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)
if (Iterables.any(defendingOpponent.getLandsInPlay(), CardPredicates.Presets.UNTAPPED)) {
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) {
final List<Card> ae = CardLists.filter(list, Predicates.and(
Predicates.or(CardPredicates.Presets.ARTIFACTS, CardPredicates.Presets.ENCHANTMENTS),
card -> !card.hasSVar("DoNotDiscardIfAble")
));
final List<Card> ae = CardLists.filter(list,
Predicates.or(CardPredicates.Presets.ARTIFACTS, CardPredicates.Presets.ENCHANTMENTS)
.and(card -> !card.hasSVar("DoNotDiscardIfAble"))
);
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.util.Iterables;
import forge.util.MyRandom;
import forge.util.Predicates;
import forge.util.TextUtil;
import forge.util.collect.FCollectionView;
import org.apache.commons.lang3.ObjectUtils;
@@ -924,7 +923,7 @@ public class ComputerUtilCost {
public static CardCollection paymentChoicesWithoutTargets(Iterable<Card> choices, SpellAbility source, Player ai) {
if (source.usesTargeting()) {
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);
}

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.util.Iterables;
import forge.util.MyRandom;
import forge.util.Predicates;
import forge.util.TextUtil;
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
// be tapped to pay its own cost if there's another untapped land like that available
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;
}
}

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.Collections;
import java.util.List;
import java.util.function.Predicate;
/**
* Special logic for individual cards
@@ -359,7 +360,7 @@ public class SpecialCardAi {
public static boolean considerSacrificingCreature(final Player ai, final SpellAbility sa) {
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))));
boolean hasUsefulBlocker = false;
@@ -1296,7 +1297,7 @@ public class SpecialCardAi {
public static boolean considerSecondTarget(final Player ai, final SpellAbility sa) {
Card firstTgt = sa.getParent().getTargetCard();
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);
if (secondTgt != null) {
sa.resetTargets();
@@ -1316,7 +1317,7 @@ public class SpecialCardAi {
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;
for (Card c : ai.getCardsIn(ZoneType.Battlefield)) {
@@ -1334,7 +1335,7 @@ public class SpecialCardAi {
}
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!
// 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

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.util.Aggregates;
import forge.util.Iterables;
import forge.util.Predicates;
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.
if (!Iterables.isEmpty(options)) {
List<Card> oppCreatures = CardLists.filter(options, Predicates.and(CardPredicates.Presets.CREATURES,
CardPredicates.isOwner(aiChoser).negate()));
List<Card> oppCreatures = CardLists.filter(options,
CardPredicates.Presets.CREATURES.and(CardPredicates.isOwner(aiChoser).negate()));
List<Card> aiNonCreatures = CardLists.filter(options,
CardPredicates.Presets.CREATURES.negate()
.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.zone.ZoneType;
import forge.util.Iterables;
import forge.util.Predicates;
public class CountersRemoveAi extends SpellAbilityAi {
@@ -183,7 +182,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
list = CardLists.filter(list, CardPredicates.isTargetableBy(sa));
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));
if (!planeswalkerList.isEmpty()) {
@@ -223,7 +222,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
// remove P1P1 counters from opposing creatures
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));
if (!oppP1P1List.isEmpty()) {
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.spellability.SpellAbility;
import forge.game.zone.ZoneType;
import forge.util.Predicates;
import java.util.function.Predicate;
@@ -110,8 +109,8 @@ public class DestroyAllAi extends SpellAbilityAi {
// Special handling for Raiding Party
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 numOppsCanSave = Math.min(CardLists.count(ai.getOpponents().getCreaturesInPlay(), Predicates.and(CardPredicates.isColor(MagicColor.WHITE), CardPredicates.Presets.UNTAPPED)) * 2, opplist.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(), CardPredicates.isColor(MagicColor.WHITE).and(CardPredicates.Presets.UNTAPPED)) * 2, opplist.size());
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.PlayerPredicates;
import forge.game.spellability.SpellAbility;
import forge.util.Predicates;
import forge.util.collect.FCollection;
public class LifeLoseAi extends SpellAbilityAi {
@@ -128,7 +127,7 @@ public class LifeLoseAi extends SpellAbilityAi {
final PlayerCollection tgtPlayers = getPlayers(ai, sa);
// TODO: check against the amount we could obtain when multiple activations are possible
PlayerCollection filteredPlayer = tgtPlayers
.filter(Predicates.and(PlayerPredicates.isOpponentOf(ai), PlayerPredicates.lifeLessOrEqualTo(amount)));
.filter(PlayerPredicates.isOpponentOf(ai).and(PlayerPredicates.lifeLessOrEqualTo(amount)));
// killing opponents asap
if (!filteredPlayer.isEmpty()) {
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.zone.ZoneType;
import forge.util.Iterables;
import forge.util.Predicates;
public class MeldAi extends SpellAbilityAi {
@Override
@@ -20,10 +19,10 @@ public class MeldAi extends SpellAbilityAi {
return false;
}
boolean hasPrimaryMeld = Iterables.any(cardsOTB, Predicates.and(
CardPredicates.nameEquals(primaryMeld), CardPredicates.isOwner(aiPlayer)));
boolean hasSecondaryMeld = Iterables.any(cardsOTB, Predicates.and(
CardPredicates.nameEquals(secondaryMeld), CardPredicates.isOwner(aiPlayer)));
boolean hasPrimaryMeld = Iterables.any(cardsOTB,
CardPredicates.nameEquals(primaryMeld).and(CardPredicates.isOwner(aiPlayer)));
boolean hasSecondaryMeld = Iterables.any(cardsOTB,
CardPredicates.nameEquals(secondaryMeld).and(CardPredicates.isOwner(aiPlayer)));
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
cardQueryFilter = card -> card.getArtIndex() == cr.artIndex;
cardQueryFilter = Predicates.and(cardQueryFilter, filter);
cardQueryFilter = cardQueryFilter.and(filter);
cards = getAllCards(cr.cardName, cardQueryFilter);
// 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
@@ -879,7 +879,7 @@ public final class CardDb implements ICardDatabase, IDeckGenPool {
return 0;
Predicate<PaperCard> predicate = card -> card.getEdition().equalsIgnoreCase(setCode);
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);
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();
Iterable<CardEdition> editionsWithBasicLands = Iterables.filter(
StaticData.instance().getEditions().getOrderedEditions(),
forge.util.Predicates.and(hasBasicLands, artPreference::accept));
hasBasicLands.and(artPreference::accept));
Iterator<CardEdition> editionsIterator = editionsWithBasicLands.iterator();
List<CardEdition> selectedEditions = new ArrayList<CardEdition>();
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_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_ATTRACTION = Predicates.and(Presets.IS_ARTIFACT,
CardRulesPredicates.subType("Attraction")
);
public static final Predicate<CardRules> IS_ATTRACTION = Presets.IS_ARTIFACT.and(CardRulesPredicates.subType("Attraction"));
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,
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));
public static final Predicate<CardRules> CAN_BE_BRAWL_COMMANDER = Presets.IS_LEGENDARY.and(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));
/** The Constant 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.PaperCard;
import forge.util.Iterables;
import forge.util.Predicates;
public class DeckGenPool implements IDeckGenPool {
private final Map<String, PaperCard> cards = new HashMap<>();
@@ -38,7 +37,7 @@ public class DeckGenPool implements IDeckGenPool {
@Override
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);
if (editionCards.iterator().hasNext()){
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){
Predicate<PaperCard> isSetBasicLand;
if (edition !=null){
isSetBasicLand = Predicates.and(IPaperCard.Predicates.printedInSet(edition),
Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules));
isSetBasicLand = IPaperCard.Predicates.printedInSet(edition)
.and(Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules));
}else{
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);
}
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 -> {
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) {
Predicate<PaperCard> cardsRule = Predicates.and(
IPaperCard.Predicates.printedInSet(setCode),
Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules));
Predicate<PaperCard> cardsRule = IPaperCard.Predicates.printedInSet(setCode)
.and(Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules));
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();
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));
} 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));
}
//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) {
return x -> predicate.test(function.apply(x));
}
@@ -23,11 +24,6 @@ public class Predicates {
//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) {
//TODO: remove casting?
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();
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 {
p = Predicates.and(p, IPaperCard.Predicates.Presets.IS_REBALANCED.negate());
p = p.and(IPaperCard.Predicates.Presets.IS_REBALANCED.negate());
}
if (!this.getAllowedSetCodes().isEmpty()) {
p = Predicates.and(p, printed ?
p = p.and(printed ?
IPaperCard.Predicates.printedInSets(this.getAllowedSetCodes(), printed) :
StaticData.instance().getCommonCards().wasPrintedInSets(this.getAllowedSetCodes()));
}
@@ -156,7 +156,7 @@ public class GameFormat implements Comparable<GameFormat> {
for (CardRarity cr: this.getAllowedRarities()) {
crp.add(StaticData.instance().getCommonCards().wasPrintedAtRarity(cr));
}
p = Predicates.and(p, Predicates.or(crp));
p = p.and(Predicates.or(crp));
}
if (!this.getAdditionalCards().isEmpty()) {
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")) {
dungeonCards = StaticData.instance().getVariantCards()
.getAllCards(Predicates.compose(
Predicates.and(CardRulesPredicates.Presets.IS_DUNGEON,
CardRulesPredicates.subType(StringOp.EQUALS, sa.getParam("Dungeon"))),
CardRulesPredicates.Presets.IS_DUNGEON
.and(CardRulesPredicates.subType(StringOp.EQUALS, sa.getParam("Dungeon"))),
PaperCard::getRules));
} else {
// 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) {
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) {
@@ -337,7 +337,7 @@ public class CardLists {
}
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) {

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.game.card.Card;
import forge.game.card.CardPredicates;
import forge.util.Predicates;
import java.util.function.Predicate;
@@ -21,10 +20,9 @@ public enum AttackRestrictionType {
case NEED_GREATER_POWER:
return CardPredicates.hasGreaterPowerThan(attacker.getNetPower());
case NEED_BLACK_OR_GREEN:
return Predicates.and(
CardPredicates.isColor((byte) (MagicColor.BLACK | MagicColor.GREEN)),
return CardPredicates.isColor((byte) (MagicColor.BLACK | MagicColor.GREEN))
// may explicitly not be black/green itself
((Predicate<Card>) attacker::equals).negate());
.and(((Predicate<Card>) attacker::equals).negate());
case NOT_ALONE:
return x -> true;
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.zone.ZoneType;
import forge.util.Iterables;
import forge.util.Predicates;
/**
* <p>
@@ -114,7 +113,7 @@ public class Untap extends Phase {
*/
private void doUntap() {
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();
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.Map.Entry;
import java.util.function.Predicate;
/**
* <p>
@@ -3749,9 +3750,9 @@ public class Player extends GameEntity implements Comparable<Player> {
public boolean hasUrzaLands() {
final CardCollectionView landsControlled = getCardsIn(ZoneType.Battlefield);
return Iterables.any(landsControlled, Predicates.and(CardPredicates.isType("Urza's"), CardPredicates.isType("Mine")))
&& Iterables.any(landsControlled, Predicates.and(CardPredicates.isType("Urza's"), CardPredicates.isType("Power-Plant")))
&& Iterables.any(landsControlled, Predicates.and(CardPredicates.isType("Urza's"), CardPredicates.isType("Tower")));
return Iterables.any(landsControlled, CardPredicates.isType("Urza's").and(CardPredicates.isType("Mine")))
&& Iterables.any(landsControlled, CardPredicates.isType("Urza's").and(CardPredicates.isType("Power-Plant")))
&& Iterables.any(landsControlled, CardPredicates.isType("Urza's").and(CardPredicates.isType("Tower")));
}
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 forge.util.Iterables;
import forge.util.Predicates;
import org.apache.commons.lang3.ArrayUtils;
public class StaticAbilityPanharmonicon {
@@ -178,10 +177,10 @@ public class StaticAbilityPanharmonicon {
Map<Card, Integer> dmgMap = (Map<Card, Integer>) runParams.get(AbilityKey.DamageMap);
// 1. check it's valid cause for static
// 2. and it must also be valid for trigger event
if (!Iterables.any(dmgMap.keySet(), Predicates.and(
GameObjectPredicates.matchesValidParam(stAb, "ValidSource"),
GameObjectPredicates.matchesValidParam(trigger, "ValidSource")
))) {
if (!Iterables.any(dmgMap.keySet(),
GameObjectPredicates.matchesValidParam(stAb, "ValidSource")
.and(GameObjectPredicates.matchesValidParam(trigger, "ValidSource"))
)) {
return false;
}
// DamageAmount$ can be ignored for now (its usage doesn't interact with ValidSource from either)
@@ -191,10 +190,9 @@ public class StaticAbilityPanharmonicon {
return false;
}
Map<GameEntity, Integer> dmgMap = (Map<GameEntity, Integer>) runParams.get(AbilityKey.DamageMap);
if (!Iterables.any(dmgMap.keySet(), Predicates.and(
GameObjectPredicates.matchesValidParam(stAb, "ValidTarget"),
GameObjectPredicates.matchesValidParam(trigger, "ValidTarget")
))) {
if (!Iterables.any(dmgMap.keySet(), GameObjectPredicates.matchesValidParam(stAb, "ValidTarget")
.and(GameObjectPredicates.matchesValidParam(trigger, "ValidTarget"))
)) {
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) {
return x -> true;
}
predicate = Predicates.and(predicate, CardRulesPredicates.Presets.IS_CREATURE);
predicate = predicate.and(CardRulesPredicates.Presets.IS_CREATURE);
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) {
return x -> true;
}
predicate = Predicates.and(predicate, CardRulesPredicates.Presets.IS_CREATURE);
predicate = predicate.and(CardRulesPredicates.Presets.IS_CREATURE);
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){
GameFormat format = FModel.getFormats().get("Brawl");
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);
}
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.util.Aggregates;
import forge.util.MyRandom;
import forge.util.Predicates;
import org.apache.commons.lang3.tuple.Pair;
import java.io.Serializable;
@@ -319,7 +318,7 @@ public class AdventureEventData implements Serializable {
private CardBlock pickWeightedCardBlock() {
CardEdition.Collection editions = FModel.getMagicDb().getEditions();
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<>();
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.util.Aggregates;
import forge.util.Iterables;
import forge.util.Predicates;
import java.text.SimpleDateFormat;
import java.util.*;
@@ -792,7 +791,7 @@ public class CardUtil {
}
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);
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) {
filter = Predicates.and(filter, additionalFilter);
filter = filter.and(additionalFilter);
}
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) {
return x -> true;
}
predicate = Predicates.and(predicate, CardRulesPredicates.Presets.IS_CREATURE);
predicate = predicate.and(CardRulesPredicates.Presets.IS_CREATURE);
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) {
return x -> true;
}
predicate = Predicates.and(predicate, CardRulesPredicates.Presets.IS_CREATURE);
predicate = predicate.and(CardRulesPredicates.Presets.IS_CREATURE);
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) {
return selectedOption.getPredicate();
}
return Predicates.and(predicate, selectedOption.getPredicate());
return predicate.and(selectedOption.getPredicate());
}
@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;
@SuppressWarnings("unchecked")
Iterable<PaperCard> legends = Iterables.filter(uniqueCards.toFlatList(), Predicates.and(format.isLegalCommanderPredicate(), Predicates.compose(
canPlay, PaperCard::getRules)));
Iterable<PaperCard> legends = Iterables.filter(uniqueCards.toFlatList(), format.isLegalCommanderPredicate()
.and(Predicates.compose(canPlay, PaperCard::getRules)));
final List<DeckProxy> decks = new ArrayList<>();
for (PaperCard legend: legends) {
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;
@SuppressWarnings("unchecked")
Iterable<PaperCard> legends = Iterables.filter(uniqueCards.toFlatList(), Predicates.and(format.isLegalCardPredicate(),
Predicates.compose(Predicates.and(
CardRulesPredicates.Presets.CAN_BE_BRAWL_COMMANDER,
canPlay), PaperCard::getRules)));
Iterable<PaperCard> legends = Iterables.filter(uniqueCards.toFlatList(), format.isLegalCardPredicate()
.and(Predicates.compose(CardRulesPredicates.Presets.CAN_BE_BRAWL_COMMANDER.and(canPlay), PaperCard::getRules)));
final List<DeckProxy> decks = new ArrayList<>();
for (PaperCard legend: legends) {
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.IHasName;
import forge.util.Iterables;
import forge.util.Predicates;
import forge.util.storage.IStorage;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
@@ -473,7 +472,7 @@ public class DeckProxy implements InventoryItem {
if (filter == null) {
filter = DeckFormat.TinyLeaders.hasLegalCardsPredicate(FModel.getPreferences().getPrefBoolean(FPref.ENFORCE_DECK_LEGALITY));
} 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);
return result;
@@ -487,7 +486,7 @@ public class DeckProxy implements InventoryItem {
if (filter == null) {
filter = DeckFormat.Brawl.hasLegalCardsPredicate(FModel.getPreferences().getPrefBoolean(FPref.ENFORCE_DECK_LEGALITY));
} 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);
return result;

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

@@ -61,7 +61,7 @@ public class DeckgenUtil {
try {
List<String> keys = new ArrayList<>(CardArchetypeLDAGenerator.ldaPools.get(format.getName()).keySet());
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);
return buildCardGenDeck(keyCard,format,isForAI);
@@ -73,7 +73,7 @@ public class DeckgenUtil {
public static Deck buildCardGenDeck(String cardName, GameFormat format, boolean isForAI){
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);
}catch (Exception e){
e.printStackTrace();
@@ -467,17 +467,19 @@ public class DeckgenUtil {
deck = Aggregates.random(geneticAI).getDeck();
} else {
Predicate<DeckProxy> sizePredicate = deckProxy -> deckProxy.getMainSize() <= 60;
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)
deck = Aggregates.random(Iterables.filter(advThemes, pred)).getDeck();
else
deck = Aggregates.random(Iterables.filter(advPrecons, pred)).getDeck();
} else {
if (isTheme)
deck = Aggregates.random(Iterables.filter(advThemes, deckProxy -> deckProxy.getMainSize() <= 60)).getDeck();
deck = Aggregates.random(Iterables.filter(advThemes, sizePredicate)).getDeck();
else
deck = Aggregates.random(Iterables.filter(advPrecons, deckProxy -> deckProxy.getMainSize() <= 60)).getDeck();
deck = Aggregates.random(Iterables.filter(advPrecons, sizePredicate)).getDeck();
}
}
} catch (Exception e) {
@@ -758,7 +760,7 @@ public class DeckgenUtil {
cardDb = FModel.getMagicDb().getCommonCards();
//shuffle first 400 random cards
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()),
DeckGeneratorBase.COLORLESS_CARDS), PaperCard::getRules)));
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
final CardPool cp = result.getOrCreate(DeckSection.Sideboard);
Iterable<PaperCard> potentialSideboard = Iterables.filter(aiPlayables,
Predicates.and(Predicates.compose(hasColor, PaperCard::getRules),
Predicates.compose(CardRulesPredicates.Presets.IS_NON_LAND, PaperCard::getRules)));
Predicates.compose(hasColor, PaperCard::getRules)
.and(Predicates.compose(CardRulesPredicates.Presets.IS_NON_LAND, PaperCard::getRules)));
int i=0;
while(i<15 && potentialSideboard.iterator().hasNext()){
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));
final Iterable<PaperCard> threeColorList = Iterables.filter(aiPlayables,
Predicates.compose(hasColor, PaperCard::getRules));
@@ -521,8 +521,8 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
protected boolean setBasicLandPool(String edition){
Predicate<PaperCard> isSetBasicLand;
if (edition !=null){
isSetBasicLand = Predicates.and(IPaperCard.Predicates.printedInSet(edition),
Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules));
isSetBasicLand = IPaperCard.Predicates.printedInSet(edition)
.and(Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules));
}else{
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> filterModern= formats.getModern().editionLegalPredicate;
private static final Predicate<CardEdition> filterStandard = Predicates.and(CardEdition.Predicates.CAN_MAKE_BOOSTER,
formats.getStandard().editionLegalPredicate);
private static final Predicate<CardEdition> filterStandard = CardEdition.Predicates.CAN_MAKE_BOOSTER.and(formats.getStandard().editionLegalPredicate);
private static final Predicate<CardEdition> filterPioneerNotStandard = Predicates.and(
CardEdition.Predicates.CAN_MAKE_BOOSTER,
Predicates.and(filterPioneer, formats.getStandard().editionLegalPredicate.negate()));
private static final Predicate<CardEdition> filterPioneerNotStandard = CardEdition.Predicates.CAN_MAKE_BOOSTER
.and(filterPioneer
.and(formats.getStandard().editionLegalPredicate.negate()));
private static final Predicate<CardEdition> filterModernNotPioneer = Predicates.and(
CardEdition.Predicates.CAN_MAKE_BOOSTER,
Predicates.and(filterModern, filterPioneer.negate()));
private static final Predicate<CardEdition> filterModernNotPioneer = CardEdition.Predicates.CAN_MAKE_BOOSTER
.and(filterModern.and(filterPioneer.negate()));
/** The filter not ext. */
private static final Predicate<CardEdition> filterNotModern = Predicates.and(CardEdition.Predicates.CAN_MAKE_BOOSTER,
filterModern.negate());
private static final Predicate<CardEdition> filterNotModern = CardEdition.Predicates.CAN_MAKE_BOOSTER
.and(filterModern.negate());
/**
* Gets the quest starter deck.
@@ -198,7 +196,7 @@ public final class BoosterUtils {
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);
if (!possibleEditions.iterator().hasNext()) {
@@ -273,7 +271,7 @@ public final class BoosterUtils {
predicate = CardRulesPredicates.hasColor(color);
}
if (MyRandom.getRandom().nextDouble() < 0.1) {
predicate = Predicates.and(predicate, CardRulesPredicates.Presets.IS_MULTICOLOR);
predicate = predicate.and(CardRulesPredicates.Presets.IS_MULTICOLOR);
}
colorFilters.add(predicate);
}
@@ -329,10 +327,8 @@ public final class BoosterUtils {
}
//Try to get multicolored cards that fit into the preferred colors.
Predicate<CardRules> predicateRules = Predicates.and(
CardRulesPredicates.isColor(preferredColors.get(index)),
CardRulesPredicates.Presets.IS_MULTICOLOR
);
Predicate<CardRules> predicateRules = CardRulesPredicates.isColor(preferredColors.get(index))
.and(CardRulesPredicates.Presets.IS_MULTICOLOR);
Predicate<PaperCard> predicateCard = Predicates.compose(predicateRules, PaperCard::getRules);
//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) {
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 {
colorFilters.add(CardRulesPredicates.isMonoColor(color));
}
@@ -411,7 +407,7 @@ public final class BoosterUtils {
do {
if (color2 != null) {
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);
}

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) {
final Predicate<CardRules> newRule = BoosterUtils.parseRulesLimitation(rule);
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) {
final Predicate<PaperCard> rulesPrinted = Predicates.compose(filterRules, PaperCard::getRules);
filters = Predicates.and(filters, rulesPrinted);
filters = filters.and(rulesPrinted);
}
if (filterRarity != null) {
filters = Predicates.and(filters, filterRarity);
filters = filters.and(filterRarity);
}
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.
*/
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) {
Predicate<CardEdition> formatFilter = CardEdition.Predicates.HAS_TOURNAMENT_PACK;
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);
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) {
Predicate<CardEdition> formatFilter = CardEdition.Predicates.HAS_FAT_PACK;
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);
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;
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);

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

@@ -1581,7 +1581,7 @@ public class AdvancedSearch {
pred = predPiece;
}
else if (operator == Operator.AND) {
pred = Predicates.and(pred, predPiece);
pred = pred.and(predPiece);
}
else if (operator == Operator.OR) {
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();
right = operands.pop();
left = operands.pop();
operands.push(Predicates.and(left, right));
operands.push(left.and(right));
break;
case OR:
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) {
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() {
if (brawlCommander == null)
return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(Predicates.and(
FModel.getFormats().get("Brawl").getFilterPrinted(), Predicates.compose(CardRulesPredicates.Presets.CAN_BE_BRAWL_COMMANDER, PaperCard::getRules))), PaperCard.class);
if (brawlCommander == null) {
return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(
FModel.getFormats().get("Brawl").getFilterPrinted()
.and(Predicates.compose(CardRulesPredicates.Presets.CAN_BE_BRAWL_COMMANDER, PaperCard::getRules))
), PaperCard.class);
}
return brawlCommander;
}