From 055dff71ce4e8d2df12a29ecb464e5795669a65b Mon Sep 17 00:00:00 2001 From: Jetz Date: Mon, 2 Sep 2024 19:36:39 -0400 Subject: [PATCH] Guava migration - Inline Predicate varargs methods --- .../java/forge/ai/AiAttackController.java | 8 ++++--- .../src/main/java/forge/ai/SpecialCardAi.java | 13 +++++++----- .../java/forge/ai/ability/ChooseSourceAi.java | 7 +++++-- .../java/forge/ai/ability/DamageDealAi.java | 8 +++++-- .../main/java/forge/ai/ability/MutateAi.java | 12 +++++------ .../java/forge/card/CardRulesPredicates.java | 9 +++++--- .../deck/generation/DeckGeneratorBase.java | 4 ++-- .../main/java/forge/item/ItemPredicate.java | 6 +++--- .../item/generation/BoosterGenerator.java | 21 +++++++++---------- .../src/main/java/forge/util/ItemPool.java | 2 +- .../src/main/java/forge/util/Predicates.java | 16 -------------- .../PlanarConquestCommanderGeneraterGA.java | 11 +++++----- .../PlanarConquestGeneraterGA.java | 9 ++++---- .../PlanarConquestTribalGeneraterGA.java | 11 +++++----- .../src/main/java/forge/deck/DeckgenUtil.java | 5 ++--- 15 files changed, 71 insertions(+), 71 deletions(-) diff --git a/forge-ai/src/main/java/forge/ai/AiAttackController.java b/forge-ai/src/main/java/forge/ai/AiAttackController.java index 44cb8791eae..6994fd30551 100644 --- a/forge-ai/src/main/java/forge/ai/AiAttackController.java +++ b/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( - CardPredicates.hasKeyword(Keyword.WITHER), CardPredicates.hasKeyword(Keyword.INFECT), - CardPredicates.hasKeyword(Keyword.LIFELINK))); + boolean dangerousBlockersPresent = Iterables.any(validBlockers, + CardPredicates.hasKeyword(Keyword.WITHER) + .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); diff --git a/forge-ai/src/main/java/forge/ai/SpecialCardAi.java b/forge-ai/src/main/java/forge/ai/SpecialCardAi.java index 74818e0f4fd..e60d336706d 100644 --- a/forge-ai/src/main/java/forge/ai/SpecialCardAi.java +++ b/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 -> { - final Card copy = CardCopyService.getLKICopy(card); - ComputerUtilCard.applyStaticContPT(ai.getGame(), copy, null); - return copy.getNetToughness() > 0; - })); + CardPredicates.Presets.CREATURES + .and(CardPredicates.lessCMC(loyalty - 1)) + .and(card -> { + final Card copy = CardCopyService.getLKICopy(card); + ComputerUtilCard.applyStaticContPT(ai.getGame(), copy, null); + return copy.getNetToughness() > 0; + }) + ); CardLists.sortByCmcDesc(creaturesToGet); if (creaturesToGet.isEmpty()) { diff --git a/forge-ai/src/main/java/forge/ai/ability/ChooseSourceAi.java b/forge-ai/src/main/java/forge/ai/ability/ChooseSourceAi.java index 00e3897a962..af422a05b0c 100644 --- a/forge-ai/src/main/java/forge/ai/ability/ChooseSourceAi.java +++ b/forge-ai/src/main/java/forge/ai/ability/ChooseSourceAi.java @@ -136,8 +136,11 @@ public class ChooseSourceAi extends SpellAbilityAi { if (!Iterables.isEmpty(options)) { List oppCreatures = CardLists.filter(options, Predicates.and(CardPredicates.Presets.CREATURES, Predicates.not(CardPredicates.isOwner(aiChoser)))); - List aiNonCreatures = CardLists.filter(options, Predicates.and(Predicates.not(CardPredicates.Presets.CREATURES), - CardPredicates.Presets.PERMANENTS, CardPredicates.isOwner(aiChoser))); + List aiNonCreatures = CardLists.filter(options, + Predicates.not(CardPredicates.Presets.CREATURES) + .and(CardPredicates.Presets.PERMANENTS) + .and(CardPredicates.isOwner(aiChoser)) + ); if (!oppCreatures.isEmpty()) { return ComputerUtilCard.getBestCreatureAI(oppCreatures); diff --git a/forge-ai/src/main/java/forge/ai/ability/DamageDealAi.java b/forge-ai/src/main/java/forge/ai/ability/DamageDealAi.java index 5061ce21dba..b75d7351c8c 100644 --- a/forge-ai/src/main/java/forge/ai/ability/DamageDealAi.java +++ b/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) { diff --git a/forge-ai/src/main/java/forge/ai/ability/MutateAi.java b/forge-ai/src/main/java/forge/ai/ability/MutateAi.java index 2c1abf84698..c5086824cf3 100644 --- a/forge-ai/src/main/java/forge/ai/ability/MutateAi.java +++ b/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( - CardPredicates.hasKeyword(Keyword.DEFENDER), - CardPredicates.hasKeyword("CARDNAME can't attack."), - CardPredicates.hasKeyword("CARDNAME can't block."), - card -> ComputerUtilCard.isUselessCreature(aiPlayer, card) - ))); + mutateTgts = CardLists.filter(mutateTgts, Predicates.not( + CardPredicates.hasKeyword(Keyword.DEFENDER) + .or(CardPredicates.hasKeyword("CARDNAME can't attack.")) + .or(CardPredicates.hasKeyword("CARDNAME can't block.")) + .or(card -> ComputerUtilCard.isUselessCreature(aiPlayer, card)) + )); if (mutateTgts.isEmpty()) { return false; diff --git a/forge-core/src/main/java/forge/card/CardRulesPredicates.java b/forge-core/src/main/java/forge/card/CardRulesPredicates.java index 7492ba47fd0..121e2b48502 100644 --- a/forge-core/src/main/java/forge/card/CardRulesPredicates.java +++ b/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 IS_NON_CREATURE_SPELL = Predicates - .or(Presets.IS_SORCERY, Presets.IS_INSTANT, Presets.IS_PLANESWALKER, Presets.IS_ENCHANTMENT, - Predicates.and(Presets.IS_ARTIFACT, Predicates.not(Presets.IS_CREATURE))); + public static final Predicate IS_NON_CREATURE_SPELL = + Presets.IS_SORCERY + .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 IS_WHITE = CardRulesPredicates.isColor(MagicColor.WHITE); diff --git a/forge-core/src/main/java/forge/deck/generation/DeckGeneratorBase.java b/forge-core/src/main/java/forge/deck/generation/DeckGeneratorBase.java index 3b8fd8cab97..49175708333 100644 --- a/forge-core/src/main/java/forge/deck/generation/DeckGeneratorBase.java +++ b/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 countLands(ItemPool outList) { @@ -390,7 +390,7 @@ public abstract class DeckGeneratorBase { Predicate dualLandFilter = CardRulesPredicates.coreType(true, CardType.CoreType.Land); Predicate exceptBasicLand = Predicates.not(CardRulesPredicates.Presets.IS_BASIC_LAND); - Iterable landCards = pool.getAllCards(Predicates.compose(Predicates.and(dualLandFilter, exceptBasicLand, canPlay), PaperCard::getRules)); + Iterable landCards = pool.getAllCards(Predicates.compose(dualLandFilter.and(exceptBasicLand).and(canPlay), PaperCard::getRules)); Iterable dualLandPatterns = Arrays.asList("Add \\{([WUBRG])\\} or \\{([WUBRG])\\}", "Add \\{([WUBRG])\\}, \\{([WUBRG])\\}, or \\{([WUBRG])\\}", "Add \\{([WUBRG])\\}\\{([WUBRG])\\}", diff --git a/forge-core/src/main/java/forge/item/ItemPredicate.java b/forge-core/src/main/java/forge/item/ItemPredicate.java index 29169cbfd24..bf6fd13f0cf 100644 --- a/forge-core/src/main/java/forge/item/ItemPredicate.java +++ b/forge-core/src/main/java/forge/item/ItemPredicate.java @@ -20,14 +20,14 @@ public abstract class ItemPredicate { * * @return the predicate */ - public static final Predicate IsTournamentPack = card -> card instanceof TournamentPack && !((TournamentPack) card).isStarterDeck(); + public static final Predicate IsTournamentPack = card -> card instanceof TournamentPack && !((TournamentPack) card).isStarterDeck(); /** * Checks that the inventory item is a Starter Deck. * * @return the predicate */ - public static final Predicate IsStarterDeck = card -> card instanceof TournamentPack && ((TournamentPack) card).isStarterDeck(); + public static final Predicate 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 IS_PACK_OR_DECK = Predicates.or(IsBoosterPack, IsFatPack, IsTournamentPack, IsStarterDeck, IsPrebuiltDeck); + public static final Predicate IS_PACK_OR_DECK = IsBoosterPack.or(IsFatPack).or(IsTournamentPack).or(IsStarterDeck).or(IsPrebuiltDeck); } } diff --git a/forge-core/src/main/java/forge/item/generation/BoosterGenerator.java b/forge-core/src/main/java/forge/item/generation/BoosterGenerator.java index 3f8d3fa1e48..4b49a0e2883 100644 --- a/forge-core/src/main/java/forge/item/generation/BoosterGenerator.java +++ b/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 predicateRares = Predicates.and(setPred, IPaperCard.Predicates.Presets.IS_RARE, extraPred); + Predicate predicateRares = setPred.and(Presets.IS_RARE).and(extraPred); ps.addAll(Iterables.filter(src, predicateRares)); - Predicate predicateUncommon = Predicates.and( setPred, IPaperCard.Predicates.Presets.IS_UNCOMMON, extraPred); + Predicate 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 predicateMythic = Predicates.and( setPred, IPaperCard.Predicates.Presets.IS_MYTHIC_RARE, extraPred); + Predicate predicateMythic = setPred.and(Presets.IS_MYTHIC_RARE).and(extraPred); ps.addAll(Iterables.filter(src, predicateMythic)); - Predicate predicateRare = Predicates.and( setPred, IPaperCard.Predicates.Presets.IS_RARE, extraPred); + Predicate 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 predicateMythic = Predicates.and( setPred, IPaperCard.Predicates.Presets.IS_MYTHIC_RARE, extraPred); + Predicate predicateMythic = setPred.and(Presets.IS_MYTHIC_RARE).and(extraPred); ps.addAll(Iterables.filter(src, predicateMythic)); - Predicate predicateRare = Predicates.and( setPred, IPaperCard.Predicates.Presets.IS_RARE, extraPred); + Predicate predicateRare = setPred.and(Presets.IS_RARE).and(extraPred); ps.addAll(Iterables.filter(src, predicateRare), 2); - Predicate predicateUncommon = Predicates.and( setPred, IPaperCard.Predicates.Presets.IS_UNCOMMON, extraPred); + Predicate 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 toAdd = null; if (operator.equalsIgnoreCase(BoosterSlots.DUAL_FACED_CARD)) { toAdd = Predicates.compose( - Predicates.or( - CardRulesPredicates.splitType(CardSplitType.Transform), - CardRulesPredicates.splitType(CardSplitType.Meld), - CardRulesPredicates.splitType(CardSplitType.Modal) + CardRulesPredicates.splitType(CardSplitType.Transform) + .or(CardRulesPredicates.splitType(CardSplitType.Meld)) + .or(CardRulesPredicates.splitType(CardSplitType.Modal) ), PaperCard::getRules); } else if (operator.equalsIgnoreCase(BoosterSlots.LAND)) { toAdd = Predicates.compose(CardRulesPredicates.Presets.IS_LAND, PaperCard::getRules); diff --git a/forge-core/src/main/java/forge/util/ItemPool.java b/forge-core/src/main/java/forge/util/ItemPool.java index 669663ad053..b3ab7cdae17 100644 --- a/forge-core/src/main/java/forge/util/ItemPool.java +++ b/forge-core/src/main/java/forge/util/ItemPool.java @@ -123,7 +123,7 @@ public class ItemPool implements Iterable int countAll(Predicate condition, Class cls) { + public final int countAll(Predicate condition, Class cls) { int count = 0; Map matchingKeys = Maps.filterKeys(this.items, item -> cls.isInstance(item) && (condition.test((U)item))); for (Integer i : matchingKeys.values()) { diff --git a/forge-core/src/main/java/forge/util/Predicates.java b/forge-core/src/main/java/forge/util/Predicates.java index c69729fa1cf..a737dff836b 100644 --- a/forge-core/src/main/java/forge/util/Predicates.java +++ b/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>) i -> i.test(x)); } - public static Predicate and(Predicate... 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 predicate : components) { - if(!predicate.test(x)) - return false; - } - return true; - }; - } public static Predicate or(Iterable> components) { //TODO: Should be able to clean up the casting here. return x -> Iterables.any(components, (Predicate>) i -> i.test(x)); } - public static Predicate or(Predicate... components) { - //TODO: Faster implementation. Or just do this one by hand. - return or(Arrays.asList(components)); - } public static Predicate compose(Predicate predicate, Function function) { return x -> predicate.test(function.apply(x)); diff --git a/forge-gui-desktop/src/test/java/forge/planarconquestgenerate/PlanarConquestCommanderGeneraterGA.java b/forge-gui-desktop/src/test/java/forge/planarconquestgenerate/PlanarConquestCommanderGeneraterGA.java index 9d126931fc5..43f55d30bfd 100644 --- a/forge-gui-desktop/src/test/java/forge/planarconquestgenerate/PlanarConquestCommanderGeneraterGA.java +++ b/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 filtered= Iterables.filter(cards, Predicates.and( - Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules), - Predicates.compose(CardRulesPredicates.Presets.IS_PLANESWALKER, PaperCard::getRules), - //Predicates.compose(CardRulesPredicates.Presets.IS_LEGENDARY, PaperCard.FN_GET_RULES), - gameFormat.getFilterPrinted())); + Iterable filtered= Iterables.filter(cards, + Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules) + .and(Predicates.compose(CardRulesPredicates.Presets.IS_PLANESWALKER, PaperCard::getRules)) + //.and(Predicates.compose(CardRulesPredicates.Presets.IS_LEGENDARY, PaperCard::getRules)) + .and(gameFormat.getFilterPrinted()) + ); List filteredList = Lists.newArrayList(filtered); rankedList = CardRanker.rankCardsInDeck(filteredList); diff --git a/forge-gui-desktop/src/test/java/forge/planarconquestgenerate/PlanarConquestGeneraterGA.java b/forge-gui-desktop/src/test/java/forge/planarconquestgenerate/PlanarConquestGeneraterGA.java index 23efc3e1bf2..7a2534bfc25 100644 --- a/forge-gui-desktop/src/test/java/forge/planarconquestgenerate/PlanarConquestGeneraterGA.java +++ b/forge-gui-desktop/src/test/java/forge/planarconquestgenerate/PlanarConquestGeneraterGA.java @@ -105,10 +105,11 @@ public class PlanarConquestGeneraterGA extends AbstractGeneticAlgorithm { cards.add(StaticData.instance().getCommonCards().getUniqueByName(cardName)); } - Iterable filtered= Iterables.filter(cards, Predicates.and( - Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules), - Predicates.compose(CardRulesPredicates.Presets.IS_NON_LAND, PaperCard::getRules), - gameFormat.getFilterPrinted())); + Iterable filtered= Iterables.filter(cards, + Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules) + .and(Predicates.compose(CardRulesPredicates.Presets.IS_NON_LAND, PaperCard::getRules)) + .and(gameFormat.getFilterPrinted()) + ); List filteredList = Lists.newArrayList(filtered); setRankedList(CardRanker.rankCardsInDeck(filteredList)); diff --git a/forge-gui-desktop/src/test/java/forge/planarconquestgenerate/PlanarConquestTribalGeneraterGA.java b/forge-gui-desktop/src/test/java/forge/planarconquestgenerate/PlanarConquestTribalGeneraterGA.java index 522006db748..59d110880b1 100644 --- a/forge-gui-desktop/src/test/java/forge/planarconquestgenerate/PlanarConquestTribalGeneraterGA.java +++ b/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 filteredTribe= Iterables.filter(cards, Predicates.and( - Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules), - Predicates.compose(CardRulesPredicates.hasCreatureType("Pirate"), PaperCard::getRules), - Predicates.compose(CardRulesPredicates.Presets.IS_CREATURE, PaperCard::getRules), - gameFormat.getFilterPrinted())); + Iterable filteredTribe= Iterables.filter(cards, + Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules) + .and(Predicates.compose(CardRulesPredicates.hasCreatureType("Pirate"), PaperCard::getRules)) + .and(Predicates.compose(CardRulesPredicates.Presets.IS_CREATURE, PaperCard::getRules)) + .and(gameFormat.getFilterPrinted()) + ); List filteredListTribe = Lists.newArrayList(filteredTribe); rankedList = CardRanker.rankCardsInDeck(filteredListTribe); diff --git a/forge-gui/src/main/java/forge/deck/DeckgenUtil.java b/forge-gui/src/main/java/forge/deck/DeckgenUtil.java index 34befebff7f..4b8cf9a7a46 100644 --- a/forge-gui/src/main/java/forge/deck/DeckgenUtil.java +++ b/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 canPlay = forAi ? DeckGeneratorBase.AI_CAN_PLAY : CardRulesPredicates.IS_KEPT_IN_RANDOM_DECKS; - @SuppressWarnings("unchecked") - Iterable legends = cardDb.getAllCards(Predicates.and(format.isLegalCardPredicate(), format.isLegalCommanderPredicate(), - Predicates.compose(canPlay, PaperCard::getRules))); + Predicate legal = format.isLegalCardPredicate().and(format.isLegalCommanderPredicate()); + Iterable legends = cardDb.getAllCards(legal.and(Predicates.compose(canPlay, PaperCard::getRules))); commander = Aggregates.random(legends); return generateRandomCommanderDeck(commander, format, forAi, false);