external-repos/forge
1
0
Fork 0
mirror of https://github.com/Card-Forge/forge.git synced 2025-11-16 18:58:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Guava migration - Inline Predicates.and

Browse Source
This commit is contained in:
Jetz
2024-09-03 20:22:45 -04:00
parent 78bc9fd04e
commit b37f8725ba
45 changed files with 119 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
forge-ai/src/main/java/forge/ai/AiAttackController.java
View File

@@ -613,7 +613,7 @@ public class AiAttackController {
// and do not predict the blocker limit (which is safer) // and do not predict the blocker limit (which is safer)
if (Iterables.any(defendingOpponent.getLandsInPlay(), CardPredicates.Presets.UNTAPPED)) { if (Iterables.any(defendingOpponent.getLandsInPlay(), CardPredicates.Presets.UNTAPPED)) {
maxBlockersAfterCrew += CardLists.count(CardLists.getNotType(defendingOpponent.getCardsIn(ZoneType.Battlefield), "Creature"), maxBlockersAfterCrew += CardLists.count(CardLists.getNotType(defendingOpponent.getCardsIn(ZoneType.Battlefield), "Creature"),
Predicates.and(CardPredicates.isType("Vehicle"), CardPredicates.Presets.UNTAPPED)); CardPredicates.isType("Vehicle").and(CardPredicates.Presets.UNTAPPED));
} }
} }

8
forge-ai/src/main/java/forge/ai/ComputerUtilCard.java
View File

@@ -504,10 +504,10 @@ public class ComputerUtilCard {
} }
if (hasEnchantmants || hasArtifacts) { if (hasEnchantmants || hasArtifacts) {
final List<Card> ae = CardLists.filter(list, Predicates.and( final List<Card> ae = CardLists.filter(list,
Predicates.or(CardPredicates.Presets.ARTIFACTS, CardPredicates.Presets.ENCHANTMENTS), Predicates.or(CardPredicates.Presets.ARTIFACTS, CardPredicates.Presets.ENCHANTMENTS)
card -> !card.hasSVar("DoNotDiscardIfAble") .and(card -> !card.hasSVar("DoNotDiscardIfAble"))
)); );
return getCheapestPermanentAI(ae, null, false); return getCheapestPermanentAI(ae, null, false);
} }

3
forge-ai/src/main/java/forge/ai/ComputerUtilCost.java
View File

@@ -23,7 +23,6 @@ import forge.game.spellability.TargetChoices;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.Predicates;
import forge.util.TextUtil; import forge.util.TextUtil;
import forge.util.collect.FCollectionView; import forge.util.collect.FCollectionView;
import org.apache.commons.lang3.ObjectUtils; import org.apache.commons.lang3.ObjectUtils;
@@ -924,7 +923,7 @@ public class ComputerUtilCost {
public static CardCollection paymentChoicesWithoutTargets(Iterable<Card> choices, SpellAbility source, Player ai) { public static CardCollection paymentChoicesWithoutTargets(Iterable<Card> choices, SpellAbility source, Player ai) {
if (source.usesTargeting()) { if (source.usesTargeting()) {
final CardCollection targets = new CardCollection(source.getTargets().getTargetCards()); final CardCollection targets = new CardCollection(source.getTargets().getTargetCards());
choices = Iterables.filter(choices, Predicates.and(CardPredicates.isController(ai), targets::contains).negate()); choices = Iterables.filter(choices, CardPredicates.isController(ai).and(targets::contains).negate());
} }
return new CardCollection(choices); return new CardCollection(choices);
} }

3
forge-ai/src/main/java/forge/ai/ComputerUtilMana.java
View File

@@ -43,7 +43,6 @@ import forge.game.zone.Zone;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.Predicates;
import forge.util.TextUtil; import forge.util.TextUtil;
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
@@ -314,7 +313,7 @@ public class ComputerUtilMana {
// For cards like Genju of the Cedars, make sure we're not attaching to the same land that will // For cards like Genju of the Cedars, make sure we're not attaching to the same land that will
// be tapped to pay its own cost if there's another untapped land like that available // be tapped to pay its own cost if there's another untapped land like that available
if (ma.getHostCard().equals(sa.getTargetCard())) { if (ma.getHostCard().equals(sa.getTargetCard())) {
if (CardLists.count(ai.getCardsIn(ZoneType.Battlefield), Predicates.and(CardPredicates.nameEquals(ma.getHostCard().getName()), CardPredicates.Presets.UNTAPPED)) > 1) { if (CardLists.count(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.nameEquals(ma.getHostCard().getName()).and(CardPredicates.Presets.UNTAPPED)) > 1) {
continue; continue;
} }
} }

9
forge-ai/src/main/java/forge/ai/SpecialCardAi.java
View File

@@ -52,6 +52,7 @@ import org.apache.commons.lang3.tuple.Pair;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.function.Predicate;
/** /**
* Special logic for individual cards * Special logic for individual cards
@@ -359,7 +360,7 @@ public class SpecialCardAi {
public static boolean considerSacrificingCreature(final Player ai, final SpellAbility sa) { public static boolean considerSacrificingCreature(final Player ai, final SpellAbility sa) {
CardCollection flyingCreatures = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardCollection flyingCreatures = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield),
Predicates.and(CardPredicates.Presets.UNTAPPED, Predicates.or( CardPredicates.Presets.UNTAPPED.and(Predicates.or(
CardPredicates.hasKeyword(Keyword.FLYING), CardPredicates.hasKeyword(Keyword.REACH)))); CardPredicates.hasKeyword(Keyword.FLYING), CardPredicates.hasKeyword(Keyword.REACH))));
boolean hasUsefulBlocker = false; boolean hasUsefulBlocker = false;
@@ -1296,7 +1297,7 @@ public class SpecialCardAi {
public static boolean considerSecondTarget(final Player ai, final SpellAbility sa) { public static boolean considerSecondTarget(final Player ai, final SpellAbility sa) {
Card firstTgt = sa.getParent().getTargetCard(); Card firstTgt = sa.getParent().getTargetCard();
Iterable<Card> candidates = Iterables.filter(ai.getOpponents().getCardsIn(ZoneType.Battlefield), Iterable<Card> candidates = Iterables.filter(ai.getOpponents().getCardsIn(ZoneType.Battlefield),
Predicates.and(CardPredicates.sharesCardTypeWith(firstTgt), CardPredicates.isTargetableBy(sa))); CardPredicates.sharesCardTypeWith(firstTgt).and(CardPredicates.isTargetableBy(sa)));
Card secondTgt = Aggregates.random(candidates); Card secondTgt = Aggregates.random(candidates);
if (secondTgt != null) { if (secondTgt != null) {
sa.resetTargets(); sa.resetTargets();
@@ -1316,7 +1317,7 @@ public class SpecialCardAi {
return false; return false;
} }
int aiLands = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), Predicates.and(CardPredicates.Presets.LANDS, CardPredicates.Presets.BASIC_LANDS.negate())).size(); int aiLands = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.LANDS.and(CardPredicates.Presets.BASIC_LANDS.negate())).size();
boolean hasBridge = false; boolean hasBridge = false;
for (Card c : ai.getCardsIn(ZoneType.Battlefield)) { for (Card c : ai.getCardsIn(ZoneType.Battlefield)) {
@@ -1334,7 +1335,7 @@ public class SpecialCardAi {
} }
for (Player opp : ai.getOpponents()) { for (Player opp : ai.getOpponents()) {
int oppLands = CardLists.filter(opp.getCardsIn(ZoneType.Battlefield), Predicates.and(CardPredicates.Presets.LANDS, CardPredicates.Presets.BASIC_LANDS.negate())).size(); int oppLands = CardLists.filter(opp.getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.LANDS.and(CardPredicates.Presets.BASIC_LANDS.negate())).size();
// Always if enemy would die and we don't! // Always if enemy would die and we don't!
// TODO : predict actual damage instead of assuming it'll be 2*lands // TODO : predict actual damage instead of assuming it'll be 2*lands
// Don't if we lose, unless we lose anyway to unblocked creatures next turn // Don't if we lose, unless we lose anyway to unblocked creatures next turn

5
forge-ai/src/main/java/forge/ai/ability/ChooseSourceAi.java
View File

@@ -24,7 +24,6 @@ import forge.game.spellability.SpellAbilityStackInstance;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Aggregates; import forge.util.Aggregates;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.Predicates;
public class ChooseSourceAi extends SpellAbilityAi { public class ChooseSourceAi extends SpellAbilityAi {
@@ -134,8 +133,8 @@ public class ChooseSourceAi extends SpellAbilityAi {
} }
// No optimal creature was found above, so try to broaden the choice. // No optimal creature was found above, so try to broaden the choice.
if (!Iterables.isEmpty(options)) { if (!Iterables.isEmpty(options)) {
List<Card> oppCreatures = CardLists.filter(options, Predicates.and(CardPredicates.Presets.CREATURES, List<Card> oppCreatures = CardLists.filter(options,
CardPredicates.isOwner(aiChoser).negate())); CardPredicates.Presets.CREATURES.and(CardPredicates.isOwner(aiChoser).negate()));
List<Card> aiNonCreatures = CardLists.filter(options, List<Card> aiNonCreatures = CardLists.filter(options,
CardPredicates.Presets.CREATURES.negate() CardPredicates.Presets.CREATURES.negate()
.and(CardPredicates.Presets.PERMANENTS) .and(CardPredicates.Presets.PERMANENTS)

5
forge-ai/src/main/java/forge/ai/ability/CountersRemoveAi.java
View File

@@ -26,7 +26,6 @@ import forge.game.spellability.SpellAbility;
import forge.game.spellability.TargetRestrictions; import forge.game.spellability.TargetRestrictions;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.Predicates;
public class CountersRemoveAi extends SpellAbilityAi { public class CountersRemoveAi extends SpellAbilityAi {
@@ -183,7 +182,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
list = CardLists.filter(list, CardPredicates.isTargetableBy(sa)); list = CardLists.filter(list, CardPredicates.isTargetableBy(sa));
CardCollection planeswalkerList = CardLists.filter(list, CardCollection planeswalkerList = CardLists.filter(list,
Predicates.and(CardPredicates.Presets.PLANESWALKERS, CardPredicates.isControlledByAnyOf(ai.getOpponents())), CardPredicates.Presets.PLANESWALKERS.and(CardPredicates.isControlledByAnyOf(ai.getOpponents())),
CardPredicates.hasLessCounter(CounterEnumType.LOYALTY, amount)); CardPredicates.hasLessCounter(CounterEnumType.LOYALTY, amount));
if (!planeswalkerList.isEmpty()) { if (!planeswalkerList.isEmpty()) {
@@ -223,7 +222,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
// remove P1P1 counters from opposing creatures // remove P1P1 counters from opposing creatures
CardCollection oppP1P1List = CardLists.filter(list, CardCollection oppP1P1List = CardLists.filter(list,
Predicates.and(CardPredicates.Presets.CREATURES, CardPredicates.isControlledByAnyOf(ai.getOpponents())), CardPredicates.Presets.CREATURES.and(CardPredicates.isControlledByAnyOf(ai.getOpponents())),
CardPredicates.hasCounter(CounterEnumType.P1P1)); CardPredicates.hasCounter(CounterEnumType.P1P1));
if (!oppP1P1List.isEmpty()) { if (!oppP1P1List.isEmpty()) {
sa.getTargets().add(ComputerUtilCard.getBestCreatureAI(oppP1P1List)); sa.getTargets().add(ComputerUtilCard.getBestCreatureAI(oppP1P1List));

5
forge-ai/src/main/java/forge/ai/ability/DestroyAllAi.java
View File

@@ -14,7 +14,6 @@ import forge.game.phase.PhaseType;
import forge.game.player.Player; import forge.game.player.Player;
import forge.game.spellability.SpellAbility; import forge.game.spellability.SpellAbility;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Predicates;
import java.util.function.Predicate; import java.util.function.Predicate;
@@ -110,8 +109,8 @@ public class DestroyAllAi extends SpellAbilityAi {
// Special handling for Raiding Party // Special handling for Raiding Party
if (logic.equals("RaidingParty")) { if (logic.equals("RaidingParty")) {
int numAiCanSave = Math.min(CardLists.count(ai.getCreaturesInPlay(), Predicates.and(CardPredicates.isColor(MagicColor.WHITE), CardPredicates.Presets.UNTAPPED)) * 2, ailist.size()); int numAiCanSave = Math.min(CardLists.count(ai.getCreaturesInPlay(), CardPredicates.isColor(MagicColor.WHITE).and(CardPredicates.Presets.UNTAPPED)) * 2, ailist.size());
int numOppsCanSave = Math.min(CardLists.count(ai.getOpponents().getCreaturesInPlay(), Predicates.and(CardPredicates.isColor(MagicColor.WHITE), CardPredicates.Presets.UNTAPPED)) * 2, opplist.size()); int numOppsCanSave = Math.min(CardLists.count(ai.getOpponents().getCreaturesInPlay(), CardPredicates.isColor(MagicColor.WHITE).and(CardPredicates.Presets.UNTAPPED)) * 2, opplist.size());
return numOppsCanSave < opplist.size() && (ailist.size() - numAiCanSave < opplist.size() - numOppsCanSave); return numOppsCanSave < opplist.size() && (ailist.size() - numAiCanSave < opplist.size() - numOppsCanSave);
} }

3
forge-ai/src/main/java/forge/ai/ability/LifeLoseAi.java
View File

@@ -14,7 +14,6 @@ import forge.game.player.Player;
import forge.game.player.PlayerCollection; import forge.game.player.PlayerCollection;
import forge.game.player.PlayerPredicates; import forge.game.player.PlayerPredicates;
import forge.game.spellability.SpellAbility; import forge.game.spellability.SpellAbility;
import forge.util.Predicates;
import forge.util.collect.FCollection; import forge.util.collect.FCollection;
public class LifeLoseAi extends SpellAbilityAi { public class LifeLoseAi extends SpellAbilityAi {
@@ -128,7 +127,7 @@ public class LifeLoseAi extends SpellAbilityAi {
final PlayerCollection tgtPlayers = getPlayers(ai, sa); final PlayerCollection tgtPlayers = getPlayers(ai, sa);
// TODO: check against the amount we could obtain when multiple activations are possible // TODO: check against the amount we could obtain when multiple activations are possible
PlayerCollection filteredPlayer = tgtPlayers PlayerCollection filteredPlayer = tgtPlayers
.filter(Predicates.and(PlayerPredicates.isOpponentOf(ai), PlayerPredicates.lifeLessOrEqualTo(amount))); .filter(PlayerPredicates.isOpponentOf(ai).and(PlayerPredicates.lifeLessOrEqualTo(amount)));
// killing opponents asap // killing opponents asap
if (!filteredPlayer.isEmpty()) { if (!filteredPlayer.isEmpty()) {
return true; return true;

9
forge-ai/src/main/java/forge/ai/ability/MeldAi.java
View File

@@ -7,7 +7,6 @@ import forge.game.player.Player;
import forge.game.spellability.SpellAbility; import forge.game.spellability.SpellAbility;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.Predicates;
public class MeldAi extends SpellAbilityAi { public class MeldAi extends SpellAbilityAi {
@Override @Override
@@ -20,10 +19,10 @@ public class MeldAi extends SpellAbilityAi {
return false; return false;
} }
boolean hasPrimaryMeld = Iterables.any(cardsOTB, Predicates.and( boolean hasPrimaryMeld = Iterables.any(cardsOTB,
CardPredicates.nameEquals(primaryMeld), CardPredicates.isOwner(aiPlayer))); CardPredicates.nameEquals(primaryMeld).and(CardPredicates.isOwner(aiPlayer)));
boolean hasSecondaryMeld = Iterables.any(cardsOTB, Predicates.and( boolean hasSecondaryMeld = Iterables.any(cardsOTB,
CardPredicates.nameEquals(secondaryMeld), CardPredicates.isOwner(aiPlayer))); CardPredicates.nameEquals(secondaryMeld).and(CardPredicates.isOwner(aiPlayer)));
return hasPrimaryMeld && hasSecondaryMeld && sa.getHostCard().getName().equals(primaryMeld); return hasPrimaryMeld && hasSecondaryMeld && sa.getHostCard().getName().equals(primaryMeld);
} }

4
forge-core/src/main/java/forge/card/CardDb.java
View File

@@ -800,7 +800,7 @@ public final class CardDb implements ICardDatabase, IDeckGenPool {
}; };
} else // filter candidates based on requested artIndex } else // filter candidates based on requested artIndex
cardQueryFilter = card -> card.getArtIndex() == cr.artIndex; cardQueryFilter = card -> card.getArtIndex() == cr.artIndex;
cardQueryFilter = Predicates.and(cardQueryFilter, filter); cardQueryFilter = cardQueryFilter.and(filter);
cards = getAllCards(cr.cardName, cardQueryFilter); cards = getAllCards(cr.cardName, cardQueryFilter);
// Note: No need to check whether "cards" is empty; the next for loop will validate condition at L699 // Note: No need to check whether "cards" is empty; the next for loop will validate condition at L699
if (cards.size() == 1) // if only one candidate, there much else we should do if (cards.size() == 1) // if only one candidate, there much else we should do
@@ -879,7 +879,7 @@ public final class CardDb implements ICardDatabase, IDeckGenPool {
return 0; return 0;
Predicate<PaperCard> predicate = card -> card.getEdition().equalsIgnoreCase(setCode); Predicate<PaperCard> predicate = card -> card.getEdition().equalsIgnoreCase(setCode);
if(functionalVariantName != null && !functionalVariantName.equals(IPaperCard.NO_FUNCTIONAL_VARIANT)) { if(functionalVariantName != null && !functionalVariantName.equals(IPaperCard.NO_FUNCTIONAL_VARIANT)) {
predicate = Predicates.and(predicate, card -> functionalVariantName.equals(card.getFunctionalVariant())); predicate = predicate.and(card -> functionalVariantName.equals(card.getFunctionalVariant()));
} }
Collection<PaperCard> cardsInSet = getAllCards(cardName, predicate); Collection<PaperCard> cardsInSet = getAllCards(cardName, predicate);
return cardsInSet.size(); return cardsInSet.size();

2
forge-core/src/main/java/forge/card/CardEdition.java
View File

@@ -904,7 +904,7 @@ public final class CardEdition implements Comparable<CardEdition> {
CardDb.CardArtPreference artPreference = StaticData.instance().getCardArtPreference(); CardDb.CardArtPreference artPreference = StaticData.instance().getCardArtPreference();
Iterable<CardEdition> editionsWithBasicLands = Iterables.filter( Iterable<CardEdition> editionsWithBasicLands = Iterables.filter(
StaticData.instance().getEditions().getOrderedEditions(), StaticData.instance().getEditions().getOrderedEditions(),
forge.util.Predicates.and(hasBasicLands, artPreference::accept)); hasBasicLands.and(artPreference::accept));
Iterator<CardEdition> editionsIterator = editionsWithBasicLands.iterator(); Iterator<CardEdition> editionsIterator = editionsWithBasicLands.iterator();
List<CardEdition> selectedEditions = new ArrayList<CardEdition>(); List<CardEdition> selectedEditions = new ArrayList<CardEdition>();
while (editionsIterator.hasNext()) while (editionsIterator.hasNext())

11
forge-core/src/main/java/forge/card/CardRulesPredicates.java
View File

@@ -574,14 +574,11 @@ public final class CardRulesPredicates {
public static final Predicate<CardRules> IS_VANGUARD = CardRulesPredicates.coreType(true, CardType.CoreType.Vanguard); public static final Predicate<CardRules> IS_VANGUARD = CardRulesPredicates.coreType(true, CardType.CoreType.Vanguard);
public static final Predicate<CardRules> IS_CONSPIRACY = CardRulesPredicates.coreType(true, CardType.CoreType.Conspiracy); public static final Predicate<CardRules> IS_CONSPIRACY = CardRulesPredicates.coreType(true, CardType.CoreType.Conspiracy);
public static final Predicate<CardRules> IS_DUNGEON = CardRulesPredicates.coreType(true, CardType.CoreType.Dungeon); public static final Predicate<CardRules> IS_DUNGEON = CardRulesPredicates.coreType(true, CardType.CoreType.Dungeon);
public static final Predicate<CardRules> IS_ATTRACTION = Predicates.and(Presets.IS_ARTIFACT, public static final Predicate<CardRules> IS_ATTRACTION = Presets.IS_ARTIFACT.and(CardRulesPredicates.subType("Attraction"));
CardRulesPredicates.subType("Attraction")
);
public static final Predicate<CardRules> IS_NON_LAND = CardRulesPredicates.coreType(false, CardType.CoreType.Land); public static final Predicate<CardRules> IS_NON_LAND = CardRulesPredicates.coreType(false, CardType.CoreType.Land);
public static final Predicate<CardRules> CAN_BE_BRAWL_COMMANDER = Predicates.and(Presets.IS_LEGENDARY, public static final Predicate<CardRules> CAN_BE_BRAWL_COMMANDER = Presets.IS_LEGENDARY.and(Predicates.or(Presets.IS_CREATURE, Presets.IS_PLANESWALKER));
Predicates.or(Presets.IS_CREATURE, Presets.IS_PLANESWALKER)); public static final Predicate<CardRules> CAN_BE_TINY_LEADERS_COMMANDER = Presets.IS_LEGENDARY.and(Predicates.or(Presets.IS_CREATURE, Presets.IS_PLANESWALKER));
public static final Predicate<CardRules> CAN_BE_TINY_LEADERS_COMMANDER = Predicates.and(Presets.IS_LEGENDARY,
Predicates.or(Presets.IS_CREATURE, Presets.IS_PLANESWALKER));
/** The Constant IS_NON_CREATURE_SPELL. **/ /** The Constant IS_NON_CREATURE_SPELL. **/
public static final Predicate<CardRules> IS_NON_CREATURE_SPELL = public static final Predicate<CardRules> IS_NON_CREATURE_SPELL =

3
forge-core/src/main/java/forge/deck/generation/DeckGenPool.java
View File

@@ -7,7 +7,6 @@ import java.util.function.Predicate;
import forge.item.IPaperCard; import forge.item.IPaperCard;
import forge.item.PaperCard; import forge.item.PaperCard;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.Predicates;
public class DeckGenPool implements IDeckGenPool { public class DeckGenPool implements IDeckGenPool {
private final Map<String, PaperCard> cards = new HashMap<>(); private final Map<String, PaperCard> cards = new HashMap<>();
@@ -38,7 +37,7 @@ public class DeckGenPool implements IDeckGenPool {
@Override @Override
public PaperCard getCard(String name, String edition) { public PaperCard getCard(String name, String edition) {
Predicate<PaperCard> filter = Predicates.and(IPaperCard.Predicates.printedInSet(edition),IPaperCard.Predicates.name(name)); Predicate<PaperCard> filter = IPaperCard.Predicates.printedInSet(edition).and(IPaperCard.Predicates.name(name));
Iterable<PaperCard> editionCards=Iterables.filter(cards.values(), filter); Iterable<PaperCard> editionCards=Iterables.filter(cards.values(), filter);
if (editionCards.iterator().hasNext()){ if (editionCards.iterator().hasNext()){
return editionCards.iterator().next(); return editionCards.iterator().next();

6
forge-core/src/main/java/forge/deck/generation/DeckGeneratorBase.java
View File

@@ -108,8 +108,8 @@ public abstract class DeckGeneratorBase {
protected boolean setBasicLandPool(String edition){ protected boolean setBasicLandPool(String edition){
Predicate<PaperCard> isSetBasicLand; Predicate<PaperCard> isSetBasicLand;
if (edition !=null){ if (edition !=null){
isSetBasicLand = Predicates.and(IPaperCard.Predicates.printedInSet(edition), isSetBasicLand = IPaperCard.Predicates.printedInSet(edition)
Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules)); .and(Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules));
}else{ }else{
isSetBasicLand = Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules); isSetBasicLand = Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules);
} }
@@ -327,7 +327,7 @@ public abstract class DeckGeneratorBase {
map.put(key, boxed == null ? delta : boxed + delta); map.put(key, boxed == null ? delta : boxed + delta);
} }
public static final Predicate<CardRules> AI_CAN_PLAY = Predicates.and(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, CardRulesPredicates.IS_KEPT_IN_RANDOM_DECKS); public static final Predicate<CardRules> AI_CAN_PLAY = CardRulesPredicates.IS_KEPT_IN_AI_DECKS.and(CardRulesPredicates.IS_KEPT_IN_RANDOM_DECKS);
public static final Predicate<CardRules> COLORLESS_CARDS = c -> { public static final Predicate<CardRules> COLORLESS_CARDS = c -> {
ManaCost mc = c.getManaCost(); ManaCost mc = c.getManaCost();

5
forge-core/src/main/java/forge/item/SealedProduct.java
View File

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

2
forge-core/src/main/java/forge/item/generation/BoosterGenerator.java
View File

@@ -609,7 +609,7 @@ public class BoosterGenerator {
String mainCode = operators.isEmpty() ? null : operators.get(0).trim(); String mainCode = operators.isEmpty() ? null : operators.get(0).trim();
if (null == mainCode || mainCode.equalsIgnoreCase(BoosterSlots.ANY)) { // no restriction on rarity if (null == mainCode || mainCode.equalsIgnoreCase(BoosterSlots.ANY)) { // no restriction on rarity
Predicate<PaperCard> predicate = Predicates.and(setPred, extraPred); Predicate<PaperCard> predicate = setPred.and(extraPred);
ps.addAll(Iterables.filter(src, predicate)); 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 } else if (mainCode.equalsIgnoreCase(BoosterSlots.UNCOMMON_RARE)) { // for sets like ARN, where U1 cards are considered rare and U3 are uncommon

6
forge-core/src/main/java/forge/util/Predicates.java
View File

@@ -16,6 +16,7 @@ public class Predicates {
return x -> Iterables.any(components, (Predicate<Predicate<? super T>>) i -> i.test(x)); return x -> Iterables.any(components, (Predicate<Predicate<? super T>>) i -> i.test(x));
} }
//TODO: Most uses of this are with the function PaperCard::getRules. Maybe we should just have PaperCardPredicates?
public static <A, B> Predicate<A> compose(Predicate<B> predicate, Function<A, ? extends B> function) { public static <A, B> Predicate<A> compose(Predicate<B> predicate, Function<A, ? extends B> function) {
return x -> predicate.test(function.apply(x)); return x -> predicate.test(function.apply(x));
} }
@@ -23,11 +24,6 @@ public class Predicates {
//TODO: Inline everything below. //TODO: Inline everything below.
public static <T> Predicate<T> and(Predicate<? super T> first, Predicate<? super T> second) {
//TODO: remove casting?
return ((Predicate<T>) first).and(second);
}
public static <T> Predicate<T> or(Predicate<? super T> first, Predicate<? super T> second) { public static <T> Predicate<T> or(Predicate<? super T> first, Predicate<? super T> second) {
//TODO: remove casting? //TODO: remove casting?
return ((Predicate<T>) first).or(second); return ((Predicate<T>) first).or(second);

8
forge-game/src/main/java/forge/game/GameFormat.java
View File

@@ -141,13 +141,13 @@ public class GameFormat implements Comparable<GameFormat> {
Predicate<PaperCard> p = IPaperCard.Predicates.names(this.getBannedCardNames()).negate(); Predicate<PaperCard> p = IPaperCard.Predicates.names(this.getBannedCardNames()).negate();
if (FormatSubType.ARENA.equals(this.getFormatSubType())) { if (FormatSubType.ARENA.equals(this.getFormatSubType())) {
p = Predicates.and(p, IPaperCard.Predicates.Presets.IS_UNREBALANCED.negate()); p = p.and(IPaperCard.Predicates.Presets.IS_UNREBALANCED.negate());
} else { } else {
p = Predicates.and(p, IPaperCard.Predicates.Presets.IS_REBALANCED.negate()); p = p.and(IPaperCard.Predicates.Presets.IS_REBALANCED.negate());
} }
if (!this.getAllowedSetCodes().isEmpty()) { if (!this.getAllowedSetCodes().isEmpty()) {
p = Predicates.and(p, printed ? p = p.and(printed ?
IPaperCard.Predicates.printedInSets(this.getAllowedSetCodes(), printed) : IPaperCard.Predicates.printedInSets(this.getAllowedSetCodes(), printed) :
StaticData.instance().getCommonCards().wasPrintedInSets(this.getAllowedSetCodes())); StaticData.instance().getCommonCards().wasPrintedInSets(this.getAllowedSetCodes()));
} }
@@ -156,7 +156,7 @@ public class GameFormat implements Comparable<GameFormat> {
for (CardRarity cr: this.getAllowedRarities()) { for (CardRarity cr: this.getAllowedRarities()) {
crp.add(StaticData.instance().getCommonCards().wasPrintedAtRarity(cr)); crp.add(StaticData.instance().getCommonCards().wasPrintedAtRarity(cr));
} }
p = Predicates.and(p, Predicates.or(crp)); p = p.and(Predicates.or(crp));
} }
if (!this.getAdditionalCards().isEmpty()) { if (!this.getAdditionalCards().isEmpty()) {
p = Predicates.or(p, IPaperCard.Predicates.names(this.getAdditionalCards())); p = Predicates.or(p, IPaperCard.Predicates.names(this.getAdditionalCards()));

4
forge-game/src/main/java/forge/game/ability/effects/VentureEffect.java
View File

@@ -46,8 +46,8 @@ public class VentureEffect extends SpellAbilityEffect {
if (sa.hasParam("Dungeon")) { if (sa.hasParam("Dungeon")) {
dungeonCards = StaticData.instance().getVariantCards() dungeonCards = StaticData.instance().getVariantCards()
.getAllCards(Predicates.compose( .getAllCards(Predicates.compose(
Predicates.and(CardRulesPredicates.Presets.IS_DUNGEON, CardRulesPredicates.Presets.IS_DUNGEON
CardRulesPredicates.subType(StringOp.EQUALS, sa.getParam("Dungeon"))), .and(CardRulesPredicates.subType(StringOp.EQUALS, sa.getParam("Dungeon"))),
PaperCard::getRules)); PaperCard::getRules));
} else { } else {
// Create a new dungeon card chosen by player in command zone. // Create a new dungeon card chosen by player in command zone.

4
forge-game/src/main/java/forge/game/card/CardLists.java
View File

@@ -314,7 +314,7 @@ public class CardLists {
} }
public static CardCollection filter(Iterable<Card> cardList, Predicate<Card> f1, Predicate<Card> f2) { public static CardCollection filter(Iterable<Card> cardList, Predicate<Card> f1, Predicate<Card> f2) {
return new CardCollection(Iterables.filter(cardList, Predicates.and(f1, f2))); return new CardCollection(Iterables.filter(cardList, f1.and(f2)));
} }
public static CardCollection filter(Iterable<Card> cardList, Iterable<Predicate<Card>> filt) { public static CardCollection filter(Iterable<Card> cardList, Iterable<Predicate<Card>> filt) {
@@ -337,7 +337,7 @@ public class CardLists {
} }
public static List<Card> filterAsList(Iterable<Card> cardList, Predicate<Card> f1, Predicate<Card> f2) { public static List<Card> filterAsList(Iterable<Card> cardList, Predicate<Card> f1, Predicate<Card> f2) {
return Lists.newArrayList(Iterables.filter(cardList, Predicates.and(f1, f2))); return Lists.newArrayList(Iterables.filter(cardList, f1.and(f2)));
} }
public static List<Card> filterAsList(Iterable<Card> cardList, Iterable<Predicate<Card>> filt) { public static List<Card> filterAsList(Iterable<Card> cardList, Iterable<Predicate<Card>> filt) {

6
forge-game/src/main/java/forge/game/combat/AttackRestrictionType.java
View File

@@ -3,7 +3,6 @@ package forge.game.combat;
import forge.card.MagicColor; import forge.card.MagicColor;
import forge.game.card.Card; import forge.game.card.Card;
import forge.game.card.CardPredicates; import forge.game.card.CardPredicates;
import forge.util.Predicates;
import java.util.function.Predicate; import java.util.function.Predicate;
@@ -21,10 +20,9 @@ public enum AttackRestrictionType {
case NEED_GREATER_POWER: case NEED_GREATER_POWER:
return CardPredicates.hasGreaterPowerThan(attacker.getNetPower()); return CardPredicates.hasGreaterPowerThan(attacker.getNetPower());
case NEED_BLACK_OR_GREEN: case NEED_BLACK_OR_GREEN:
return Predicates.and( return CardPredicates.isColor((byte) (MagicColor.BLACK | MagicColor.GREEN))
CardPredicates.isColor((byte) (MagicColor.BLACK | MagicColor.GREEN)),
// may explicitly not be black/green itself // may explicitly not be black/green itself
((Predicate<Card>) attacker::equals).negate()); .and(((Predicate<Card>) attacker::equals).negate());
case NOT_ALONE: case NOT_ALONE:
return x -> true; return x -> true;
default: default:

3
forge-game/src/main/java/forge/game/phase/Untap.java
View File

@@ -45,7 +45,6 @@ import forge.game.staticability.StaticAbilityCantPhase;
import forge.game.trigger.TriggerType; import forge.game.trigger.TriggerType;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.Predicates;
/** /**
* <p> * <p>
@@ -114,7 +113,7 @@ public class Untap extends Phase {
*/ */
private void doUntap() { private void doUntap() {
final Player player = game.getPhaseHandler().getPlayerTurn(); final Player player = game.getPhaseHandler().getPlayerTurn();
final Predicate<Card> tappedCanUntap = Predicates.and(Presets.TAPPED, CANUNTAP); final Predicate<Card> tappedCanUntap = Presets.TAPPED.and(CANUNTAP);
Map<Player, CardCollection> untapMap = Maps.newHashMap(); Map<Player, CardCollection> untapMap = Maps.newHashMap();
CardCollection list = new CardCollection(player.getCardsIn(ZoneType.Battlefield)); CardCollection list = new CardCollection(player.getCardsIn(ZoneType.Battlefield));

7
forge-game/src/main/java/forge/game/player/Player.java
View File

@@ -63,6 +63,7 @@ import org.apache.commons.lang3.tuple.Pair;
import java.util.*; import java.util.*;
import java.util.Map.Entry; import java.util.Map.Entry;
import java.util.function.Predicate;
/** /**
* <p> * <p>
@@ -3749,9 +3750,9 @@ public class Player extends GameEntity implements Comparable<Player> {
public boolean hasUrzaLands() { public boolean hasUrzaLands() {
final CardCollectionView landsControlled = getCardsIn(ZoneType.Battlefield); final CardCollectionView landsControlled = getCardsIn(ZoneType.Battlefield);
return Iterables.any(landsControlled, Predicates.and(CardPredicates.isType("Urza's"), CardPredicates.isType("Mine"))) return Iterables.any(landsControlled, CardPredicates.isType("Urza's").and(CardPredicates.isType("Mine")))
&& Iterables.any(landsControlled, Predicates.and(CardPredicates.isType("Urza's"), CardPredicates.isType("Power-Plant"))) && Iterables.any(landsControlled, CardPredicates.isType("Urza's").and(CardPredicates.isType("Power-Plant")))
&& Iterables.any(landsControlled, Predicates.and(CardPredicates.isType("Urza's"), CardPredicates.isType("Tower"))); && Iterables.any(landsControlled, CardPredicates.isType("Urza's").and(CardPredicates.isType("Tower")));
} }
public void revealFaceDownCards() { public void revealFaceDownCards() {

16
forge-game/src/main/java/forge/game/staticability/StaticAbilityPanharmonicon.java
View File

@@ -21,7 +21,6 @@ import java.util.List;
import java.util.Map; import java.util.Map;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.Predicates;
import org.apache.commons.lang3.ArrayUtils; import org.apache.commons.lang3.ArrayUtils;
public class StaticAbilityPanharmonicon { public class StaticAbilityPanharmonicon {
@@ -178,10 +177,10 @@ public class StaticAbilityPanharmonicon {
Map<Card, Integer> dmgMap = (Map<Card, Integer>) runParams.get(AbilityKey.DamageMap); Map<Card, Integer> dmgMap = (Map<Card, Integer>) runParams.get(AbilityKey.DamageMap);
// 1. check it's valid cause for static // 1. check it's valid cause for static
// 2. and it must also be valid for trigger event // 2. and it must also be valid for trigger event
if (!Iterables.any(dmgMap.keySet(), Predicates.and( if (!Iterables.any(dmgMap.keySet(),
GameObjectPredicates.matchesValidParam(stAb, "ValidSource"), GameObjectPredicates.matchesValidParam(stAb, "ValidSource")
GameObjectPredicates.matchesValidParam(trigger, "ValidSource") .and(GameObjectPredicates.matchesValidParam(trigger, "ValidSource"))
))) { )) {
return false; return false;
} }
// DamageAmount$ can be ignored for now (its usage doesn't interact with ValidSource from either) // DamageAmount$ can be ignored for now (its usage doesn't interact with ValidSource from either)
@@ -191,10 +190,9 @@ public class StaticAbilityPanharmonicon {
return false; return false;
} }
Map<GameEntity, Integer> dmgMap = (Map<GameEntity, Integer>) runParams.get(AbilityKey.DamageMap); Map<GameEntity, Integer> dmgMap = (Map<GameEntity, Integer>) runParams.get(AbilityKey.DamageMap);
if (!Iterables.any(dmgMap.keySet(), Predicates.and( if (!Iterables.any(dmgMap.keySet(), GameObjectPredicates.matchesValidParam(stAb, "ValidTarget")
GameObjectPredicates.matchesValidParam(stAb, "ValidTarget"), .and(GameObjectPredicates.matchesValidParam(trigger, "ValidTarget"))
GameObjectPredicates.matchesValidParam(trigger, "ValidTarget") )) {
))) {
return false; return false;
} }
} }

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

@@ -33,7 +33,7 @@ public class CardPowerFilter extends ValueRangeFilter<PaperCard> {
if (predicate == null) { if (predicate == null) {
return x -> true; return x -> true;
} }
predicate = Predicates.and(predicate, CardRulesPredicates.Presets.IS_CREATURE); predicate = predicate.and(CardRulesPredicates.Presets.IS_CREATURE);
return Predicates.compose(predicate, PaperCard::getRules); return Predicates.compose(predicate, PaperCard::getRules);
} }
} }

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

@@ -33,7 +33,7 @@ public class CardToughnessFilter extends ValueRangeFilter<PaperCard> {
if (predicate == null) { if (predicate == null) {
return x -> true; return x -> true;
} }
predicate = Predicates.and(predicate, CardRulesPredicates.Presets.IS_CREATURE); predicate = predicate.and(CardRulesPredicates.Presets.IS_CREATURE);
return Predicates.compose(predicate, PaperCard::getRules); return Predicates.compose(predicate, PaperCard::getRules);
} }
} }

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

@@ -83,7 +83,7 @@ public final class CEditorCommander extends CDeckEditor<Deck> {
if (gameType == GameType.Brawl){ if (gameType == GameType.Brawl){
GameFormat format = FModel.getFormats().get("Brawl"); GameFormat format = FModel.getFormats().get("Brawl");
Predicate<CardRules> commanderFilter = CardRulesPredicates.Presets.CAN_BE_BRAWL_COMMANDER; Predicate<CardRules> commanderFilter = CardRulesPredicates.Presets.CAN_BE_BRAWL_COMMANDER;
commanderPool = ItemPool.createFrom(commonCards.getAllCardsNoAlt(Predicates.and(format.getFilterPrinted(), Predicates.compose(commanderFilter, PaperCard::getRules))), PaperCard.class); commanderPool = ItemPool.createFrom(commonCards.getAllCardsNoAlt(format.getFilterPrinted().and(Predicates.compose(commanderFilter, PaperCard::getRules))), PaperCard.class);
normalPool = ItemPool.createFrom(format.getAllCards(), PaperCard.class); normalPool = ItemPool.createFrom(format.getAllCards(), PaperCard.class);
} }
else { else {

3
forge-gui-mobile/src/forge/adventure/data/AdventureEventData.java
View File

@@ -20,7 +20,6 @@ import forge.model.CardBlock;
import forge.model.FModel; import forge.model.FModel;
import forge.util.Aggregates; import forge.util.Aggregates;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.Predicates;
import org.apache.commons.lang3.tuple.Pair; import org.apache.commons.lang3.tuple.Pair;
import java.io.Serializable; import java.io.Serializable;
@@ -319,7 +318,7 @@ public class AdventureEventData implements Serializable {
private CardBlock pickWeightedCardBlock() { private CardBlock pickWeightedCardBlock() {
CardEdition.Collection editions = FModel.getMagicDb().getEditions(); CardEdition.Collection editions = FModel.getMagicDb().getEditions();
Iterable<CardBlock> src = FModel.getBlocks(); //all blocks Iterable<CardBlock> src = FModel.getBlocks(); //all blocks
Predicate<CardEdition> filter = Predicates.and(CardEdition.Predicates.CAN_MAKE_BOOSTER, selectSetPool()); Predicate<CardEdition> filter = CardEdition.Predicates.CAN_MAKE_BOOSTER.and(selectSetPool());
List<CardEdition> allEditions = new ArrayList<>(); List<CardEdition> allEditions = new ArrayList<>();
StreamSupport.stream(editions.spliterator(), false).filter(filter).filter(CardEdition::hasBoosterTemplate).collect(Collectors.toList()).iterator().forEachRemaining(allEditions::add); StreamSupport.stream(editions.spliterator(), false).filter(filter).filter(CardEdition::hasBoosterTemplate).collect(Collectors.toList()).iterator().forEachRemaining(allEditions::add);

3
forge-gui-mobile/src/forge/adventure/util/CardUtil.java
View File

@@ -22,7 +22,6 @@ import forge.item.generation.UnOpenedProduct;
import forge.model.FModel; import forge.model.FModel;
import forge.util.Aggregates; import forge.util.Aggregates;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.Predicates;
import java.text.SimpleDateFormat; import java.text.SimpleDateFormat;
import java.util.*; import java.util.*;
@@ -792,7 +791,7 @@ public class CardUtil {
} }
public static Deck generateRandomBoosterPackAsDeck(final Predicate<CardEdition> editionFilter) { public static Deck generateRandomBoosterPackAsDeck(final Predicate<CardEdition> editionFilter) {
Predicate<CardEdition> filter = Predicates.and(CardEdition.Predicates.CAN_MAKE_BOOSTER, editionFilter); Predicate<CardEdition> filter = CardEdition.Predicates.CAN_MAKE_BOOSTER.and(editionFilter);
Iterable<CardEdition> possibleEditions = Iterables.filter(FModel.getMagicDb().getEditions(), filter); Iterable<CardEdition> possibleEditions = Iterables.filter(FModel.getMagicDb().getEditions(), filter);
if (!possibleEditions.iterator().hasNext()) { if (!possibleEditions.iterator().hasNext()) {

2
forge-gui-mobile/src/forge/deck/FDeckEditor.java
View File

@@ -93,7 +93,7 @@ public class FDeckEditor extends TabPageScreen<FDeckEditor> {
} }
} }
else if (additionalFilter != null) { else if (additionalFilter != null) {
filter = Predicates.and(filter, additionalFilter); filter = filter.and(additionalFilter);
} }
ItemPool<PaperCard> filteredPool = new ItemPool<>(PaperCard.class); ItemPool<PaperCard> filteredPool = new ItemPool<>(PaperCard.class);

2
forge-gui-mobile/src/forge/itemmanager/filters/CardPowerFilter.java
View File

@@ -30,7 +30,7 @@ public class CardPowerFilter extends ValueRangeFilter<PaperCard> {
if (predicate == null) { if (predicate == null) {
return x -> true; return x -> true;
} }
predicate = Predicates.and(predicate, CardRulesPredicates.Presets.IS_CREATURE); predicate = predicate.and(CardRulesPredicates.Presets.IS_CREATURE);
return Predicates.compose(predicate, PaperCard::getRules); return Predicates.compose(predicate, PaperCard::getRules);
} }
} }

2
forge-gui-mobile/src/forge/itemmanager/filters/CardToughnessFilter.java
View File

@@ -30,7 +30,7 @@ public class CardToughnessFilter extends ValueRangeFilter<PaperCard> {
if (predicate == null) { if (predicate == null) {
return x -> true; return x -> true;
} }
predicate = Predicates.and(predicate, CardRulesPredicates.Presets.IS_CREATURE); predicate = predicate.and(CardRulesPredicates.Presets.IS_CREATURE);
return Predicates.compose(predicate, PaperCard::getRules); return Predicates.compose(predicate, PaperCard::getRules);
} }
} }

2
forge-gui-mobile/src/forge/screens/planarconquest/ConquestAEtherScreen.java
View File

@@ -389,7 +389,7 @@ public class ConquestAEtherScreen extends FScreen {
if (predicate == null) { if (predicate == null) {
return selectedOption.getPredicate(); return selectedOption.getPredicate();
} }
return Predicates.and(predicate, selectedOption.getPredicate()); return predicate.and(selectedOption.getPredicate());
} }
@Override @Override

10
forge-gui/src/main/java/forge/deck/CommanderDeckGenerator.java
View File

@@ -40,8 +40,8 @@ public class CommanderDeckGenerator extends DeckProxy implements Comparable<Comm
} }
Predicate<CardRules> canPlay = isForAi ? DeckGeneratorBase.AI_CAN_PLAY : CardRulesPredicates.IS_KEPT_IN_RANDOM_DECKS; Predicate<CardRules> canPlay = isForAi ? DeckGeneratorBase.AI_CAN_PLAY : CardRulesPredicates.IS_KEPT_IN_RANDOM_DECKS;
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
Iterable<PaperCard> legends = Iterables.filter(uniqueCards.toFlatList(), Predicates.and(format.isLegalCommanderPredicate(), Predicates.compose( Iterable<PaperCard> legends = Iterables.filter(uniqueCards.toFlatList(), format.isLegalCommanderPredicate()
canPlay, PaperCard::getRules))); .and(Predicates.compose(canPlay, PaperCard::getRules)));
final List<DeckProxy> decks = new ArrayList<>(); final List<DeckProxy> decks = new ArrayList<>();
for (PaperCard legend: legends) { for (PaperCard legend: legends) {
decks.add(new CommanderDeckGenerator(legend, format, isForAi, isCardGen)); decks.add(new CommanderDeckGenerator(legend, format, isForAi, isCardGen));
@@ -64,10 +64,8 @@ public class CommanderDeckGenerator extends DeckProxy implements Comparable<Comm
} }
Predicate<CardRules> canPlay = isForAi ? DeckGeneratorBase.AI_CAN_PLAY : CardRulesPredicates.IS_KEPT_IN_RANDOM_DECKS; Predicate<CardRules> canPlay = isForAi ? DeckGeneratorBase.AI_CAN_PLAY : CardRulesPredicates.IS_KEPT_IN_RANDOM_DECKS;
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
Iterable<PaperCard> legends = Iterables.filter(uniqueCards.toFlatList(), Predicates.and(format.isLegalCardPredicate(), Iterable<PaperCard> legends = Iterables.filter(uniqueCards.toFlatList(), format.isLegalCardPredicate()
Predicates.compose(Predicates.and( .and(Predicates.compose(CardRulesPredicates.Presets.CAN_BE_BRAWL_COMMANDER.and(canPlay), PaperCard::getRules)));
CardRulesPredicates.Presets.CAN_BE_BRAWL_COMMANDER,
canPlay), PaperCard::getRules)));
final List<DeckProxy> decks = new ArrayList<>(); final List<DeckProxy> decks = new ArrayList<>();
for (PaperCard legend: legends) { for (PaperCard legend: legends) {
decks.add(new CommanderDeckGenerator(legend, format, isForAi, isCardGen)); decks.add(new CommanderDeckGenerator(legend, format, isForAi, isCardGen));

5
forge-gui/src/main/java/forge/deck/DeckProxy.java
View File

@@ -18,7 +18,6 @@ import forge.model.FModel;
import forge.util.BinaryUtil; import forge.util.BinaryUtil;
import forge.util.IHasName; import forge.util.IHasName;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.Predicates;
import forge.util.storage.IStorage; import forge.util.storage.IStorage;
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.commons.lang3.tuple.ImmutablePair;
@@ -473,7 +472,7 @@ public class DeckProxy implements InventoryItem {
if (filter == null) { if (filter == null) {
filter = DeckFormat.TinyLeaders.hasLegalCardsPredicate(FModel.getPreferences().getPrefBoolean(FPref.ENFORCE_DECK_LEGALITY)); filter = DeckFormat.TinyLeaders.hasLegalCardsPredicate(FModel.getPreferences().getPrefBoolean(FPref.ENFORCE_DECK_LEGALITY));
} else { } else {
filter = Predicates.and(DeckFormat.TinyLeaders.hasLegalCardsPredicate(FModel.getPreferences().getPrefBoolean(FPref.ENFORCE_DECK_LEGALITY)), filter); filter = filter.and(DeckFormat.TinyLeaders.hasLegalCardsPredicate(FModel.getPreferences().getPrefBoolean(FPref.ENFORCE_DECK_LEGALITY)));
} }
addDecksRecursivelly("Tiny Leaders", GameType.TinyLeaders, result, "", FModel.getDecks().getTinyLeaders(), filter); addDecksRecursivelly("Tiny Leaders", GameType.TinyLeaders, result, "", FModel.getDecks().getTinyLeaders(), filter);
return result; return result;
@@ -487,7 +486,7 @@ public class DeckProxy implements InventoryItem {
if (filter == null) { if (filter == null) {
filter = DeckFormat.Brawl.hasLegalCardsPredicate(FModel.getPreferences().getPrefBoolean(FPref.ENFORCE_DECK_LEGALITY)); filter = DeckFormat.Brawl.hasLegalCardsPredicate(FModel.getPreferences().getPrefBoolean(FPref.ENFORCE_DECK_LEGALITY));
} else { } else {
filter = Predicates.and(DeckFormat.Brawl.hasLegalCardsPredicate(FModel.getPreferences().getPrefBoolean(FPref.ENFORCE_DECK_LEGALITY)), filter); filter = filter.and(DeckFormat.Brawl.hasLegalCardsPredicate(FModel.getPreferences().getPrefBoolean(FPref.ENFORCE_DECK_LEGALITY)));
} }
addDecksRecursivelly("Brawl", GameType.Brawl, result, "", FModel.getDecks().getBrawl(), filter); addDecksRecursivelly("Brawl", GameType.Brawl, result, "", FModel.getDecks().getBrawl(), filter);
return result; return result;

14
forge-gui/src/main/java/forge/deck/DeckgenUtil.java
View File

@@ -61,7 +61,7 @@ public class DeckgenUtil {
try { try {
List<String> keys = new ArrayList<>(CardArchetypeLDAGenerator.ldaPools.get(format.getName()).keySet()); List<String> keys = new ArrayList<>(CardArchetypeLDAGenerator.ldaPools.get(format.getName()).keySet());
String randomKey = keys.get( MyRandom.getRandom().nextInt(keys.size()) ); String randomKey = keys.get( MyRandom.getRandom().nextInt(keys.size()) );
Predicate<PaperCard> cardFilter = Predicates.and(format.getFilterPrinted(),PaperCard.Predicates.name(randomKey)); Predicate<PaperCard> cardFilter = format.getFilterPrinted().and(PaperCard.Predicates.name(randomKey));
PaperCard keyCard = FModel.getMagicDb().getCommonCards().getAllCards(cardFilter).get(0); PaperCard keyCard = FModel.getMagicDb().getCommonCards().getAllCards(cardFilter).get(0);
return buildCardGenDeck(keyCard,format,isForAI); return buildCardGenDeck(keyCard,format,isForAI);
@@ -73,7 +73,7 @@ public class DeckgenUtil {
public static Deck buildCardGenDeck(String cardName, GameFormat format, boolean isForAI){ public static Deck buildCardGenDeck(String cardName, GameFormat format, boolean isForAI){
try { try {
Predicate<PaperCard> cardFilter = Predicates.and(format.getFilterPrinted(),PaperCard.Predicates.name(cardName)); Predicate<PaperCard> cardFilter = format.getFilterPrinted().and(PaperCard.Predicates.name(cardName));
return buildCardGenDeck(FModel.getMagicDb().getCommonCards().getAllCards(cardFilter).get(0),format,isForAI); return buildCardGenDeck(FModel.getMagicDb().getCommonCards().getAllCards(cardFilter).get(0),format,isForAI);
}catch (Exception e){ }catch (Exception e){
e.printStackTrace(); e.printStackTrace();
@@ -467,17 +467,19 @@ public class DeckgenUtil {
deck = Aggregates.random(geneticAI).getDeck(); deck = Aggregates.random(geneticAI).getDeck();
} else { } else {
Predicate<DeckProxy> sizePredicate = deckProxy -> deckProxy.getMainSize() <= 60;
if (!selection.isEmpty() && selection.size() < 4) { if (!selection.isEmpty() && selection.size() < 4) {
Predicate<DeckProxy> pred = Predicates.and(deckProxy -> deckProxy.getMainSize() <= 60, deckProxy -> deckProxy.getColorIdentity().hasAllColors(ColorSet.fromNames(colors.toCharArray()).getColor())); Predicate<DeckProxy> colorPredicate = deckProxy -> deckProxy.getColorIdentity().hasAllColors(ColorSet.fromNames(colors.toCharArray()).getColor());
Predicate<DeckProxy> pred = sizePredicate.and(colorPredicate);
if (isTheme) if (isTheme)
deck = Aggregates.random(Iterables.filter(advThemes, pred)).getDeck(); deck = Aggregates.random(Iterables.filter(advThemes, pred)).getDeck();
else else
deck = Aggregates.random(Iterables.filter(advPrecons, pred)).getDeck(); deck = Aggregates.random(Iterables.filter(advPrecons, pred)).getDeck();
} else { } else {
if (isTheme) if (isTheme)
deck = Aggregates.random(Iterables.filter(advThemes, deckProxy -> deckProxy.getMainSize() <= 60)).getDeck(); deck = Aggregates.random(Iterables.filter(advThemes, sizePredicate)).getDeck();
else else
deck = Aggregates.random(Iterables.filter(advPrecons, deckProxy -> deckProxy.getMainSize() <= 60)).getDeck(); deck = Aggregates.random(Iterables.filter(advPrecons, sizePredicate)).getDeck();
} }
} }
} catch (Exception e) { } catch (Exception e) {
@@ -758,7 +760,7 @@ public class DeckgenUtil {
cardDb = FModel.getMagicDb().getCommonCards(); cardDb = FModel.getMagicDb().getCommonCards();
//shuffle first 400 random cards //shuffle first 400 random cards
Iterable<PaperCard> colorList = Iterables.filter(format.getCardPool(cardDb).getAllCards(), Iterable<PaperCard> colorList = Iterables.filter(format.getCardPool(cardDb).getAllCards(),
Predicates.and(format.isLegalCardPredicate(),Predicates.compose(Predicates.or( format.isLegalCardPredicate().and(Predicates.compose(Predicates.or(
new CardThemedDeckBuilder.MatchColorIdentity(commander.getRules().getColorIdentity()), new CardThemedDeckBuilder.MatchColorIdentity(commander.getRules().getColorIdentity()),
DeckGeneratorBase.COLORLESS_CARDS), PaperCard::getRules))); DeckGeneratorBase.COLORLESS_CARDS), PaperCard::getRules)));
switch (format) { switch (format) {

10
forge-gui/src/main/java/forge/gamemodes/limited/CardThemedDeckBuilder.java
View File

@@ -319,8 +319,8 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
//Add remaining non-land colour matching cards to sideboard //Add remaining non-land colour matching cards to sideboard
final CardPool cp = result.getOrCreate(DeckSection.Sideboard); final CardPool cp = result.getOrCreate(DeckSection.Sideboard);
Iterable<PaperCard> potentialSideboard = Iterables.filter(aiPlayables, Iterable<PaperCard> potentialSideboard = Iterables.filter(aiPlayables,
Predicates.and(Predicates.compose(hasColor, PaperCard::getRules), Predicates.compose(hasColor, PaperCard::getRules)
Predicates.compose(CardRulesPredicates.Presets.IS_NON_LAND, PaperCard::getRules))); .and(Predicates.compose(CardRulesPredicates.Presets.IS_NON_LAND, PaperCard::getRules)));
int i=0; int i=0;
while(i<15 && potentialSideboard.iterator().hasNext()){ while(i<15 && potentialSideboard.iterator().hasNext()){
PaperCard sbCard = potentialSideboard.iterator().next(); PaperCard sbCard = potentialSideboard.iterator().next();
@@ -476,7 +476,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
} }
} }
hasColor = Predicates.and(CardRulesPredicates.Presets.IS_NON_LAND,Predicates.or(new MatchColorIdentity(colors), hasColor = CardRulesPredicates.Presets.IS_NON_LAND.and(Predicates.or(new MatchColorIdentity(colors),
DeckGeneratorBase.COLORLESS_CARDS)); DeckGeneratorBase.COLORLESS_CARDS));
final Iterable<PaperCard> threeColorList = Iterables.filter(aiPlayables, final Iterable<PaperCard> threeColorList = Iterables.filter(aiPlayables,
Predicates.compose(hasColor, PaperCard::getRules)); Predicates.compose(hasColor, PaperCard::getRules));
@@ -521,8 +521,8 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
protected boolean setBasicLandPool(String edition){ protected boolean setBasicLandPool(String edition){
Predicate<PaperCard> isSetBasicLand; Predicate<PaperCard> isSetBasicLand;
if (edition !=null){ if (edition !=null){
isSetBasicLand = Predicates.and(IPaperCard.Predicates.printedInSet(edition), isSetBasicLand = IPaperCard.Predicates.printedInSet(edition)
Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules)); .and(Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules));
}else{ }else{
isSetBasicLand = Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules); isSetBasicLand = Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules);
} }

32
forge-gui/src/main/java/forge/gamemodes/quest/BoosterUtils.java
View File

@@ -72,20 +72,18 @@ public final class BoosterUtils {
private static final Predicate<CardEdition> filterPioneer = formats.getPioneer().editionLegalPredicate; private static final Predicate<CardEdition> filterPioneer = formats.getPioneer().editionLegalPredicate;
private static final Predicate<CardEdition> filterModern= formats.getModern().editionLegalPredicate; private static final Predicate<CardEdition> filterModern= formats.getModern().editionLegalPredicate;
private static final Predicate<CardEdition> filterStandard = Predicates.and(CardEdition.Predicates.CAN_MAKE_BOOSTER, private static final Predicate<CardEdition> filterStandard = CardEdition.Predicates.CAN_MAKE_BOOSTER.and(formats.getStandard().editionLegalPredicate);
formats.getStandard().editionLegalPredicate);
private static final Predicate<CardEdition> filterPioneerNotStandard = Predicates.and( private static final Predicate<CardEdition> filterPioneerNotStandard = CardEdition.Predicates.CAN_MAKE_BOOSTER
CardEdition.Predicates.CAN_MAKE_BOOSTER, .and(filterPioneer
Predicates.and(filterPioneer, formats.getStandard().editionLegalPredicate.negate())); .and(formats.getStandard().editionLegalPredicate.negate()));
private static final Predicate<CardEdition> filterModernNotPioneer = Predicates.and( private static final Predicate<CardEdition> filterModernNotPioneer = CardEdition.Predicates.CAN_MAKE_BOOSTER
CardEdition.Predicates.CAN_MAKE_BOOSTER, .and(filterModern.and(filterPioneer.negate()));
Predicates.and(filterModern, filterPioneer.negate()));
/** The filter not ext. */ /** The filter not ext. */
private static final Predicate<CardEdition> filterNotModern = Predicates.and(CardEdition.Predicates.CAN_MAKE_BOOSTER, private static final Predicate<CardEdition> filterNotModern = CardEdition.Predicates.CAN_MAKE_BOOSTER
filterModern.negate()); .and(filterModern.negate());
/** /**
* Gets the quest starter deck. * Gets the quest starter deck.
@@ -198,7 +196,7 @@ public final class BoosterUtils {
List<InventoryItem> output = new ArrayList<>(); List<InventoryItem> output = new ArrayList<>();
Predicate<CardEdition> filter = Predicates.and(CardEdition.Predicates.CAN_MAKE_BOOSTER, editionFilter); Predicate<CardEdition> filter = CardEdition.Predicates.CAN_MAKE_BOOSTER.and(editionFilter);
Iterable<CardEdition> possibleEditions = Iterables.filter(FModel.getMagicDb().getEditions(), filter); Iterable<CardEdition> possibleEditions = Iterables.filter(FModel.getMagicDb().getEditions(), filter);
if (!possibleEditions.iterator().hasNext()) { if (!possibleEditions.iterator().hasNext()) {
@@ -273,7 +271,7 @@ public final class BoosterUtils {
predicate = CardRulesPredicates.hasColor(color); predicate = CardRulesPredicates.hasColor(color);
} }
if (MyRandom.getRandom().nextDouble() < 0.1) { if (MyRandom.getRandom().nextDouble() < 0.1) {
predicate = Predicates.and(predicate, CardRulesPredicates.Presets.IS_MULTICOLOR); predicate = predicate.and(CardRulesPredicates.Presets.IS_MULTICOLOR);
} }
colorFilters.add(predicate); colorFilters.add(predicate);
} }
@@ -329,10 +327,8 @@ public final class BoosterUtils {
} }
//Try to get multicolored cards that fit into the preferred colors. //Try to get multicolored cards that fit into the preferred colors.
Predicate<CardRules> predicateRules = Predicates.and( Predicate<CardRules> predicateRules = CardRulesPredicates.isColor(preferredColors.get(index))
CardRulesPredicates.isColor(preferredColors.get(index)), .and(CardRulesPredicates.Presets.IS_MULTICOLOR);
CardRulesPredicates.Presets.IS_MULTICOLOR
);
Predicate<PaperCard> predicateCard = Predicates.compose(predicateRules, PaperCard::getRules); Predicate<PaperCard> predicateCard = Predicates.compose(predicateRules, PaperCard::getRules);
//Adjust for the number of multicolored possibilities. This prevents flooding of non-selected //Adjust for the number of multicolored possibilities. This prevents flooding of non-selected
@@ -355,7 +351,7 @@ public final class BoosterUtils {
for (Byte color : otherColors) { for (Byte color : otherColors) {
if (i % 6 == 0) { if (i % 6 == 0) {
colorFilters.add(Predicates.and(CardRulesPredicates.isColor(color), CardRulesPredicates.Presets.IS_MULTICOLOR)); colorFilters.add(CardRulesPredicates.isColor(color).and(CardRulesPredicates.Presets.IS_MULTICOLOR));
} else { } else {
colorFilters.add(CardRulesPredicates.isMonoColor(color)); colorFilters.add(CardRulesPredicates.isMonoColor(color));
} }
@@ -411,7 +407,7 @@ public final class BoosterUtils {
do { do {
if (color2 != null) { if (color2 != null) {
Predicate<PaperCard> color2c = Predicates.compose(color2, PaperCard::getRules); Predicate<PaperCard> color2c = Predicates.compose(color2, PaperCard::getRules);
card = Aggregates.random(Iterables.filter(source, Predicates.and(filter, color2c))); card = Aggregates.random(Iterables.filter(source, filter.and(color2c)));
} }
} while (card == null && colorMisses++ < 10); } while (card == null && colorMisses++ < 10);
} }

6
forge-gui/src/main/java/forge/gamemodes/quest/QuestRewardCard.java
View File

@@ -79,7 +79,7 @@ public abstract class QuestRewardCard implements IQuestRewardCard {
for (final String rule : ruleCodes) { for (final String rule : ruleCodes) {
final Predicate<CardRules> newRule = BoosterUtils.parseRulesLimitation(rule); final Predicate<CardRules> newRule = BoosterUtils.parseRulesLimitation(rule);
if (newRule != null) { if (newRule != null) {
filterRules = (filterRules == null ? newRule : Predicates.and(filterRules, newRule)); filterRules = filterRules == null ? newRule : filterRules.and(newRule);
} }
} }
} }
@@ -107,10 +107,10 @@ public abstract class QuestRewardCard implements IQuestRewardCard {
if (filterRules != null) { if (filterRules != null) {
final Predicate<PaperCard> rulesPrinted = Predicates.compose(filterRules, PaperCard::getRules); final Predicate<PaperCard> rulesPrinted = Predicates.compose(filterRules, PaperCard::getRules);
filters = Predicates.and(filters, rulesPrinted); filters = filters.and(rulesPrinted);
} }
if (filterRarity != null) { if (filterRarity != null) {
filters = Predicates.and(filters, filterRarity); filters = filters.and(filterRarity);
} }
return filters; return filters;
} }

8
forge-gui/src/main/java/forge/gamemodes/quest/QuestUtilCards.java
View File

@@ -207,7 +207,7 @@ public final class QuestUtilCards {
* @return the composite predicate. * @return the composite predicate.
*/ */
public Predicate<PaperCard> applyFormatFilter(Predicate<PaperCard> source) { public Predicate<PaperCard> applyFormatFilter(Predicate<PaperCard> source) {
return questController.getFormat() == null ? source : Predicates.and(source, questController.getFormat().getFilterPrinted()); return questController.getFormat() == null ? source : source.and(questController.getFormat().getFilterPrinted());
} }
/** /**
@@ -636,7 +636,7 @@ public final class QuestUtilCards {
private void generateTournamentsInShop(final int count) { private void generateTournamentsInShop(final int count) {
Predicate<CardEdition> formatFilter = CardEdition.Predicates.HAS_TOURNAMENT_PACK; Predicate<CardEdition> formatFilter = CardEdition.Predicates.HAS_TOURNAMENT_PACK;
if (questController.getFormat() != null) { if (questController.getFormat() != null) {
formatFilter = Predicates.and(formatFilter, isLegalInQuestFormat(questController.getFormat())); formatFilter = formatFilter.and(isLegalInQuestFormat(questController.getFormat()));
} }
Iterable<CardEdition> rightEditions = Iterables.filter(FModel.getMagicDb().getEditions(), formatFilter); Iterable<CardEdition> rightEditions = Iterables.filter(FModel.getMagicDb().getEditions(), formatFilter);
questAssets.getShopList().addAllOfTypeFlat(Aggregates.random(Iterables.transform(rightEditions, TournamentPack::fromSet), count)); questAssets.getShopList().addAllOfTypeFlat(Aggregates.random(Iterables.transform(rightEditions, TournamentPack::fromSet), count));
@@ -651,7 +651,7 @@ public final class QuestUtilCards {
private void generateFatPacksInShop(final int count) { private void generateFatPacksInShop(final int count) {
Predicate<CardEdition> formatFilter = CardEdition.Predicates.HAS_FAT_PACK; Predicate<CardEdition> formatFilter = CardEdition.Predicates.HAS_FAT_PACK;
if (questController.getFormat() != null) { if (questController.getFormat() != null) {
formatFilter = Predicates.and(formatFilter, isLegalInQuestFormat(questController.getFormat())); formatFilter = formatFilter.and(isLegalInQuestFormat(questController.getFormat()));
} }
Iterable<CardEdition> rightEditions = Iterables.filter(FModel.getMagicDb().getEditions(), formatFilter); Iterable<CardEdition> rightEditions = Iterables.filter(FModel.getMagicDb().getEditions(), formatFilter);
questAssets.getShopList().addAllOfTypeFlat(Aggregates.random(Iterables.transform(rightEditions, FatPack::fromSet), count)); questAssets.getShopList().addAllOfTypeFlat(Aggregates.random(Iterables.transform(rightEditions, FatPack::fromSet), count));
@@ -665,7 +665,7 @@ public final class QuestUtilCards {
Predicate<CardEdition> formatFilter = CardEdition.Predicates.HAS_BOOSTER_BOX; Predicate<CardEdition> formatFilter = CardEdition.Predicates.HAS_BOOSTER_BOX;
if (questController.getFormat() != null) { if (questController.getFormat() != null) {
formatFilter = Predicates.and(formatFilter, isLegalInQuestFormat(questController.getFormat())); formatFilter = formatFilter.and(isLegalInQuestFormat(questController.getFormat()));
} }
Iterable<CardEdition> rightEditions = Iterables.filter(FModel.getMagicDb().getEditions(), formatFilter); Iterable<CardEdition> rightEditions = Iterables.filter(FModel.getMagicDb().getEditions(), formatFilter);

2
forge-gui/src/main/java/forge/itemmanager/AdvancedSearch.java
View File

@@ -1581,7 +1581,7 @@ public class AdvancedSearch {
pred = predPiece; pred = predPiece;
} }
else if (operator == Operator.AND) { else if (operator == Operator.AND) {
pred = Predicates.and(pred, predPiece); pred = pred.and(predPiece);
} }
else if (operator == Operator.OR) { else if (operator == Operator.OR) {
pred = Predicates.or(pred, predPiece); pred = Predicates.or(pred, predPiece);

2
forge-gui/src/main/java/forge/itemmanager/BooleanExpression.java
View File

@@ -122,7 +122,7 @@ public class BooleanExpression {
operators.pop(); operators.pop();
right = operands.pop(); right = operands.pop();
left = operands.pop(); left = operands.pop();
operands.push(Predicates.and(left, right)); operands.push(left.and(right));
break; break;
case OR: case OR:
operators.pop(); operators.pop();

2
forge-gui/src/main/java/forge/itemmanager/SFilterUtil.java
View File

@@ -384,6 +384,6 @@ public class SFilterUtil {
} }
public static <T> Predicate<T> optimizedAnd(Predicate<T> p1, Predicate<T> p2) { public static <T> Predicate<T> optimizedAnd(Predicate<T> p1, Predicate<T> p2) {
return p1 == null ? p2 : (p2 == null ? p1 : Predicates.and(p1, p2)); return p1 == null ? p2 : (p2 == null ? p1 : p1.and(p2));
} }
} }

9
forge-gui/src/main/java/forge/model/FModel.java
View File

@@ -335,9 +335,12 @@ public final class FModel {
} }
public static ItemPool<PaperCard> getBrawlCommander() { public static ItemPool<PaperCard> getBrawlCommander() {
if (brawlCommander == null) if (brawlCommander == null) {
return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(Predicates.and( return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(
FModel.getFormats().get("Brawl").getFilterPrinted(), Predicates.compose(CardRulesPredicates.Presets.CAN_BE_BRAWL_COMMANDER, PaperCard::getRules))), PaperCard.class); FModel.getFormats().get("Brawl").getFilterPrinted()
.and(Predicates.compose(CardRulesPredicates.Presets.CAN_BE_BRAWL_COMMANDER, PaperCard::getRules))
), PaperCard.class);
}
return brawlCommander; return brawlCommander;
} }