Guava migration - Inline Predicate varargs methods

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

@@ -1390,9 +1390,11 @@ public class AiAttackController {
         boolean canTrampleOverDefenders = attacker.hasKeyword(Keyword.TRAMPLE) && attacker.getNetCombatDamage() > Aggregates.sum(validBlockers, Card::getNetToughness);
 
         // used to check that CanKillAllDangerous check makes sense in context where creatures with dangerous abilities are present
-        boolean dangerousBlockersPresent = Iterables.any(validBlockers, Predicates.or(
+        boolean dangerousBlockersPresent = Iterables.any(validBlockers,
-                CardPredicates.hasKeyword(Keyword.WITHER), CardPredicates.hasKeyword(Keyword.INFECT),
+                CardPredicates.hasKeyword(Keyword.WITHER)
-                CardPredicates.hasKeyword(Keyword.LIFELINK)));
+                        .or(CardPredicates.hasKeyword(Keyword.INFECT))
+                        .or(CardPredicates.hasKeyword(Keyword.LIFELINK))
+        );
 
         // total power of the defending creatures, used in predicting whether a gang block can kill the attacker
         int defPower = CardLists.getTotalPower(validBlockers, true, false);

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

@@ -1442,11 +1442,14 @@ public class SpecialCardAi {
         public static boolean consider(final Player ai, final SpellAbility sa) {
             int loyalty = sa.getHostCard().getCounters(CounterEnumType.LOYALTY);
             CardCollection creaturesToGet = CardLists.filter(ai.getCardsIn(ZoneType.Graveyard),
-                    Predicates.and(CardPredicates.Presets.CREATURES, CardPredicates.lessCMC(loyalty - 1), card -> {
+                    CardPredicates.Presets.CREATURES
-                        final Card copy = CardCopyService.getLKICopy(card);
+                        .and(CardPredicates.lessCMC(loyalty - 1))
-                        ComputerUtilCard.applyStaticContPT(ai.getGame(), copy, null);
+                        .and(card -> {
-                        return copy.getNetToughness() > 0;
+                            final Card copy = CardCopyService.getLKICopy(card);
-                    }));
+                            ComputerUtilCard.applyStaticContPT(ai.getGame(), copy, null);
+                            return copy.getNetToughness() > 0;
+                        })
+            );
             CardLists.sortByCmcDesc(creaturesToGet);
 
             if (creaturesToGet.isEmpty()) {

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

@@ -136,8 +136,11 @@ public class ChooseSourceAi extends SpellAbilityAi {
             if (!Iterables.isEmpty(options)) {
                 List<Card> oppCreatures = CardLists.filter(options, Predicates.and(CardPredicates.Presets.CREATURES,
                         Predicates.not(CardPredicates.isOwner(aiChoser))));
-                List<Card> aiNonCreatures = CardLists.filter(options, Predicates.and(Predicates.not(CardPredicates.Presets.CREATURES),
+                List<Card> aiNonCreatures = CardLists.filter(options,
-                        CardPredicates.Presets.PERMANENTS, CardPredicates.isOwner(aiChoser)));
+                        Predicates.not(CardPredicates.Presets.CREATURES)
+                                .and(CardPredicates.Presets.PERMANENTS)
+                                .and(CardPredicates.isOwner(aiChoser))
+                );
 
                 if (!oppCreatures.isEmpty()) {
                     return ComputerUtilCard.getBestCreatureAI(oppCreatures);

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

@@ -892,7 +892,11 @@ public class DamageDealAi extends DamageAiBase {
 
             // See if there's an indestructible target that can be used
             CardCollection indestructible = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield),
-                    Predicates.and(CardPredicates.Presets.CREATURES, CardPredicates.Presets.PLANESWALKERS, CardPredicates.hasKeyword(Keyword.INDESTRUCTIBLE), CardPredicates.isTargetableBy(sa)));
+                    CardPredicates.Presets.CREATURES
+                            .and(CardPredicates.Presets.PLANESWALKERS) //TODO: Should this be "or" Planeswalkers?
+                            .and(CardPredicates.hasKeyword(Keyword.INDESTRUCTIBLE))
+                            .and(CardPredicates.isTargetableBy(sa))
+            );
 
             if (!indestructible.isEmpty()) {
                 Card c = ComputerUtilCard.getWorstPermanentAI(indestructible, false, false, false, false);
@@ -905,7 +909,7 @@ public class DamageDealAi extends DamageAiBase {
             }
             else if (tgt.canTgtPlaneswalker()) {
                 // Second pass for planeswalkers: choose AI's worst planeswalker
-                final Card c = ComputerUtilCard.getWorstPlaneswalkerToDamage(CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), Predicates.and(CardPredicates.Presets.PLANESWALKERS), CardPredicates.isTargetableBy(sa)));
+                final Card c = ComputerUtilCard.getWorstPlaneswalkerToDamage(CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.PLANESWALKERS, CardPredicates.isTargetableBy(sa)));
                 if (c != null) {
                     sa.getTargets().add(c);
                     if (divided) {

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

@@ -23,12 +23,12 @@ public class MutateAi extends SpellAbilityAi {
 
         // Filter out some abilities that are useless
         // TODO: add other stuff useless for Mutate here
-        mutateTgts = CardLists.filter(mutateTgts, Predicates.not(Predicates.or(
+        mutateTgts = CardLists.filter(mutateTgts, Predicates.not(
-                CardPredicates.hasKeyword(Keyword.DEFENDER),
+                CardPredicates.hasKeyword(Keyword.DEFENDER)
-                CardPredicates.hasKeyword("CARDNAME can't attack."),
+                        .or(CardPredicates.hasKeyword("CARDNAME can't attack."))
-                CardPredicates.hasKeyword("CARDNAME can't block."),
+                        .or(CardPredicates.hasKeyword("CARDNAME can't block."))
-                card -> ComputerUtilCard.isUselessCreature(aiPlayer, card)
+                        .or(card -> ComputerUtilCard.isUselessCreature(aiPlayer, card))
-        )));
+        ));
 
         if (mutateTgts.isEmpty()) {
             return false;

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

@@ -584,9 +584,12 @@ public final class CardRulesPredicates {
                 Predicates.or(Presets.IS_CREATURE, Presets.IS_PLANESWALKER));
 
         /** The Constant IS_NON_CREATURE_SPELL. **/
-        public static final Predicate<CardRules> IS_NON_CREATURE_SPELL = Predicates
+        public static final Predicate<CardRules> IS_NON_CREATURE_SPELL =
-                .or(Presets.IS_SORCERY, Presets.IS_INSTANT, Presets.IS_PLANESWALKER, Presets.IS_ENCHANTMENT,
+            Presets.IS_SORCERY
-                        Predicates.and(Presets.IS_ARTIFACT, Predicates.not(Presets.IS_CREATURE)));
+                    .or(Presets.IS_INSTANT)
+                    .or(Presets.IS_PLANESWALKER)
+                    .or(Presets.IS_ENCHANTMENT) //TODO: Battles? Is testing these one by one really the best way to check "non-creature"?
+                    .or(Presets.IS_ARTIFACT.and(Presets.IS_CREATURE.negate()));
 
         /** The Constant isWhite. */
         public static final Predicate<CardRules> IS_WHITE = CardRulesPredicates.isColor(MagicColor.WHITE);

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

@@ -291,7 +291,7 @@ public abstract class DeckGeneratorBase {
         if (useArtifacts) {
             hasColor = Predicates.or(hasColor, COLORLESS_CARDS);
         }
-        return Iterables.filter(pool.getAllCards(), Predicates.compose(Predicates.and(canPlay, hasColor, canUseInFormat), PaperCard::getRules));
+        return Iterables.filter(pool.getAllCards(), Predicates.compose(canPlay.and(hasColor).and(canUseInFormat), PaperCard::getRules));
     }
 
     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 = Predicates.not(CardRulesPredicates.Presets.IS_BASIC_LAND);
 
-        Iterable<PaperCard> landCards = pool.getAllCards(Predicates.compose(Predicates.and(dualLandFilter, exceptBasicLand, canPlay), PaperCard::getRules));
+        Iterable<PaperCard> landCards = pool.getAllCards(Predicates.compose(dualLandFilter.and(exceptBasicLand).and(canPlay), PaperCard::getRules));
         Iterable<String> dualLandPatterns = Arrays.asList("Add \\{([WUBRG])\\} or \\{([WUBRG])\\}",
                 "Add \\{([WUBRG])\\}, \\{([WUBRG])\\}, or \\{([WUBRG])\\}",
                 "Add \\{([WUBRG])\\}\\{([WUBRG])\\}",

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

@@ -20,14 +20,14 @@ public abstract class ItemPredicate {
      * 
      * @return the predicate
      */
-    public static final Predicate<InventoryItem> IsTournamentPack = card -> card instanceof TournamentPack && !((TournamentPack) card).isStarterDeck();
+    public static final Predicate<Object> IsTournamentPack = card -> card instanceof TournamentPack && !((TournamentPack) card).isStarterDeck();
 
     /**
      * Checks that the inventory item is a Starter Deck.
      * 
      * @return the predicate
      */
-    public static final Predicate<InventoryItem> IsStarterDeck = card -> card instanceof TournamentPack && ((TournamentPack) card).isStarterDeck();
+    public static final Predicate<Object> IsStarterDeck = card -> card instanceof TournamentPack && ((TournamentPack) card).isStarterDeck();
 
     /**
      * Checks that the inventory item is a Prebuilt Deck.
@@ -40,6 +40,6 @@ public abstract class ItemPredicate {
      */
     public static class Presets {
         /** The Item IsPack. */
-        public static final Predicate<InventoryItem> IS_PACK_OR_DECK = Predicates.or(IsBoosterPack, IsFatPack, IsTournamentPack, IsStarterDeck, IsPrebuiltDeck);
+        public static final Predicate<Object> IS_PACK_OR_DECK = IsBoosterPack.or(IsFatPack).or(IsTournamentPack).or(IsStarterDeck).or(IsPrebuiltDeck);
     }
 }

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

@@ -613,31 +613,31 @@ public class BoosterGenerator {
             ps.addAll(Iterables.filter(src, predicate));
 
         } else if (mainCode.equalsIgnoreCase(BoosterSlots.UNCOMMON_RARE)) { // for sets like ARN, where U1 cards are considered rare and U3 are uncommon
-            Predicate<PaperCard> predicateRares = Predicates.and(setPred, IPaperCard.Predicates.Presets.IS_RARE, extraPred);
+            Predicate<PaperCard> predicateRares = setPred.and(Presets.IS_RARE).and(extraPred);
             ps.addAll(Iterables.filter(src, predicateRares));
 
-            Predicate<PaperCard> predicateUncommon = Predicates.and( setPred, IPaperCard.Predicates.Presets.IS_UNCOMMON, extraPred);
+            Predicate<PaperCard> predicateUncommon = setPred.and(Presets.IS_UNCOMMON).and(extraPred);
             ps.addAll(Iterables.filter(src, predicateUncommon), 3);
 
         } else if (mainCode.equalsIgnoreCase(BoosterSlots.RARE_MYTHIC)) {
             // Typical ratio of rares to mythics is 53:15, changing to 35:10 in smaller sets.
             // To achieve the desired 1:8 are all mythics are added once, and all rares added twice per print sheet.
 
-            Predicate<PaperCard> predicateMythic = Predicates.and( setPred, IPaperCard.Predicates.Presets.IS_MYTHIC_RARE, extraPred);
+            Predicate<PaperCard> predicateMythic = setPred.and(Presets.IS_MYTHIC_RARE).and(extraPred);
             ps.addAll(Iterables.filter(src, predicateMythic));
 
-            Predicate<PaperCard> predicateRare = Predicates.and( setPred, IPaperCard.Predicates.Presets.IS_RARE, extraPred);
+            Predicate<PaperCard> predicateRare = setPred.and(Presets.IS_RARE).and(extraPred);
             ps.addAll(Iterables.filter(src, predicateRare), 2);
         } else if (mainCode.equalsIgnoreCase(BoosterSlots.UNCOMMON_RARE_MYTHIC)) {
             // Extended version of RARE_MYTHIC, used for Alchemy slots
 
-            Predicate<PaperCard> predicateMythic = Predicates.and( setPred, IPaperCard.Predicates.Presets.IS_MYTHIC_RARE, extraPred);
+            Predicate<PaperCard> predicateMythic = setPred.and(Presets.IS_MYTHIC_RARE).and(extraPred);
             ps.addAll(Iterables.filter(src, predicateMythic));
 
-            Predicate<PaperCard> predicateRare = Predicates.and( setPred, IPaperCard.Predicates.Presets.IS_RARE, extraPred);
+            Predicate<PaperCard> predicateRare = setPred.and(Presets.IS_RARE).and(extraPred);
             ps.addAll(Iterables.filter(src, predicateRare), 2);
 
-            Predicate<PaperCard> predicateUncommon = Predicates.and( setPred, IPaperCard.Predicates.Presets.IS_UNCOMMON, extraPred);
+            Predicate<PaperCard> predicateUncommon = setPred.and(Presets.IS_UNCOMMON).and(extraPred);
             ps.addAll(Iterables.filter(src, predicateUncommon), 4);
         } else {
             throw new IllegalArgumentException("Booster generator: operator could not be parsed - " + mainCode);
@@ -670,10 +670,9 @@ public class BoosterGenerator {
             Predicate<PaperCard> toAdd = null;
             if (operator.equalsIgnoreCase(BoosterSlots.DUAL_FACED_CARD)) {
                 toAdd = Predicates.compose(
-                            Predicates.or(
+                        CardRulesPredicates.splitType(CardSplitType.Transform)
-                                CardRulesPredicates.splitType(CardSplitType.Transform),
+                                .or(CardRulesPredicates.splitType(CardSplitType.Meld))
-                                CardRulesPredicates.splitType(CardSplitType.Meld),
+                                .or(CardRulesPredicates.splitType(CardSplitType.Modal)
-                                CardRulesPredicates.splitType(CardSplitType.Modal)
                             ),
                         PaperCard::getRules);
             } else if (operator.equalsIgnoreCase(BoosterSlots.LAND)) {          toAdd = Predicates.compose(CardRulesPredicates.Presets.IS_LAND, PaperCard::getRules);

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

@@ -123,7 +123,7 @@ public class ItemPool<T extends InventoryItem> implements Iterable<Entry<T, Inte
     }
 
     @SuppressWarnings("unchecked")
-    public final <U extends InventoryItem> int countAll(Predicate<U> condition, Class<U> cls) {
+    public final <U extends InventoryItem> int countAll(Predicate<? super U> condition, Class<U> cls) {
         int count = 0;
         Map<T, Integer> matchingKeys = Maps.filterKeys(this.items, item -> cls.isInstance(item) && (condition.test((U)item)));
         for (Integer i : matchingKeys.values()) {

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

@@ -1,6 +1,5 @@
 package forge.util;
 
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.Objects;
 import java.util.function.Function;
@@ -14,25 +13,10 @@ public class Predicates {
         //TODO: Should be able to clean up the casting here.
         return x -> Iterables.all(components, (Predicate<Predicate<? super T>>) i -> i.test(x));
     }
-    public static <T> Predicate<T> and(Predicate<? super T>... components) {
-        //TODO: Switch to iterables all once it stops being confused and the others are inlined.
-        //Or just switch this to chained "and"s by hand.
-        return x -> {
-            for(Predicate<? super T> predicate : components) {
-                if(!predicate.test(x))
-                    return false;
-            }
-            return true;
-        };
-    }
     public static <T> Predicate<T> or(Iterable<? extends Predicate<? super T>> components) {
         //TODO: Should be able to clean up the casting here.
         return x -> Iterables.any(components, (Predicate<Predicate<? super T>>) i -> i.test(x));
     }
-    public static <T> Predicate<T> or(Predicate<? super T>... components) {
-        //TODO: Faster implementation. Or just do this one by hand.
-        return or(Arrays.asList(components));
-    }
 
     public static <A, B> Predicate<A> compose(Predicate<B> predicate, Function<A, ? extends B> function) {
         return x -> predicate.test(function.apply(x));

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

@@ -75,11 +75,12 @@ public class PlanarConquestCommanderGeneraterGA extends PlanarConquestGeneraterG
             cards.add(StaticData.instance().getCommonCards().getUniqueByName(cardName));
         }
 
-        Iterable<PaperCard> filtered= Iterables.filter(cards, Predicates.and(
+        Iterable<PaperCard> filtered= Iterables.filter(cards,
-                Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules),
+                Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules)
-                Predicates.compose(CardRulesPredicates.Presets.IS_PLANESWALKER, PaperCard::getRules),
+                        .and(Predicates.compose(CardRulesPredicates.Presets.IS_PLANESWALKER, PaperCard::getRules))
-                //Predicates.compose(CardRulesPredicates.Presets.IS_LEGENDARY, PaperCard.FN_GET_RULES),
+                        //.and(Predicates.compose(CardRulesPredicates.Presets.IS_LEGENDARY, PaperCard::getRules))
-                gameFormat.getFilterPrinted()));
+                        .and(gameFormat.getFilterPrinted())
+                );
 
         List<PaperCard> filteredList = Lists.newArrayList(filtered);
         rankedList = CardRanker.rankCardsInDeck(filteredList);

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

@@ -105,10 +105,11 @@ public class PlanarConquestGeneraterGA extends AbstractGeneticAlgorithm<Deck> {
             cards.add(StaticData.instance().getCommonCards().getUniqueByName(cardName));
         }
 
-        Iterable<PaperCard> filtered= Iterables.filter(cards, Predicates.and(
+        Iterable<PaperCard> filtered= Iterables.filter(cards,
-                Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules),
+                Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules)
-                Predicates.compose(CardRulesPredicates.Presets.IS_NON_LAND, PaperCard::getRules),
+                        .and(Predicates.compose(CardRulesPredicates.Presets.IS_NON_LAND, PaperCard::getRules))
-                gameFormat.getFilterPrinted()));
+                        .and(gameFormat.getFilterPrinted())
+        );
 
         List<PaperCard> filteredList = Lists.newArrayList(filtered);
         setRankedList(CardRanker.rankCardsInDeck(filteredList));

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

@@ -77,11 +77,12 @@ public class PlanarConquestTribalGeneraterGA extends PlanarConquestGeneraterGA {
             cards.add(StaticData.instance().getCommonCards().getUniqueByName(cardName));
         }
 
-        Iterable<PaperCard> filteredTribe= Iterables.filter(cards, Predicates.and(
+        Iterable<PaperCard> filteredTribe= Iterables.filter(cards,
-                Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules),
+                Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules)
-                Predicates.compose(CardRulesPredicates.hasCreatureType("Pirate"), PaperCard::getRules),
+                        .and(Predicates.compose(CardRulesPredicates.hasCreatureType("Pirate"), PaperCard::getRules))
-                Predicates.compose(CardRulesPredicates.Presets.IS_CREATURE, PaperCard::getRules),
+                        .and(Predicates.compose(CardRulesPredicates.Presets.IS_CREATURE, PaperCard::getRules))
-                gameFormat.getFilterPrinted()));
+                        .and(gameFormat.getFilterPrinted())
+        );
 
         List<PaperCard> filteredListTribe = Lists.newArrayList(filteredTribe);
         rankedList = CardRanker.rankCardsInDeck(filteredListTribe);

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

@@ -663,9 +663,8 @@ public class DeckgenUtil {
         // Get random multicolor Legendary creature
         final DeckFormat format = gameType.getDeckFormat();
         Predicate<CardRules> canPlay = forAi ? DeckGeneratorBase.AI_CAN_PLAY : CardRulesPredicates.IS_KEPT_IN_RANDOM_DECKS;
-        @SuppressWarnings("unchecked")
+        Predicate<PaperCard> legal = format.isLegalCardPredicate().and(format.isLegalCommanderPredicate());
-        Iterable<PaperCard> legends = cardDb.getAllCards(Predicates.and(format.isLegalCardPredicate(), format.isLegalCommanderPredicate(),
+        Iterable<PaperCard> legends = cardDb.getAllCards(legal.and(Predicates.compose(canPlay, PaperCard::getRules)));
-                Predicates.compose(canPlay, PaperCard::getRules)));
 
         commander = Aggregates.random(legends);
         return generateRandomCommanderDeck(commander, format, forAi, false);