Guava migration - Helper method for composing CardRules into PaperCards

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

@@ -205,6 +205,7 @@ public class DeckHints {
 
     private Iterable<PaperCard> getMatchingItems(Iterable<PaperCard> source, Predicate<CardRules> predicate, Function<PaperCard, CardRules> fn) {
         // TODO should token generators be counted differently for their potential?
+        // And would there ever be a circumstance where `fn` should be anything but PaperCard::getRules?
         return Iterables.filter(source, Predicates.compose(tokens ? rulesWithTokens(predicate) : predicate, fn));
     }
 

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

@@ -29,6 +29,7 @@ import forge.deck.generation.DeckGeneratorBase.FilterCMC;
 import forge.deck.generation.IDeckGenPool;
 import forge.item.IPaperCard;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.util.Aggregates;
 import forge.util.Iterables;
 import forge.util.Predicates;
@@ -540,6 +541,6 @@ public enum DeckFormat {
             //Notably, no partner ability or combination of partner abilities can ever let a player have more than two commanders.
             predicate = predicate.or(CardRulesPredicates.canBePartnerCommanderWith(commanders.get(0).getRules()));
         }
-        return Predicates.compose(predicate, PaperCard::getRules);
+        return PaperCardPredicates.fromRules(predicate);
     }
 }

forge-core/src/main/java/forge/deck/generation/DeckGeneratorBase.java

@@ -87,12 +87,12 @@ public abstract class DeckGeneratorBase {
         final Iterable<PaperCard> cards = selectCardsOfMatchingColorForPlayer(forAi);
         // build subsets based on type
 
-        final Iterable<PaperCard> creatures = Iterables.filter(cards, Predicates.compose(CardRulesPredicates.IS_CREATURE, PaperCard::getRules));
+        final Iterable<PaperCard> creatures = Iterables.filter(cards, PaperCardPredicates.fromRules(CardRulesPredicates.IS_CREATURE));
         final int creatCnt = (int) Math.ceil(getCreaturePercentage() * size);
         trace.append("Creatures to add:").append(creatCnt).append("\n");
         addCmcAdjusted(creatures, creatCnt, cmcLevels);
 
-        Predicate<PaperCard> preSpells = Predicates.compose(CardRulesPredicates.IS_NON_CREATURE_SPELL, PaperCard::getRules);
+        Predicate<PaperCard> preSpells = PaperCardPredicates.fromRules(CardRulesPredicates.IS_NON_CREATURE_SPELL);
         final Iterable<PaperCard> spells = Iterables.filter(cards, preSpells);
         final int spellCnt = (int) Math.ceil(getSpellPercentage() * size);
         trace.append("Spells to add:").append(spellCnt).append("\n");
@@ -107,11 +107,11 @@ public abstract class DeckGeneratorBase {
 
     protected boolean setBasicLandPool(String edition){
         Predicate<PaperCard> isSetBasicLand;
-        if (edition !=null){
+        if (edition != null){
             isSetBasicLand = PaperCardPredicates.printedInSet(edition)
-                    .and(Predicates.compose(CardRulesPredicates.IS_BASIC_LAND, PaperCard::getRules));
+                    .and(PaperCardPredicates.fromRules(CardRulesPredicates.IS_BASIC_LAND));
-        }else{
+        } else {
-            isSetBasicLand = Predicates.compose(CardRulesPredicates.IS_BASIC_LAND, PaperCard::getRules);
+            isSetBasicLand = PaperCardPredicates.fromRules(CardRulesPredicates.IS_BASIC_LAND);
         }
 
         landPool = new DeckGenPool(StaticData.instance().getCommonCards().getAllCards(isSetBasicLand));
@@ -234,7 +234,7 @@ public abstract class DeckGeneratorBase {
             addSome(targetSize - actualSize, tDeck.toFlatList());
         }
         else if (actualSize > targetSize) {
-            Predicate<PaperCard> exceptBasicLand = Predicates.compose(CardRulesPredicates.NOT_BASIC_LAND, PaperCard::getRules);
+            Predicate<PaperCard> exceptBasicLand = PaperCardPredicates.fromRules(CardRulesPredicates.NOT_BASIC_LAND);
 
             for (int i = 0; i < 3 && actualSize > targetSize; i++) {
                 Iterable<PaperCard> matchingCards = Iterables.filter(tDeck.toFlatList(), exceptBasicLand);
@@ -261,7 +261,7 @@ public abstract class DeckGeneratorBase {
         float requestedOverTotal = (float)cnt / totalWeight;
 
         for (ImmutablePair<FilterCMC, Integer> pair : cmcLevels) {
-            Iterable<PaperCard> matchingCards = Iterables.filter(source, Predicates.compose(pair.getLeft(), PaperCard::getRules));
+            Iterable<PaperCard> matchingCards = Iterables.filter(source, PaperCardPredicates.fromRules(pair.getLeft()));
             int cmcCountForPool = (int) Math.ceil(pair.getRight() * desiredOverTotal);
             
             int addOfThisCmc = Math.round(pair.getRight() * requestedOverTotal);
@@ -291,7 +291,7 @@ public abstract class DeckGeneratorBase {
         if (useArtifacts) {
             hasColor = hasColor.or(COLORLESS_CARDS);
         }
-        return Iterables.filter(pool.getAllCards(), Predicates.compose(canPlay.and(hasColor).and(canUseInFormat), PaperCard::getRules));
+        return Iterables.filter(pool.getAllCards(), PaperCardPredicates.fromRules(canPlay.and(hasColor).and(canUseInFormat)));
     }
 
     protected static Map<String, Integer> countLands(ItemPool<PaperCard> outList) {
@@ -390,7 +390,7 @@ public abstract class DeckGeneratorBase {
         Predicate<CardRules> dualLandFilter = CardRulesPredicates.coreType(true, CardType.CoreType.Land);
         Predicate<CardRules> exceptBasicLand = CardRulesPredicates.NOT_BASIC_LAND;
 
-        Iterable<PaperCard> landCards = pool.getAllCards(Predicates.compose(dualLandFilter.and(exceptBasicLand).and(canPlay), PaperCard::getRules));
+        Iterable<PaperCard> landCards = pool.getAllCards(PaperCardPredicates.fromRules(dualLandFilter.and(exceptBasicLand).and(canPlay)));
         Iterable<String> dualLandPatterns = Arrays.asList("Add \\{([WUBRG])\\} or \\{([WUBRG])\\}",
                 "Add \\{([WUBRG])\\}, \\{([WUBRG])\\}, or \\{([WUBRG])\\}",
                 "Add \\{([WUBRG])\\}\\{([WUBRG])\\}",

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

@@ -1,9 +1,7 @@
 package forge.item;
 
 import com.google.common.collect.Lists;
-import forge.card.CardRarity;
+import forge.card.*;
-import forge.card.CardType;
-import forge.card.MagicColor;
 import forge.util.PredicateCard;
 import forge.util.PredicateString;
 import org.apache.commons.lang3.StringUtils;
@@ -179,6 +177,11 @@ public abstract class PaperCardPredicates {
         }
     }
 
+    //TODO: Remove
+    public static Predicate<PaperCard> fromRules(Predicate<CardRules> cardRulesPredicate) {
+        return paperCard -> cardRulesPredicate.test(paperCard.getRules());
+    }
+
     public static final Predicate<PaperCard> IS_COMMON = PaperCardPredicates.rarity(true, CardRarity.Common);
     public static final Predicate<PaperCard> IS_UNCOMMON = PaperCardPredicates.rarity(true, CardRarity.Uncommon);
     public static final Predicate<PaperCard> IS_RARE = PaperCardPredicates.rarity(true, CardRarity.Rare);

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

@@ -114,7 +114,7 @@ public abstract class SealedProduct implements InventoryItemFromSet {
 
     protected List<PaperCard> getRandomBasicLands(final String setCode, final int count) {
         Predicate<PaperCard> cardsRule = PaperCardPredicates.printedInSet(setCode)
-                .and(Predicates.compose(CardRulesPredicates.IS_BASIC_LAND, PaperCard::getRules));
+                .and(PaperCardPredicates.fromRules(CardRulesPredicates.IS_BASIC_LAND));
         return Aggregates.random(Iterables.filter(StaticData.instance().getCommonCards().getAllCards(), cardsRule), count);
     }
 }

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

@@ -668,13 +668,12 @@ public class BoosterGenerator {
 
             Predicate<PaperCard> toAdd = null;
             if (operator.equalsIgnoreCase(BoosterSlots.DUAL_FACED_CARD)) {
-                toAdd = Predicates.compose(
+                toAdd = PaperCardPredicates.fromRules(
                         CardRulesPredicates.splitType(CardSplitType.Transform)
                                 .or(CardRulesPredicates.splitType(CardSplitType.Meld))
                                 .or(CardRulesPredicates.splitType(CardSplitType.Modal)
-                            ),
+                            ));
-                        PaperCard::getRules);
+            } else if (operator.equalsIgnoreCase(BoosterSlots.LAND)) {          toAdd = PaperCardPredicates.fromRules(CardRulesPredicates.IS_LAND);
-            } else if (operator.equalsIgnoreCase(BoosterSlots.LAND)) {          toAdd = Predicates.compose(CardRulesPredicates.IS_LAND, PaperCard::getRules);
             } else if (operator.equalsIgnoreCase(BoosterSlots.BASIC_LAND)) {    toAdd = PaperCardPredicates.IS_BASIC_LAND;
             } else if (operator.equalsIgnoreCase(BoosterSlots.TIME_SHIFTED)) {  toAdd = PaperCardPredicates.IS_SPECIAL;
             } else if (operator.equalsIgnoreCase(BoosterSlots.SPECIAL)) {       toAdd = PaperCardPredicates.IS_SPECIAL;

forge-game/src/main/java/forge/game/ability/effects/CopyPermanentEffect.java

@@ -5,6 +5,7 @@ import java.util.List;
 import java.util.function.Predicate;
 
 import forge.card.GamePieceType;
+import forge.item.PaperCardPredicates;
 import forge.util.*;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.mutable.MutableBoolean;
@@ -156,11 +157,11 @@ public class CopyPermanentEffect extends TokenEffectBase {
                             "X", Integer.toString(AbilityUtils.calculateAmount(host, "X", sa)));
                 }
                 if (StringUtils.containsIgnoreCase(valid, "creature")) {
-                    Predicate<PaperCard> cpp = Predicates.compose(CardRulesPredicates.IS_CREATURE, PaperCard::getRules);
+                    Predicate<PaperCard> cpp = PaperCardPredicates.fromRules(CardRulesPredicates.IS_CREATURE);
                     cards = Lists.newArrayList(Iterables.filter(cards, cpp));
                 }
                 if (StringUtils.containsIgnoreCase(valid, "equipment")) {
-                    Predicate<PaperCard> cpp = Predicates.compose(CardRulesPredicates.IS_EQUIPMENT, PaperCard::getRules);
+                    Predicate<PaperCard> cpp = PaperCardPredicates.fromRules(CardRulesPredicates.IS_EQUIPMENT);
                     cards = Lists.newArrayList(Iterables.filter(cards, cpp));
                 }
                 if (sa.hasParam("RandomCopied")) {
@@ -193,7 +194,7 @@ public class CopyPermanentEffect extends TokenEffectBase {
                     }
                 }
 
-                Predicate<PaperCard> cpp = Predicates.compose(CardRulesPredicates.name(StringOp.EQUALS, name), PaperCard::getRules);
+                Predicate<PaperCard> cpp = PaperCardPredicates.fromRules(CardRulesPredicates.name(StringOp.EQUALS, name));
                 cards = Lists.newArrayList(Iterables.filter(cards, cpp));
 
                 if (!cards.isEmpty()) {

forge-game/src/main/java/forge/game/ability/effects/PlayEffect.java

@@ -9,6 +9,7 @@ import java.util.function.Predicate;
 
 import forge.card.CardStateName;
 import forge.card.GamePieceType;
+import forge.item.PaperCardPredicates;
 import forge.util.*;
 import org.apache.commons.lang3.StringUtils;
 
@@ -121,11 +122,11 @@ public class PlayEffect extends SpellAbilityEffect {
                 }
             } else if (valid.equalsIgnoreCase("sorcery")) {
                 cards = Lists.newArrayList(StaticData.instance().getCommonCards().getUniqueCards());
-                final Predicate<PaperCard> cpp = Predicates.compose(CardRulesPredicates.IS_SORCERY, PaperCard::getRules);
+                final Predicate<PaperCard> cpp = PaperCardPredicates.fromRules(CardRulesPredicates.IS_SORCERY);
                 cards = Lists.newArrayList(Iterables.filter(cards, cpp));
             } else if (valid.equalsIgnoreCase("instant")) {
                 cards = Lists.newArrayList(StaticData.instance().getCommonCards().getUniqueCards());
-                final Predicate<PaperCard> cpp = Predicates.compose(CardRulesPredicates.IS_INSTANT, PaperCard::getRules);
+                final Predicate<PaperCard> cpp = PaperCardPredicates.fromRules(CardRulesPredicates.IS_INSTANT);
                 cards = Lists.newArrayList(Iterables.filter(cards, cpp));
             }
             if (sa.hasParam("RandomCopied")) {

forge-game/src/main/java/forge/game/ability/effects/PlayLandVariantEffect.java

@@ -16,6 +16,7 @@ import forge.game.card.CardFactory;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.util.Aggregates;
 import forge.util.Iterables;
 import forge.util.Predicates;
@@ -30,7 +31,7 @@ public class PlayLandVariantEffect extends SpellAbilityEffect {
         final String landType = sa.getParam("Clone");
         List<PaperCard> cards = Lists.newArrayList(StaticData.instance().getCommonCards().getUniqueCards());
         if ("BasicLand".equals(landType)) {
-            final Predicate<PaperCard> cpp = Predicates.compose(CardRulesPredicates.IS_BASIC_LAND, PaperCard::getRules);
+            final Predicate<PaperCard> cpp = PaperCardPredicates.fromRules(CardRulesPredicates.IS_BASIC_LAND);
             cards = Lists.newArrayList(Iterables.filter(cards, cpp));
         }
         // current color of source card

forge-game/src/main/java/forge/game/ability/effects/VentureEffect.java

@@ -3,8 +3,10 @@ package forge.game.ability.effects;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Predicate;
 
 import forge.StaticData;
+import forge.card.CardRules;
 import forge.card.CardRulesPredicates;
 import forge.game.Game;
 import forge.game.ability.AbilityKey;
@@ -21,6 +23,7 @@ import forge.game.trigger.TriggerType;
 import forge.game.trigger.WrappedAbility;
 import forge.game.zone.ZoneType;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.util.Localizer;
 import forge.util.PredicateString.StringOp;
 import forge.util.Predicates;
@@ -44,15 +47,14 @@ public class VentureEffect  extends SpellAbilityEffect {
 
         List<PaperCard> dungeonCards = null;
         if (sa.hasParam("Dungeon")) {
-            dungeonCards = StaticData.instance().getVariantCards()
+            String dungeonType = sa.getParam("Dungeon");
-                    .getAllCards(Predicates.compose(
+            Predicate<CardRules> rulesPredicate = CardRulesPredicates.IS_DUNGEON.and(CardRulesPredicates.subType(StringOp.EQUALS, dungeonType));
-                            CardRulesPredicates.IS_DUNGEON
+            dungeonCards = StaticData.instance().getVariantCards().getAllCards(
-                                    .and(CardRulesPredicates.subType(StringOp.EQUALS, sa.getParam("Dungeon"))),
+                    PaperCardPredicates.fromRules(rulesPredicate));
-                            PaperCard::getRules));
         } else {
             // Create a new dungeon card chosen by player in command zone.
             dungeonCards = StaticData.instance().getVariantCards().getAllCards(
-                Predicates.compose(CardRulesPredicates.IS_DUNGEON, PaperCard::getRules));
+                    PaperCardPredicates.fromRules(CardRulesPredicates.IS_DUNGEON));
             dungeonCards.removeIf(c -> !c.getRules().isEnterableDungeon());
         }
         String message = Localizer.getInstance().getMessage("lblChooseDungeon");

forge-gui-desktop/src/main/java/forge/itemmanager/filters/CardCMCFilter.java

@@ -8,6 +8,7 @@ import javax.swing.JPanel;
 
 import forge.card.CardRules;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.ItemManager;
 import forge.itemmanager.SItemManagerUtil.StatTypes;
 import forge.itemmanager.SpellShopManager;
@@ -55,6 +56,6 @@ public class CardCMCFilter extends StatTypeFilter<PaperCard> {
             //use custom return true delegate to validate the item is a card
             return card -> true;
         }
-        return Predicates.compose(Predicates.or(cmcs), PaperCard::getRules);
+        return PaperCardPredicates.fromRules(Predicates.or(cmcs));
     }
 }

forge-gui-desktop/src/main/java/forge/itemmanager/filters/CardCMCRangeFilter.java

@@ -3,6 +3,7 @@ package forge.itemmanager.filters;
 import forge.card.CardRules;
 import forge.card.CardRulesPredicates;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.ItemManager;
 import forge.util.Predicates;
 
@@ -33,6 +34,6 @@ public class CardCMCRangeFilter extends ValueRangeFilter<PaperCard> {
         if (predicate == null) {
             return x -> true;
         }
-        return Predicates.compose(predicate, PaperCard::getRules);
+        return PaperCardPredicates.fromRules(predicate);
     }
 }

forge-gui-desktop/src/main/java/forge/itemmanager/filters/CardPowerFilter.java

@@ -3,6 +3,7 @@ package forge.itemmanager.filters;
 import forge.card.CardRules;
 import forge.card.CardRulesPredicates;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.ItemManager;
 import forge.util.Predicates;
 
@@ -34,6 +35,6 @@ public class CardPowerFilter extends ValueRangeFilter<PaperCard> {
             return x -> true;
         }
         predicate = predicate.and(CardRulesPredicates.IS_CREATURE);
-        return Predicates.compose(predicate, PaperCard::getRules);
+        return PaperCardPredicates.fromRules(predicate);
     }
 }

forge-gui-desktop/src/main/java/forge/itemmanager/filters/CardToughnessFilter.java

@@ -3,6 +3,7 @@ package forge.itemmanager.filters;
 import forge.card.CardRules;
 import forge.card.CardRulesPredicates;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.ItemManager;
 import forge.util.Predicates;
 
@@ -34,6 +35,6 @@ public class CardToughnessFilter extends ValueRangeFilter<PaperCard> {
             return x -> true;
         }
         predicate = predicate.and(CardRulesPredicates.IS_CREATURE);
-        return Predicates.compose(predicate, PaperCard::getRules);
+        return PaperCardPredicates.fromRules(predicate);
     }
 }

forge-gui-desktop/src/main/java/forge/itemmanager/filters/CardTypeFilter.java

@@ -8,6 +8,7 @@ import javax.swing.JPanel;
 
 import forge.card.CardRules;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.ItemManager;
 import forge.itemmanager.SItemManagerUtil.StatTypes;
 import forge.itemmanager.SpellShopManager;
@@ -53,6 +54,6 @@ public class CardTypeFilter extends StatTypeFilter<PaperCard> {
             //use custom return true delegate to validate the item is a card
             return card -> true;
         }
-        return Predicates.compose(Predicates.or(types), PaperCard::getRules);
+        return PaperCardPredicates.fromRules(Predicates.or(types));
     }
 }

forge-gui-desktop/src/main/java/forge/itemmanager/filters/StatTypeFilter.java

@@ -10,6 +10,7 @@ import forge.gui.UiCommand;
 import forge.item.InventoryItem;
 import forge.item.ItemPredicate;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.ItemManager;
 import forge.itemmanager.SFilterUtil;
 import forge.itemmanager.SItemManagerUtil.StatTypes;
@@ -76,7 +77,7 @@ public abstract class StatTypeFilter<T extends InventoryItem> extends ToggleButt
 
         for (StatTypes statTypes : buttonMap.keySet()) {
             if (statTypes.predicate != null) {
-                int count = items.countAll(Predicates.compose(statTypes.predicate, PaperCard::getRules), PaperCard.class);
+                int count = items.countAll(PaperCardPredicates.fromRules(statTypes.predicate), PaperCard.class);
                 buttonMap.get(statTypes).setText(String.valueOf(count));
             }
         }

forge-gui-desktop/src/main/java/forge/screens/deckeditor/controllers/CDeckgen.java

@@ -16,6 +16,7 @@ import forge.gui.UiCommand;
 import forge.gui.framework.ICDoc;
 import forge.item.InventoryItem;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.localinstance.properties.ForgePreferences.FPref;
 import forge.model.FModel;
 import forge.screens.deckeditor.CDeckEditorUI;
@@ -70,7 +71,7 @@ public enum CDeckgen implements ICDoc {
 
         final Deck randomDeck = new Deck();
 
-        final Predicate<PaperCard> notBasicLand = Predicates.compose(CardRulesPredicates.NOT_BASIC_LAND, PaperCard::getRules);
+        final Predicate<PaperCard> notBasicLand = PaperCardPredicates.fromRules(CardRulesPredicates.NOT_BASIC_LAND);
         final Iterable<PaperCard> source = Iterables.filter(FModel.getMagicDb().getCommonCards().getUniqueCards(), notBasicLand);
         randomDeck.getMain().addAllFlat(Aggregates.random(source, 15 * 5));
 

forge-gui-desktop/src/main/java/forge/screens/deckeditor/controllers/CEditorCommander.java

@@ -28,6 +28,7 @@ import forge.gui.UiCommand;
 import forge.gui.framework.DragCell;
 import forge.gui.framework.FScreen;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.CardManager;
 import forge.itemmanager.ItemManagerConfig;
 import forge.model.CardCollections;
@@ -83,14 +84,14 @@ public final class CEditorCommander extends CDeckEditor<Deck> {
         if (gameType == GameType.Brawl){
             GameFormat format = FModel.getFormats().get("Brawl");
             Predicate<CardRules> commanderFilter = CardRulesPredicates.CAN_BE_BRAWL_COMMANDER;
-            commanderPool = ItemPool.createFrom(commonCards.getAllCardsNoAlt(format.getFilterPrinted().and(Predicates.compose(commanderFilter, PaperCard::getRules))), PaperCard.class);
+            commanderPool = ItemPool.createFrom(commonCards.getAllCardsNoAlt(format.getFilterPrinted().and(PaperCardPredicates.fromRules(commanderFilter))), PaperCard.class);
             normalPool = ItemPool.createFrom(format.getAllCards(), PaperCard.class);
         }
         else {
             Predicate<CardRules> commanderFilter = gameType == GameType.Oathbreaker
                     ? CardRulesPredicates.CAN_BE_OATHBREAKER.or(CardRulesPredicates.CAN_BE_SIGNATURE_SPELL)
                     : CardRulesPredicates.CAN_BE_COMMANDER;
-            commanderPool = ItemPool.createFrom(commonCards.getAllCardsNoAlt(Predicates.compose(commanderFilter, PaperCard::getRules)),PaperCard.class);
+            commanderPool = ItemPool.createFrom(commonCards.getAllCardsNoAlt(PaperCardPredicates.fromRules(commanderFilter)),PaperCard.class);
             normalPool = ItemPool.createFrom(commonCards.getAllCardsNoAlt(), PaperCard.class);
         }
 

forge-gui-desktop/src/main/java/forge/screens/deckeditor/controllers/CEditorQuest.java

@@ -44,6 +44,7 @@ import forge.gui.framework.DragCell;
 import forge.gui.framework.FScreen;
 import forge.item.InventoryItem;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.CardManager;
 import forge.itemmanager.ColumnDef;
 import forge.itemmanager.ItemManagerConfig;
@@ -346,7 +347,7 @@ public final class CEditorQuest extends CDeckEditor<Deck> {
     }
 
     private ItemPool<PaperCard> getCommanderCardPool(){
-        Predicate<PaperCard> commanderPredicate = Predicates.compose(CardRulesPredicates.CAN_BE_COMMANDER, PaperCard::getRules);
+        Predicate<PaperCard> commanderPredicate = PaperCardPredicates.fromRules(CardRulesPredicates.CAN_BE_COMMANDER);
         return getRemainingCardPool().getFilteredPool(commanderPredicate);
     }
 

forge-gui-desktop/src/main/java/forge/screens/deckeditor/controllers/CStatistics.java

@@ -12,6 +12,7 @@ import forge.deck.DeckBase;
 import forge.gui.framework.ICDoc;
 import forge.item.InventoryItem;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.SItemManagerUtil.StatTypes;
 import forge.screens.deckeditor.CDeckEditorUI;
 import forge.screens.deckeditor.views.VStatistics;
@@ -51,7 +52,7 @@ public enum CStatistics implements ICDoc {
     }
 
     private void setLabelValue(final JLabel label, final ItemPool<PaperCard> deck, final Predicate<CardRules> predicate, final int total) {
-        final int tmp = deck.countAll(Predicates.compose(predicate, PaperCard::getRules));
+        final int tmp = deck.countAll(PaperCardPredicates.fromRules(predicate));
         label.setText(tmp + " (" + calculatePercentage(tmp, total) + "%)");
     }
 

forge-gui-desktop/src/main/java/forge/screens/deckeditor/controllers/CStatisticsImporter.java

@@ -7,6 +7,7 @@ import forge.deck.CardPool;
 import forge.deck.DeckRecognizer;
 import forge.deck.DeckSection;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.SItemManagerUtil;
 import forge.screens.deckeditor.views.VStatisticsImporter;
 import forge.util.ItemPool;
@@ -100,7 +101,7 @@ public class CStatisticsImporter {
     }
 
     private void setLabelValue(final JLabel label, final ItemPool<PaperCard> deck, final Predicate<CardRules> predicate, final int total) {
-        final int tmp = deck.countAll(Predicates.compose(predicate, PaperCard::getRules));
+        final int tmp = deck.countAll(PaperCardPredicates.fromRules(predicate));
         label.setText(tmp + " (" + calculatePercentage(tmp, total) + "%)");
     }
 

forge-gui-desktop/src/test/java/forge/planarconquestgenerate/PlanarConquestCommanderGeneraterGA.java

@@ -20,6 +20,7 @@ import forge.game.GameType;
 import forge.gamemodes.limited.CardRanker;
 import forge.gui.GuiBase;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.localinstance.properties.ForgeConstants;
 import forge.localinstance.properties.ForgePreferences;
 import forge.model.FModel;
@@ -76,10 +77,10 @@ public class PlanarConquestCommanderGeneraterGA extends PlanarConquestGeneraterG
         }
 
         Iterable<PaperCard> filtered= Iterables.filter(cards,
-                Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules)
+                PaperCardPredicates.fromRules(CardRulesPredicates.IS_KEPT_IN_AI_DECKS
-                        .and(Predicates.compose(CardRulesPredicates.IS_PLANESWALKER, PaperCard::getRules))
+                                .and(CardRulesPredicates.IS_PLANESWALKER)
-                        //.and(Predicates.compose(CardRulesPredicates.IS_LEGENDARY, PaperCard::getRules))
+                                //.and(CardRulesPredicates.IS_LEGENDARY)
-                        .and(gameFormat.getFilterPrinted())
+                        ).and(gameFormat.getFilterPrinted())
                 );
 
         List<PaperCard> filteredList = Lists.newArrayList(filtered);

forge-gui-desktop/src/test/java/forge/planarconquestgenerate/PlanarConquestGeneraterGA.java

@@ -5,6 +5,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
+import forge.item.PaperCardPredicates;
 import forge.util.*;
 import org.apache.commons.lang3.tuple.Pair;
 
@@ -106,9 +107,9 @@ public class PlanarConquestGeneraterGA extends AbstractGeneticAlgorithm<Deck> {
         }
 
         Iterable<PaperCard> filtered= Iterables.filter(cards,
-                Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules)
+                PaperCardPredicates.fromRules(CardRulesPredicates.IS_KEPT_IN_AI_DECKS
-                        .and(Predicates.compose(CardRulesPredicates.IS_NON_LAND, PaperCard::getRules))
+                                .and(CardRulesPredicates.IS_NON_LAND)
-                        .and(gameFormat.getFilterPrinted())
+                        ).and(gameFormat.getFilterPrinted())
         );
 
         List<PaperCard> filteredList = Lists.newArrayList(filtered);

forge-gui-desktop/src/test/java/forge/planarconquestgenerate/PlanarConquestTribalGeneraterGA.java

@@ -19,6 +19,7 @@ import forge.game.GameType;
 import forge.gamemodes.limited.CardRanker;
 import forge.gui.GuiBase;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.localinstance.properties.ForgeConstants;
 import forge.localinstance.properties.ForgePreferences;
 import forge.model.FModel;
@@ -78,10 +79,10 @@ public class PlanarConquestTribalGeneraterGA extends PlanarConquestGeneraterGA {
         }
 
         Iterable<PaperCard> filteredTribe= Iterables.filter(cards,
-                Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules)
+                PaperCardPredicates.fromRules(CardRulesPredicates.IS_KEPT_IN_AI_DECKS
-                        .and(Predicates.compose(CardRulesPredicates.hasCreatureType("Pirate"), PaperCard::getRules))
+                                .and(CardRulesPredicates.hasCreatureType("Pirate"))
-                        .and(Predicates.compose(CardRulesPredicates.IS_CREATURE, PaperCard::getRules))
+                                .and(CardRulesPredicates.IS_CREATURE)
-                        .and(gameFormat.getFilterPrinted())
+                        ).and(gameFormat.getFilterPrinted())
         );
 
         List<PaperCard> filteredListTribe = Lists.newArrayList(filteredTribe);

forge-gui-mobile/src/forge/adventure/character/EnemySprite.java

@@ -30,6 +30,7 @@ import forge.card.CardRulesPredicates;
 import forge.deck.CardPool;
 import forge.deck.Deck;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.util.Aggregates;
 import forge.util.MyRandom;
 import forge.util.Predicates;
@@ -481,7 +482,7 @@ public class EnemySprite extends CharacterSprite implements Steerable<Vector2> {
             if(data.rewards != null) { //Collect standard rewards.
                 Deck enemyDeck = Current.latestDeck();
                 // By popular demand, remove basic lands from the reward pool.
-                CardPool deckNoBasicLands = enemyDeck.getMain().getFilteredPool(Predicates.compose(CardRulesPredicates.NOT_BASIC_LAND, PaperCard::getRules));
+                CardPool deckNoBasicLands = enemyDeck.getMain().getFilteredPool(PaperCardPredicates.fromRules(CardRulesPredicates.NOT_BASIC_LAND));
 
                 for (RewardData rdata : data.rewards) {
                     ret.addAll(rdata.generate(false,  enemyDeck == null ? null : deckNoBasicLands.toFlatList(),true ));

forge-gui-mobile/src/forge/itemmanager/filters/CardCMCFilter.java

@@ -3,6 +3,7 @@ package forge.itemmanager.filters;
 import forge.card.CardRules;
 import forge.card.CardRulesPredicates;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.ItemManager;
 import forge.util.Predicates;
 
@@ -30,6 +31,6 @@ public class CardCMCFilter extends ValueRangeFilter<PaperCard> {
         if (predicate == null) {
             return x -> true;
         }
-        return Predicates.compose(predicate, PaperCard::getRules);
+        return PaperCardPredicates.fromRules(predicate);
     }
 }

forge-gui-mobile/src/forge/itemmanager/filters/CardColorlessCostFilter.java

@@ -3,6 +3,7 @@ package forge.itemmanager.filters;
 import forge.card.CardRules;
 import forge.card.CardRulesPredicates;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.ItemManager;
 import forge.util.Predicates;
 
@@ -30,6 +31,6 @@ public class CardColorlessCostFilter extends ValueRangeFilter<PaperCard> {
         if (predicate == null) {
             return x -> true;
         }
-        return Predicates.compose(predicate, PaperCard::getRules);
+        return PaperCardPredicates.fromRules(predicate);
     }
 }

forge-gui-mobile/src/forge/itemmanager/filters/CardPowerFilter.java

@@ -3,6 +3,7 @@ package forge.itemmanager.filters;
 import forge.card.CardRules;
 import forge.card.CardRulesPredicates;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.ItemManager;
 import forge.util.Predicates;
 
@@ -31,6 +32,6 @@ public class CardPowerFilter extends ValueRangeFilter<PaperCard> {
             return x -> true;
         }
         predicate = predicate.and(CardRulesPredicates.IS_CREATURE);
-        return Predicates.compose(predicate, PaperCard::getRules);
+        return PaperCardPredicates.fromRules(predicate);
     }
 }

forge-gui-mobile/src/forge/itemmanager/filters/CardToughnessFilter.java

@@ -3,6 +3,7 @@ package forge.itemmanager.filters;
 import forge.card.CardRules;
 import forge.card.CardRulesPredicates;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.ItemManager;
 import forge.util.Predicates;
 
@@ -31,6 +32,6 @@ public class CardToughnessFilter extends ValueRangeFilter<PaperCard> {
             return x -> true;
         }
         predicate = predicate.and(CardRulesPredicates.IS_CREATURE);
-        return Predicates.compose(predicate, PaperCard::getRules);
+        return PaperCardPredicates.fromRules(predicate);
     }
 }

forge-gui-mobile/src/forge/itemmanager/filters/CardTypeFilter.java

@@ -6,6 +6,7 @@ import java.util.function.Predicate;
 
 import forge.card.CardRules;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.ItemManager;
 import forge.itemmanager.SItemManagerUtil.StatTypes;
 import forge.util.Predicates;
@@ -50,6 +51,6 @@ public class CardTypeFilter extends StatTypeFilter<PaperCard> {
             //use custom return true delegate to validate the item is a card
             return card -> true;
         }
-        return Predicates.compose(Predicates.or(types), PaperCard::getRules);
+        return PaperCardPredicates.fromRules(Predicates.or(types));
     }
 }

forge-gui/src/main/java/forge/deck/CardRelationMatrixGenerator.java

@@ -10,6 +10,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import forge.item.PaperCardPredicates;
 import forge.util.Iterables;
 import forge.util.Predicates;
 import org.apache.commons.lang3.ArrayUtils;
@@ -73,8 +74,8 @@ public final class CardRelationMatrixGenerator {
                 ForgeConstants.DECK_GEN_DIR, false),
                 true);
 
-        final Iterable<PaperCard> cards = Iterables.filter(format.getAllCards()
+        final Iterable<PaperCard> cards = Iterables.filter(format.getAllCards(),
-                , Predicates.compose(CardRulesPredicates.NOT_TRUE_BASIC_LAND, PaperCard::getRules));
+                PaperCardPredicates.fromRules(CardRulesPredicates.NOT_TRUE_BASIC_LAND));
         List<PaperCard> cardList = Lists.newArrayList(cards);
         cardList.add(FModel.getMagicDb().getCommonCards().getCard("Wastes"));
         Map<String, Integer> cardIntegerMap = new HashMap<>();
@@ -90,7 +91,7 @@ public final class CardRelationMatrixGenerator {
             for (Deck deck:decks){
                 if (deck.getMain().contains(card)){
                     for (PaperCard pairCard:Iterables.filter(deck.getMain().toFlatList(),
-                            Predicates.compose(CardRulesPredicates.NOT_TRUE_BASIC_LAND, PaperCard::getRules))){
+                            PaperCardPredicates.fromRules(CardRulesPredicates.NOT_TRUE_BASIC_LAND))){
                         if (!pairCard.getName().equals(card.getName())){
                             try {
                                 int old = matrix[cardIntegerMap.get(card.getName())][cardIntegerMap.get(pairCard.getName())];
@@ -142,8 +143,8 @@ public final class CardRelationMatrixGenerator {
                 true);
 
         //get all cards
-        final Iterable<PaperCard> cards = Iterables.filter(FModel.getMagicDb().getCommonCards().getUniqueCards()
+        final Iterable<PaperCard> cards = Iterables.filter(FModel.getMagicDb().getCommonCards().getUniqueCards(),
-                , Predicates.compose(CardRulesPredicates.NOT_TRUE_BASIC_LAND, PaperCard::getRules));
+                PaperCardPredicates.fromRules(CardRulesPredicates.NOT_TRUE_BASIC_LAND));
         List<PaperCard> cardList = Lists.newArrayList(cards);
         cardList.add(FModel.getMagicDb().getCommonCards().getCard("Wastes"));
         Map<String, Integer> cardIntegerMap = new HashMap<>();
@@ -200,7 +201,7 @@ public final class CardRelationMatrixGenerator {
     public static void updateLegendMatrix(Deck deck, PaperCard legend, Map<String, Integer> cardIntegerMap,
                              Map<String, Integer> legendIntegerMap, int[][] matrix){
         for (PaperCard pairCard:Iterables.filter(deck.getMain().toFlatList(),
-                Predicates.compose(CardRulesPredicates.NOT_TRUE_BASIC_LAND, PaperCard::getRules))){
+                PaperCardPredicates.fromRules(CardRulesPredicates.NOT_TRUE_BASIC_LAND))){
             if (!pairCard.getName().equals(legend.getName())){
                 try {
                     int old = matrix[legendIntegerMap.get(legend.getName())][cardIntegerMap.get(pairCard.getName())];

forge-gui/src/main/java/forge/deck/CommanderDeckGenerator.java

@@ -10,6 +10,7 @@ import forge.card.CardRules;
 import forge.card.CardRulesPredicates;
 import forge.deck.generation.DeckGeneratorBase;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.model.FModel;
 import forge.util.ItemPool;
 import forge.util.Iterables;
@@ -41,7 +42,7 @@ public class CommanderDeckGenerator extends DeckProxy implements Comparable<Comm
         Predicate<CardRules> canPlay = isForAi ? DeckGeneratorBase.AI_CAN_PLAY : CardRulesPredicates.IS_KEPT_IN_RANDOM_DECKS;
         @SuppressWarnings("unchecked")
         Iterable<PaperCard> legends = Iterables.filter(uniqueCards.toFlatList(), format.isLegalCommanderPredicate()
-                .and(Predicates.compose(canPlay, PaperCard::getRules)));
+                .and(PaperCardPredicates.fromRules(canPlay)));
         final List<DeckProxy> decks = new ArrayList<>();
         for (PaperCard legend: legends) {
             decks.add(new CommanderDeckGenerator(legend, format, isForAi, isCardGen));
@@ -65,7 +66,7 @@ public class CommanderDeckGenerator extends DeckProxy implements Comparable<Comm
         Predicate<CardRules> canPlay = isForAi ? DeckGeneratorBase.AI_CAN_PLAY : CardRulesPredicates.IS_KEPT_IN_RANDOM_DECKS;
         @SuppressWarnings("unchecked")
         Iterable<PaperCard> legends = Iterables.filter(uniqueCards.toFlatList(), format.isLegalCardPredicate()
-                .and(Predicates.compose(CardRulesPredicates.CAN_BE_BRAWL_COMMANDER.and(canPlay), PaperCard::getRules)));
+                .and(PaperCardPredicates.fromRules(CardRulesPredicates.CAN_BE_BRAWL_COMMANDER.and(canPlay))));
         final List<DeckProxy> decks = new ArrayList<>();
         for (PaperCard legend: legends) {
             decks.add(new CommanderDeckGenerator(legend, format, isForAi, isCardGen));

forge-gui/src/main/java/forge/deck/DeckgenUtil.java

@@ -215,8 +215,8 @@ public class DeckgenUtil {
             System.out.println("Wrong card count "+deck.getMain().countAll());
             deck=buildLDACArchetypeDeck(format,isForAI);
         }
-        if(deck.getMain().countAll(Predicates.compose(CardRulesPredicates.IS_LAND, PaperCard::getRules))>27){
+        if(deck.getMain().countAll(PaperCardPredicates.fromRules(CardRulesPredicates.IS_LAND))>27){
-            System.out.println("Too many lands "+deck.getMain().countAll(Predicates.compose(CardRulesPredicates.IS_LAND, PaperCard::getRules)));
+            System.out.println("Too many lands "+deck.getMain().countAll(PaperCardPredicates.fromRules(CardRulesPredicates.IS_LAND)));
             deck=buildLDACArchetypeDeck(format,isForAI);
         }
         while(deck.get(DeckSection.Sideboard).countAll()>15){
@@ -314,8 +314,8 @@ public class DeckgenUtil {
             System.out.println("Wrong card count "+deck.getMain().countAll());
             deck=buildLDACArchetypeDeck(format,isForAI);
         }
-        if(deck.getMain().countAll(Predicates.compose(CardRulesPredicates.IS_LAND, PaperCard::getRules))>27){
+        if(deck.getMain().countAll(PaperCardPredicates.fromRules(CardRulesPredicates.IS_LAND))>27){
-            System.out.println("Too many lands "+deck.getMain().countAll(Predicates.compose(CardRulesPredicates.IS_LAND, PaperCard::getRules)));
+            System.out.println("Too many lands "+deck.getMain().countAll(PaperCardPredicates.fromRules(CardRulesPredicates.IS_LAND)));
             deck=buildLDACArchetypeDeck(format,isForAI);
         }
         while(deck.get(DeckSection.Sideboard).countAll()>15){
@@ -667,7 +667,7 @@ public class DeckgenUtil {
         final DeckFormat format = gameType.getDeckFormat();
         Predicate<CardRules> canPlay = forAi ? DeckGeneratorBase.AI_CAN_PLAY : CardRulesPredicates.IS_KEPT_IN_RANDOM_DECKS;
         Predicate<PaperCard> legal = format.isLegalCardPredicate().and(format.isLegalCommanderPredicate());
-        Iterable<PaperCard> legends = cardDb.getAllCards(legal.and(Predicates.compose(canPlay, PaperCard::getRules)));
+        Iterable<PaperCard> legends = cardDb.getAllCards(legal.and(PaperCardPredicates.fromRules(canPlay)));
 
         commander = Aggregates.random(legends);
         return generateRandomCommanderDeck(commander, format, forAi, false);
@@ -761,10 +761,9 @@ public class DeckgenUtil {
             cardDb = FModel.getMagicDb().getCommonCards();
             //shuffle first 400 random cards
             Iterable<PaperCard> colorList = Iterables.filter(format.getCardPool(cardDb).getAllCards(),
-                    format.isLegalCardPredicate().and(Predicates.compose(
+                    format.isLegalCardPredicate().and(PaperCardPredicates.fromRules(
                             new CardThemedDeckBuilder.MatchColorIdentity(commander.getRules().getColorIdentity())
-                                    .or(DeckGeneratorBase.COLORLESS_CARDS),
+                                    .or(DeckGeneratorBase.COLORLESS_CARDS))));
-                            PaperCard::getRules)));
             switch (format) {
             case Brawl: //for Brawl - add additional filterprinted rule to remove old reprints for a consistent look
                 colorList = Iterables.filter(colorList,FModel.getFormats().getStandard().getFilterPrinted());
@@ -842,7 +841,7 @@ public class DeckgenUtil {
 
         // determine how many additional lands we need, but don't take lands already in deck into consideration,
         // or we risk incorrectly determining the target deck size
-        int numLands = Iterables.size(Iterables.filter(cards, Predicates.compose(CardRulesPredicates.IS_LAND, PaperCard::getRules)));
+        int numLands = Iterables.size(Iterables.filter(cards, PaperCardPredicates.fromRules(CardRulesPredicates.IS_LAND)));
         int sizeNoLands = cards.size() - numLands;
 
         // attempt to determine if building for sealed, constructed or EDH

forge-gui/src/main/java/forge/gamemodes/limited/CardThemedCommanderDeckBuilder.java

@@ -9,6 +9,7 @@ import forge.card.ColorSet;
 import forge.deck.DeckFormat;
 import forge.deck.generation.DeckGenPool;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.model.FModel;
 import forge.util.Iterables;
 import forge.util.Predicates;
@@ -26,7 +27,7 @@ public class CardThemedCommanderDeckBuilder extends CardThemedDeckBuilder {
         // remove Unplayables
         if(isForAI) {
             final Iterable<PaperCard> playables = Iterables.filter(availableList,
-                    Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules));
+                    PaperCardPredicates.fromRules(CardRulesPredicates.IS_KEPT_IN_AI_DECKS));
             this.aiPlayables = Lists.newArrayList(playables);
         }else{
             this.aiPlayables = Lists.newArrayList(availableList);

forge-gui/src/main/java/forge/gamemodes/limited/CardThemedConquestDeckBuilder.java

@@ -10,6 +10,7 @@ import forge.deck.DeckFormat;
 import forge.deck.generation.DeckGenPool;
 import forge.game.GameFormat;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.model.FModel;
 import forge.util.Iterables;
 import forge.util.Predicates;
@@ -30,7 +31,7 @@ public class CardThemedConquestDeckBuilder extends CardThemedDeckBuilder {
         // remove Unplayables
         if(isForAI) {
             final Iterable<PaperCard> playables = Iterables.filter(availableList,
-                    Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules));
+                    PaperCardPredicates.fromRules(CardRulesPredicates.IS_KEPT_IN_AI_DECKS));
             this.aiPlayables = Lists.newArrayList(playables);
         }else{
             this.aiPlayables = Lists.newArrayList(availableList);

forge-gui/src/main/java/forge/gamemodes/limited/CardThemedDeckBuilder.java

@@ -106,7 +106,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
         // remove Unplayables
         if(isForAI) {
             final Iterable<PaperCard> playables = Iterables.filter(availableList,
-                    Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules));
+                    PaperCardPredicates.fromRules(CardRulesPredicates.IS_KEPT_IN_AI_DECKS));
             this.aiPlayables = Lists.newArrayList(playables);
         }else{
             this.aiPlayables = Lists.newArrayList(availableList);
@@ -190,11 +190,11 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
             System.out.println("Colors: " + colors.toEnumSet().toString());
         }
         Iterable<PaperCard> colorList = Iterables.filter(aiPlayables,
-                Predicates.compose(hasColor, PaperCard::getRules));
+                PaperCardPredicates.fromRules(hasColor));
         rankedColorList = Lists.newArrayList(colorList);
         onColorCreaturesAndSpells = Iterables.filter(rankedColorList,
-                Predicates.compose(CardRulesPredicates.IS_CREATURE
+                PaperCardPredicates.fromRules(CardRulesPredicates.IS_CREATURE
-                        .or(CardRulesPredicates.IS_NON_CREATURE_SPELL), PaperCard::getRules));
+                        .or(CardRulesPredicates.IS_NON_CREATURE_SPELL)));
 
         // Guava iterables do not copy the collection contents, instead they act
         // as filters and iterate over _source_ collection each time. So even if
@@ -320,8 +320,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
         //Add remaining non-land colour matching cards to sideboard
         final CardPool cp = result.getOrCreate(DeckSection.Sideboard);
         Iterable<PaperCard> potentialSideboard = Iterables.filter(aiPlayables,
-                Predicates.compose(hasColor, PaperCard::getRules)
+                PaperCardPredicates.fromRules(hasColor.and(CardRulesPredicates.IS_NON_LAND)));
-                        .and(Predicates.compose(CardRulesPredicates.IS_NON_LAND, PaperCard::getRules)));
         int i=0;
         while(i<15 && potentialSideboard.iterator().hasNext()){
             PaperCard sbCard = potentialSideboard.iterator().next();
@@ -463,7 +462,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
     protected void addThirdColorCards(int num) {
         if (num > 0) {
             final Iterable<PaperCard> others = Iterables.filter(aiPlayables,
-                    Predicates.compose(CardRulesPredicates.IS_NON_LAND, PaperCard::getRules));
+                    PaperCardPredicates.fromRules(CardRulesPredicates.IS_NON_LAND));
             // We haven't yet ranked the off-color cards.
             // Compare them to the cards already in the deckList.
             //List<PaperCard> rankedOthers = CardRanker.rankCardsInPack(others, deckList, colors, true);
@@ -480,7 +479,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
             hasColor = CardRulesPredicates.IS_NON_LAND.and(new MatchColorIdentity(colors)
                     .or(DeckGeneratorBase.COLORLESS_CARDS));
             final Iterable<PaperCard> threeColorList = Iterables.filter(aiPlayables,
-                    Predicates.compose(hasColor, PaperCard::getRules));
+                    PaperCardPredicates.fromRules(hasColor));
             for (final PaperCard card : threeColorList) {
                 if (num > 0) {
                     toAdd.add(card);
@@ -500,7 +499,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
 
     protected void addLowCMCCard(){
         final Iterable<PaperCard> nonLands = Iterables.filter(rankedColorList,
-                Predicates.compose(CardRulesPredicates.IS_NON_LAND, PaperCard::getRules));
+                PaperCardPredicates.fromRules(CardRulesPredicates.IS_NON_LAND));
         final PaperCard card = Iterables.getFirst(nonLands, null);
         if (card != null) {
             deckList.add(card);
@@ -523,9 +522,9 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
         Predicate<PaperCard> isSetBasicLand;
         if (edition !=null){
             isSetBasicLand = PaperCardPredicates.printedInSet(edition)
-                    .and(Predicates.compose(CardRulesPredicates.IS_BASIC_LAND, PaperCard::getRules));
+                    .and(PaperCardPredicates.fromRules(CardRulesPredicates.IS_BASIC_LAND));
-        }else{
+        } else {
-            isSetBasicLand = Predicates.compose(CardRulesPredicates.IS_BASIC_LAND, PaperCard::getRules);
+            isSetBasicLand = PaperCardPredicates.fromRules(CardRulesPredicates.IS_BASIC_LAND);
         }
 
         landPool = new DeckGenPool(format.getCardPool(fullCardDB).getAllCards(isSetBasicLand));
@@ -668,7 +667,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
      */
     private void addLands(final int[] clrCnts) {
         // basic lands that are available in the deck
-        final Iterable<PaperCard> basicLands = Iterables.filter(aiPlayables, Predicates.compose(CardRulesPredicates.IS_BASIC_LAND, PaperCard::getRules));
+        final Iterable<PaperCard> basicLands = Iterables.filter(aiPlayables, PaperCardPredicates.fromRules(CardRulesPredicates.IS_BASIC_LAND));
 
         // total of all ClrCnts
         int totalColor = 0;
@@ -810,7 +809,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
      */
     private void addNonBasicLands() {
         Iterable<PaperCard> lands = Iterables.filter(aiPlayables,
-                Predicates.compose(CardRulesPredicates.IS_NONBASIC_LAND, PaperCard::getRules));
+                PaperCardPredicates.fromRules(CardRulesPredicates.IS_NONBASIC_LAND));
         List<PaperCard> landsToAdd = new ArrayList<>();
         int minBasics;//Keep a minimum number of basics to ensure playable decks
         if(colors.isColorless()) {
@@ -824,7 +823,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
         }
 
         lands = Iterables.filter(aiPlayables,
-                Predicates.compose(CardRulesPredicates.IS_NONBASIC_LAND, PaperCard::getRules));
+                PaperCardPredicates.fromRules(CardRulesPredicates.IS_NONBASIC_LAND));
 
         for (final PaperCard card : lands) {
             if (landsNeeded > minBasics) {
@@ -924,8 +923,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
         for (int i = 1; i < 7; i++) {
             creatureCosts.put(i, 0);
         }
-        final Predicate<PaperCard> filter = Predicates.compose(CardRulesPredicates.IS_CREATURE,
+        final Predicate<PaperCard> filter = PaperCardPredicates.fromRules(CardRulesPredicates.IS_CREATURE);
-                PaperCard::getRules);
         for (final IPaperCard creature : Iterables.filter(deckList, filter)) {
             int cmc = creature.getRules().getManaCost().getCMC();
             if (cmc < 1) {

forge-gui/src/main/java/forge/gamemodes/limited/LimitedDeckBuilder.java

@@ -26,6 +26,7 @@ import forge.deck.DeckSection;
 import forge.deck.generation.DeckGeneratorBase;
 import forge.item.IPaperCard;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.model.FModel;
 import forge.util.Iterables;
 import forge.util.MyRandom;
@@ -83,13 +84,13 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
 
         // remove Unplayables
         final Iterable<PaperCard> playables = Iterables.filter(availableList,
-                Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_LIMITED_DECKS, PaperCard::getRules));
+                PaperCardPredicates.fromRules(CardRulesPredicates.IS_KEPT_IN_AI_LIMITED_DECKS));
         this.aiPlayables = Lists.newArrayList(playables);
         this.availableList.removeAll(aiPlayables);
 
         // keep Conspiracies in a separate list
         final Iterable<PaperCard> conspiracies = Iterables.filter(aiPlayables,
-                Predicates.compose(CardRulesPredicates.coreType(true, "Conspiracy"), PaperCard::getRules));
+                PaperCardPredicates.fromRules(CardRulesPredicates.coreType(true, "Conspiracy")));
         this.draftedConspiracies = Lists.newArrayList(conspiracies);
         this.aiPlayables.removeAll(draftedConspiracies);
 
@@ -136,19 +137,19 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
         // 1. Prepare
         hasColor = new MatchColorIdentity(colors).or(COLORLESS_CARDS);
         Iterable<PaperCard> colorList = Iterables.filter(aiPlayables,
-                Predicates.compose(hasColor, PaperCard::getRules));
+                PaperCardPredicates.fromRules(hasColor));
         rankedColorList = CardRanker.rankCardsInDeck(colorList);
         onColorCreatures = Iterables.filter(rankedColorList,
-                Predicates.compose(CardRulesPredicates.IS_CREATURE, PaperCard::getRules));
+                PaperCardPredicates.fromRules(CardRulesPredicates.IS_CREATURE));
         onColorNonCreatures = Iterables.filter(rankedColorList,
-                Predicates.compose(CardRulesPredicates.IS_NON_CREATURE_SPELL, PaperCard::getRules));
+                PaperCardPredicates.fromRules(CardRulesPredicates.IS_NON_CREATURE_SPELL));
         // Guava iterables do not copy the collection contents, instead they act
         // as filters and iterate over _source_ collection each time. So even if
         // aiPlayable has changed, there is no need to create a new iterable.
 
         // 2. Add any planeswalkers
         final Iterable<PaperCard> onColorWalkers = Iterables.filter(colorList,
-                Predicates.compose(CardRulesPredicates.IS_PLANESWALKER, PaperCard::getRules));
+                PaperCardPredicates.fromRules(CardRulesPredicates.IS_PLANESWALKER));
         final List<PaperCard> walkers = Lists.newArrayList(onColorWalkers);
         deckList.addAll(walkers);
         aiPlayables.removeAll(walkers);
@@ -171,7 +172,7 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
         // an extra.
         if (deckList.size() == numSpellsNeeded && getAverageCMC(deckList) < 4) {
             final Iterable<PaperCard> nonLands = Iterables.filter(rankedColorList,
-                    Predicates.compose(CardRulesPredicates.IS_NON_LAND, PaperCard::getRules));
+                    PaperCardPredicates.fromRules(CardRulesPredicates.IS_NON_LAND));
             final PaperCard card = Iterables.getFirst(nonLands, null);
             if (card != null) {
                 deckList.add(card);
@@ -342,7 +343,8 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
      */
     private void addLands(final int[] clrCnts, final String landSetCode) {
         // basic lands that are available in the deck
-        final Iterable<PaperCard> basicLands = Iterables.filter(aiPlayables, Predicates.compose(CardRulesPredicates.IS_BASIC_LAND, PaperCard::getRules));
+        final Iterable<PaperCard> basicLands = Iterables.filter(aiPlayables,
+                PaperCardPredicates.fromRules(CardRulesPredicates.IS_BASIC_LAND));
         final Set<PaperCard> snowLands = new HashSet<>();
 
         // total of all ClrCnts
@@ -455,7 +457,7 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
      */
     private void addNonBasicLands() {
         final Iterable<PaperCard> lands = Iterables.filter(aiPlayables,
-                Predicates.compose(CardRulesPredicates.IS_NONBASIC_LAND, PaperCard::getRules));
+                PaperCardPredicates.fromRules(CardRulesPredicates.IS_NONBASIC_LAND));
         List<PaperCard> landsToAdd = new ArrayList<>();
         for (final PaperCard card : lands) {
             if (landsNeeded > 0) {
@@ -483,7 +485,7 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
     private void addThirdColorCards(int num) {
         if (num > 0) {
             final Iterable<PaperCard> others = Iterables.filter(aiPlayables,
-                    Predicates.compose(CardRulesPredicates.IS_NON_LAND, PaperCard::getRules));
+                    PaperCardPredicates.fromRules(CardRulesPredicates.IS_NON_LAND));
             // We haven't yet ranked the off-color cards.
             // Compare them to the cards already in the deckList.
             List<PaperCard> rankedOthers = CardRanker.rankCardsInPack(others, deckList, colors, true);
@@ -499,7 +501,7 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
 
             hasColor = new MatchColorIdentity(colors).or(DeckGeneratorBase.COLORLESS_CARDS);
             final Iterable<PaperCard> threeColorList = Iterables.filter(rankedOthers,
-                    Predicates.compose(hasColor, PaperCard::getRules));
+                    PaperCardPredicates.fromRules(hasColor));
             for (final PaperCard card : threeColorList) {
                 if (num > 0) {
                     toAdd.add(card);
@@ -526,7 +528,7 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
      */
     private void addRandomCards(int num) {
         final Iterable<PaperCard> others = Iterables.filter(aiPlayables,
-                Predicates.compose(CardRulesPredicates.IS_NON_LAND, PaperCard::getRules));
+                PaperCardPredicates.fromRules(CardRulesPredicates.IS_NON_LAND));
         List <PaperCard> toAdd = new ArrayList<>();
         for (final PaperCard card : others) {
             if (num > 0) {
@@ -669,8 +671,7 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
         for (int i = 1; i < 7; i++) {
             creatureCosts.put(i, 0);
         }
-        final Predicate<PaperCard> filter = Predicates.compose(CardRulesPredicates.IS_CREATURE,
+        final Predicate<PaperCard> filter = PaperCardPredicates.fromRules(CardRulesPredicates.IS_CREATURE);
-                PaperCard::getRules);
         for (final IPaperCard creature : Iterables.filter(deckList, filter)) {
             int cmc = creature.getRules().getManaCost().getCMC();
             if (cmc < 1) {

forge-gui/src/main/java/forge/gamemodes/limited/LimitedPlayerAI.java

@@ -7,6 +7,7 @@ import forge.deck.Deck;
 import forge.deck.DeckSection;
 import forge.deck.generation.DeckGeneratorBase;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.localinstance.properties.ForgePreferences;
 import forge.util.Iterables;
 import forge.util.MyRandom;
@@ -265,7 +266,7 @@ public class LimitedPlayerAI extends LimitedPlayer {
 
         DeckGeneratorBase.MatchColorIdentity hasColor = new DeckGeneratorBase.MatchColorIdentity(colors);
         Iterable<PaperCard> colorList = Iterables.filter(deckCards,
-                Predicates.compose(hasColor, PaperCard::getRules).negate());
+                PaperCardPredicates.fromRules(hasColor).negate());
 
         PaperCard exchangeCard = null;
 

forge-gui/src/main/java/forge/gamemodes/planarconquest/ConquestRegion.java

@@ -12,6 +12,7 @@ import forge.deck.generation.DeckGenPool;
 import forge.game.card.Card;
 import forge.gui.GuiBase;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.localinstance.skin.ISkinImage;
 import forge.model.FModel;
 import forge.util.Predicates;
@@ -130,7 +131,7 @@ public class ConquestRegion {
                     break;
                 case "colors":
                     colorSet = ColorSet.fromNames(value.toCharArray());
-                    pred = Predicates.compose(CardRulesPredicates.hasColorIdentity(colorSet.getColor()), PaperCard::getRules);
+                    pred = PaperCardPredicates.fromRules(CardRulesPredicates.hasColorIdentity(colorSet.getColor()));
                     break;
                 case "sets":
                     final String[] sets = value.split(",");

forge-gui/src/main/java/forge/gamemodes/quest/BoosterUtils.java

@@ -305,7 +305,7 @@ public final class BoosterUtils {
                         if (preferredColors.contains(MagicColor.COLORLESS) && preferredColors.size() == 1) {
 
                             Predicate<CardRules> predicateRules =  CardRulesPredicates.cost(StringOp.CONTAINS_IC, "p/");
-                            Predicate<PaperCard> predicateCard = Predicates.compose(predicateRules, PaperCard::getRules);
+                            Predicate<PaperCard> predicateCard = PaperCardPredicates.fromRules(predicateRules);
 
                             int size = Iterables.size(Iterables.filter(cardPool, predicateCard));
                             int totalSize = cardPool.size();
@@ -324,7 +324,7 @@ public final class BoosterUtils {
                         //Try to get multicolored cards that fit into the preferred colors.
                         Predicate<CardRules> predicateRules = CardRulesPredicates.isColor(preferredColors.get(index))
                                 .and(CardRulesPredicates.IS_MULTICOLOR);
-                        Predicate<PaperCard> predicateCard = Predicates.compose(predicateRules, PaperCard::getRules);
+                        Predicate<PaperCard> predicateCard = PaperCardPredicates.fromRules(predicateRules);
 
                         //Adjust for the number of multicolored possibilities. This prevents flooding of non-selected
                         //colors if multicolored cards aren't in the selected sets. The more multi-colored cards in the
@@ -401,7 +401,7 @@ public final class BoosterUtils {
                 //handful of multi-colored cards.
                 do {
                     if (color2 != null) {
-                        Predicate<PaperCard> color2c = Predicates.compose(color2, PaperCard::getRules);
+                        Predicate<PaperCard> color2c = PaperCardPredicates.fromRules(color2);
                         card = Aggregates.random(Iterables.filter(source, filter.and(color2c)));
                     }
                 } while (card == null && colorMisses++ < 10);
@@ -483,7 +483,7 @@ public final class BoosterUtils {
             if (temp.length > 2) {
                 Predicate<CardRules> cr = parseRulesLimitation(temp[1]);
                 if (cr != null) {
-                    preds.add(Predicates.compose(cr, PaperCard::getRules));
+                    preds.add(PaperCardPredicates.fromRules(cr));
                 }
             }
 

forge-gui/src/main/java/forge/gamemodes/quest/QuestRewardCard.java

@@ -106,7 +106,7 @@ public abstract class QuestRewardCard implements IQuestRewardCard {
         }
 
         if (filterRules != null) {
-            final Predicate<PaperCard> rulesPrinted = Predicates.compose(filterRules, PaperCard::getRules);
+            final Predicate<PaperCard> rulesPrinted = PaperCardPredicates.fromRules(filterRules);
             filters = filters.and(rulesPrinted);
         }
         if (filterRarity != null) {

forge-gui/src/main/java/forge/itemmanager/SFilterUtil.java

@@ -19,6 +19,7 @@ import forge.gamemodes.quest.data.StarRating;
 import forge.gui.interfaces.IButton;
 import forge.item.InventoryItem;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.SItemManagerUtil.StatTypes;
 import forge.localinstance.properties.ForgePreferences;
 import forge.model.FModel;
@@ -50,7 +51,7 @@ public class SFilterUtil {
             try {
                 Predicate<CardRules> filter = expression.evaluate();
                 if (filter != null) {
-                    return Predicates.compose(invert ? filter.negate() : filter, PaperCard::getRules);
+                    return PaperCardPredicates.fromRules(invert ? filter.negate() : filter);
                 }
             }
             catch (Exception ignored) {
@@ -74,7 +75,7 @@ public class SFilterUtil {
         Predicate<CardRules> textFilter;
         textFilter = invert ? Predicates.or(terms).negate() : Predicates.and(terms);
 
-        return Predicates.compose(textFilter, PaperCard::getRules);
+        return PaperCardPredicates.fromRules(textFilter);
     }
 
     private static List<String> getSplitText(String text) {

forge-gui/src/main/java/forge/model/FModel.java

@@ -49,6 +49,7 @@ import forge.gui.GuiBase;
 import forge.gui.card.CardPreferences;
 import forge.gui.interfaces.IProgressBar;
 import forge.item.PaperCard;
+import forge.item.PaperCardPredicates;
 import forge.itemmanager.ItemManagerConfig;
 import forge.localinstance.achievements.*;
 import forge.localinstance.properties.ForgeConstants;
@@ -324,13 +325,13 @@ public final class FModel {
 
     public static ItemPool<PaperCard> getArchenemyCards() {
         if (archenemyCards == null)
-            return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(Predicates.compose(CardRulesPredicates.IS_SCHEME, PaperCard::getRules)), PaperCard.class);
+            return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(PaperCardPredicates.fromRules(CardRulesPredicates.IS_SCHEME)), PaperCard.class);
         return archenemyCards;
     }
 
     public static ItemPool<PaperCard> getPlanechaseCards() {
         if (planechaseCards == null)
-            return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(Predicates.compose(CardRulesPredicates.IS_PLANE_OR_PHENOMENON, PaperCard::getRules)), PaperCard.class);
+            return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(PaperCardPredicates.fromRules(CardRulesPredicates.IS_PLANE_OR_PHENOMENON)), PaperCard.class);
         return planechaseCards;
     }
 
@@ -338,7 +339,7 @@ public final class FModel {
         if (brawlCommander == null) {
             return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(
                     FModel.getFormats().get("Brawl").getFilterPrinted()
-                            .and(Predicates.compose(CardRulesPredicates.CAN_BE_BRAWL_COMMANDER, PaperCard::getRules))
+                            .and(PaperCardPredicates.fromRules(CardRulesPredicates.CAN_BE_BRAWL_COMMANDER))
             ), PaperCard.class);
         }
         return brawlCommander;
@@ -346,44 +347,50 @@ public final class FModel {
 
     public static ItemPool<PaperCard> getOathbreakerCommander() {
         if (oathbreakerCommander == null)
-            return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(Predicates.compose(
+            return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(PaperCardPredicates.fromRules(
-                    CardRulesPredicates.CAN_BE_OATHBREAKER.or(CardRulesPredicates.CAN_BE_SIGNATURE_SPELL), PaperCard::getRules)), PaperCard.class);
+                    CardRulesPredicates.CAN_BE_OATHBREAKER.or(CardRulesPredicates.CAN_BE_SIGNATURE_SPELL))), PaperCard.class);
         return oathbreakerCommander;
     }
 
     public static ItemPool<PaperCard> getTinyLeadersCommander() {
         if (tinyLeadersCommander == null)
-            return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(Predicates.compose(CardRulesPredicates.CAN_BE_TINY_LEADERS_COMMANDER, PaperCard::getRules)), PaperCard.class);
+            return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(PaperCardPredicates.fromRules(
+                    CardRulesPredicates.CAN_BE_TINY_LEADERS_COMMANDER)), PaperCard.class);
         return tinyLeadersCommander;
     }
 
     public static ItemPool<PaperCard> getCommanderPool() {
         if (commanderPool == null)
-            return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(Predicates.compose(CardRulesPredicates.CAN_BE_COMMANDER, PaperCard::getRules)), PaperCard.class);
+            return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(PaperCardPredicates.fromRules(
+                    CardRulesPredicates.CAN_BE_COMMANDER)), PaperCard.class);
         return commanderPool;
     }
 
     public static ItemPool<PaperCard> getAvatarPool() {
         if (avatarPool == null)
-            return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(Predicates.compose(CardRulesPredicates.IS_VANGUARD, PaperCard::getRules)), PaperCard.class);
+            return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(PaperCardPredicates.fromRules(
+                    CardRulesPredicates.IS_VANGUARD)), PaperCard.class);
         return avatarPool;
     }
 
     public static ItemPool<PaperCard> getConspiracyPool() {
         if (conspiracyPool == null)
-            return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(Predicates.compose(CardRulesPredicates.IS_CONSPIRACY, PaperCard::getRules)), PaperCard.class);
+            return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(PaperCardPredicates.fromRules(
+                    CardRulesPredicates.IS_CONSPIRACY)), PaperCard.class);
         return conspiracyPool;
     }
 
     public static ItemPool<PaperCard> getDungeonPool() {
         if (dungeonPool == null)
-            return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(Predicates.compose(CardRulesPredicates.IS_DUNGEON, PaperCard::getRules)), PaperCard.class);
+            return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(PaperCardPredicates.fromRules(
+                    CardRulesPredicates.IS_DUNGEON)), PaperCard.class);
         return dungeonPool;
     }
 
     public static ItemPool<PaperCard> getAttractionPool() {
         if (attractionPool == null)
-            return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(Predicates.compose(CardRulesPredicates.IS_ATTRACTION, PaperCard::getRules)), PaperCard.class);
+            return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(PaperCardPredicates.fromRules(
+                    CardRulesPredicates.IS_ATTRACTION)), PaperCard.class);
         return attractionPool;
     }
     private static boolean keywordsLoaded = false;

forge-lda/src/main/java/forge/lda/LDAModelGenetrator.java

@@ -11,6 +11,7 @@ import forge.deck.io.Archetype;
 import forge.deck.io.CardThemedLDAIO;
 import forge.deck.io.DeckStorage;
 import forge.gui.GuiBase;
+import forge.item.PaperCardPredicates;
 import forge.lda.dataset.Dataset;
 import forge.lda.lda.LDA;
 import forge.game.GameFormat;
@@ -290,8 +291,8 @@ public final class LDAModelGenetrator {
                 true);
 
         //get all cards
-        final Iterable<PaperCard> cards = Iterables.filter(FModel.getMagicDb().getCommonCards().getUniqueCards()
+        final Iterable<PaperCard> cards = Iterables.filter(FModel.getMagicDb().getCommonCards().getUniqueCards(),
-                , Predicates.compose(CardRulesPredicates.NOT_TRUE_BASIC_LAND, PaperCard::getRules));
+                PaperCardPredicates.fromRules(CardRulesPredicates.NOT_TRUE_BASIC_LAND));
         List<PaperCard> cardList = Lists.newArrayList(cards);
         cardList.add(FModel.getMagicDb().getCommonCards().getCard("Wastes"));
         Map<String, Integer> cardIntegerMap = new HashMap<>();
@@ -305,9 +306,9 @@ public final class LDAModelGenetrator {
         }
 
         //filter to just legal commanders
-        List<PaperCard> legends = Lists.newArrayList(Iterables.filter(cardList,Predicates.compose(
+        List<PaperCard> legends = Lists.newArrayList(Iterables.filter(cardList, PaperCardPredicates.fromRules(
-                DeckFormat.Commander::isLegalCommander, PaperCard::getRules
+                DeckFormat.Commander::isLegalCommander))
-        )));
+        );
 
         //generate lookups for legends to link commander names to matrix rows
         for (int i=0; i<legends.size(); ++i){
@@ -350,7 +351,7 @@ public final class LDAModelGenetrator {
     public static void updateLegendMatrix(Deck deck, PaperCard legend, Map<String, Integer> cardIntegerMap,
                              Map<String, Integer> legendIntegerMap, int[][] matrix){
         for (PaperCard pairCard:Iterables.filter(deck.getMain().toFlatList(),
-                Predicates.compose(CardRulesPredicates.NOT_TRUE_BASIC_LAND, PaperCard::getRules))){
+                PaperCardPredicates.fromRules(CardRulesPredicates.NOT_TRUE_BASIC_LAND))){
             if (!pairCard.getName().equals(legend.getName())){
                 try {
                     int old = matrix[legendIntegerMap.get(legend.getName())][cardIntegerMap.get(pairCard.getName())];