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

Guava migration - Remove single use Predicate implementations

Browse Source 
Remove unused parameters of other predicates
This commit is contained in:
Jetz
2024-09-24 09:33:23 -04:00
parent 1af22ff4b6
commit a57bab1dac
12 changed files with 73 additions and 397 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1060,69 +1060,26 @@ public final class CardDb implements ICardDatabase, IDeckGenPool {
}
@Override
public Predicate<? super PaperCard> wasPrintedInSets(List<String> setCodes) {
return new PredicateExistsInSets(setCodes);
}
private class PredicateExistsInSets implements Predicate<PaperCard> {
private final List<String> sets;
public PredicateExistsInSets(final List<String> wantSets) {
this.sets = wantSets; // maybe should make a copy here?
}
@Override
public boolean test(final PaperCard subject) {
for (PaperCard c : getAllCards(subject.getName())) {
if (sets.contains(c.getEdition())) {
return true;
}
}
return false;
}
public Predicate<? super PaperCard> wasPrintedInSets(Collection<String> setCodes) {
Set<String> sets = new HashSet<>(setCodes);
return paperCard -> getAllCards(paperCard.getName()).stream()
.map(PaperCard::getEdition)
.anyMatch(sets::contains);
}
// This Predicate validates if a card is legal in a given format (identified by the list of allowed sets)
@Override
public Predicate<? super PaperCard> isLegal(List<String> allowedSetCodes){
return new PredicateLegalInSets(allowedSetCodes);
}
private class PredicateLegalInSets implements Predicate<PaperCard> {
private final List<String> sets = new ArrayList<>();
public PredicateLegalInSets(final List<String> allowedSets){
this.sets.addAll(allowedSets);
}
@Override
public boolean test(final PaperCard card){
if (card == null) return false;
return this.sets.contains(card.getEdition());
}
public Predicate<? super PaperCard> isLegal(Collection<String> allowedSetCodes){
Set<String> sets = new HashSet<>(allowedSetCodes);
return paperCard -> paperCard != null && sets.contains(paperCard.getEdition());
}
// This Predicate validates if a card was printed at [rarity], on any of its printings
@Override
public Predicate<? super PaperCard> wasPrintedAtRarity(CardRarity rarity) {
return new PredicatePrintedAtRarity(rarity);
}
private class PredicatePrintedAtRarity implements Predicate<PaperCard> {
private final Set<String> matchingCards;
public PredicatePrintedAtRarity(CardRarity rarity) {
this.matchingCards = new HashSet<>();
for (PaperCard c : getAllCards()) {
if (c.getRarity() == rarity) {
this.matchingCards.add(c.getName());
}
}
}
@Override
public boolean test(final PaperCard subject) {
return matchingCards.contains(subject.getName());
}
return paperCard -> getAllCards(paperCard.getName()).stream()
.map(PaperCard::getRarity)
.anyMatch(rarity::equals);
}
public StringBuilder appendCardToStringBuilder(PaperCard card, StringBuilder sb) {

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

@@ -892,14 +892,7 @@ public final class CardEdition implements Comparable<CardEdition> {
}
public static class Predicates {
public static final Predicate<CardEdition> CAN_MAKE_BOOSTER = new CanMakeBooster();
private static class CanMakeBooster implements Predicate<CardEdition> {
@Override
public boolean test(final CardEdition subject) {
return subject.hasBoosterTemplate();
}
}
public static final Predicate<CardEdition> CAN_MAKE_BOOSTER = CardEdition::hasBoosterTemplate;
public static CardEdition getRandomSetWithAllBasicLands(Iterable<CardEdition> allEditions) {
return Aggregates.random(Iterables.filter(allEditions, hasBasicLands));
@@ -921,29 +914,11 @@ public final class CardEdition implements Comparable<CardEdition> {
}
public static final Predicate<CardEdition> HAS_TOURNAMENT_PACK = new CanMakeStarter();
private static class CanMakeStarter implements Predicate<CardEdition> {
@Override
public boolean test(final CardEdition subject) {
return StaticData.instance().getTournamentPacks().contains(subject.getCode());
}
}
public static final Predicate<CardEdition> HAS_TOURNAMENT_PACK = edition -> StaticData.instance().getTournamentPacks().contains(edition.getCode());
public static final Predicate<CardEdition> HAS_FAT_PACK = new CanMakeFatPack();
private static class CanMakeFatPack implements Predicate<CardEdition> {
@Override
public boolean test(final CardEdition subject) {
return subject.getFatPackCount() > 0;
}
}
public static final Predicate<CardEdition> HAS_FAT_PACK = edition -> edition.getFatPackCount() > 0;
public static final Predicate<CardEdition> HAS_BOOSTER_BOX = new CanMakeBoosterBox();
private static class CanMakeBoosterBox implements Predicate<CardEdition> {
@Override
public boolean test(final CardEdition subject) {
return subject.getBoosterBoxCount() > 0;
}
}
public static final Predicate<CardEdition> HAS_BOOSTER_BOX = edition -> edition.getBoosterBoxCount() > 0;
public static final Predicate<CardEdition> hasBasicLands = ed -> {
if (ed == null) {

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

@@ -85,14 +85,6 @@ public final class CardRulesPredicates {
return new LeafString(LeafString.CardField.NAME, op, what);
}
/**
* TODO: Write javadoc for this method.
* @param transform
* @return
*/
public static Predicate<CardRules> splitType(final CardSplitType transform) {
return new PredicateSplitType(transform);
}
/**
* Sub type.
@@ -105,15 +97,6 @@ public final class CardRulesPredicates {
return new LeafString(LeafString.CardField.SUBTYPE, PredicateString.StringOp.CONTAINS, what);
}
/**
* Sub type.
*
* @param op
* the op
* @param what
* the what
* @return the predicate
*/
public static Predicate<CardRules> subType(final PredicateString.StringOp op, final String what) {
return new LeafString(LeafString.CardField.SUBTYPE, op, what);
}
@@ -172,64 +155,26 @@ public final class CardRulesPredicates {
};
}
/**
* Core type.
*
* @param isEqual
* the is equal
* @param what
* the what
* @return the predicate
*/
public static Predicate<CardRules> coreType(final boolean isEqual, final String what) {
public static Predicate<CardRules> coreType(final String what) {
try {
return CardRulesPredicates.coreType(isEqual, Enum.valueOf(CardType.CoreType.class, what));
return CardRulesPredicates.coreType(Enum.valueOf(CardType.CoreType.class, what));
} catch (final Exception e) {
return x -> false;
}
}
/**
* Core type.
*
* @param isEqual
* the is equal
* @param type
* the type
* @return the predicate
* @return a Predicate that matches cards that have the specified core type.
*/
public static Predicate<CardRules> coreType(final boolean isEqual, final CardType.CoreType type) {
return new PredicateCoreType(type, isEqual);
public static Predicate<CardRules> coreType(final CardType.CoreType type) {
return card -> card.getType().hasType(type);
}
/**
* Super type.
*
* @param isEqual
* the is equal
* @param what
* the what
* @return the predicate
* @return a Predicate that matches cards that have the specified supertype.
*/
public static Predicate<CardRules> superType(final boolean isEqual, final String what) {
try {
return CardRulesPredicates.superType(isEqual, Enum.valueOf(CardType.Supertype.class, what));
} catch (final Exception e) {
return x -> false;
}
}
/**
* Super type.
*
* @param isEqual
* the is equal
* @param type
* the type
* @return the predicate
*/
public static Predicate<CardRules> superType(final boolean isEqual, final CardType.Supertype type) {
return new PredicateSuperType(type, isEqual);
public static Predicate<CardRules> superType(final CardType.Supertype type) {
return card -> card.getType().hasSupertype(type);
}
/**
@@ -494,58 +439,12 @@ public final class CardRulesPredicates {
}
}
private static class PredicateCoreType implements Predicate<CardRules> {
private final CardType.CoreType operand;
private final boolean shouldBeEqual;
@Override
public boolean test(final CardRules card) {
if (null == card) {
return false;
}
return this.shouldBeEqual == card.getType().hasType(this.operand);
}
public PredicateCoreType(final CardType.CoreType type, final boolean wantEqual) {
this.operand = type;
this.shouldBeEqual = wantEqual;
}
}
private static class PredicateSuperType implements Predicate<CardRules> {
private final CardType.Supertype operand;
private final boolean shouldBeEqual;
@Override
public boolean test(final CardRules card) {
return this.shouldBeEqual == card.getType().hasSupertype(this.operand);
}
public PredicateSuperType(final CardType.Supertype type, final boolean wantEqual) {
this.operand = type;
this.shouldBeEqual = wantEqual;
}
}
private static class PredicateSplitType implements Predicate<CardRules> {
private final CardSplitType cst;
public PredicateSplitType(final CardSplitType type) {
cst = type;
}
@Override
public boolean test(final CardRules subject) {
return subject.getSplitType() == cst;
}
}
public static final Predicate<CardRules> IS_CREATURE = CardRulesPredicates.coreType(true, CardType.CoreType.Creature);
public static final Predicate<CardRules> IS_LEGENDARY = CardRulesPredicates.superType(true, CardType.Supertype.Legendary);
public static final Predicate<CardRules> IS_ARTIFACT = CardRulesPredicates.coreType(true, CardType.CoreType.Artifact);
public static final Predicate<CardRules> IS_CREATURE = CardRulesPredicates.coreType(CardType.CoreType.Creature);
public static final Predicate<CardRules> IS_LEGENDARY = CardRulesPredicates.superType(CardType.Supertype.Legendary);
public static final Predicate<CardRules> IS_ARTIFACT = CardRulesPredicates.coreType(CardType.CoreType.Artifact);
public static final Predicate<CardRules> IS_ATTRACTION = CardRulesPredicates.IS_ARTIFACT.and(CardRulesPredicates.subType("Attraction"));
public static final Predicate<CardRules> IS_EQUIPMENT = CardRulesPredicates.subType("Equipment");
public static final Predicate<CardRules> IS_LAND = CardRulesPredicates.coreType(true, CardType.CoreType.Land);
public static final Predicate<CardRules> IS_LAND = CardRulesPredicates.coreType(CardType.CoreType.Land);
public static final Predicate<CardRules> IS_BASIC_LAND = subject -> subject.getType().isBasicLand();
public static final Predicate<CardRules> NOT_BASIC_LAND = subject -> !subject.getType().isBasicLand();
/** Matches only Plains, Island, Swamp, Mountain, or Forest. */
@@ -557,25 +456,25 @@ public final class CardRulesPredicates {
public static final Predicate<CardRules> CAN_BE_PARTNER_COMMANDER = CardRules::canBePartnerCommander;
public static final Predicate<CardRules> CAN_BE_OATHBREAKER = CardRules::canBeOathbreaker;
public static final Predicate<CardRules> CAN_BE_SIGNATURE_SPELL = CardRules::canBeSignatureSpell;
public static final Predicate<CardRules> IS_PLANESWALKER = CardRulesPredicates.coreType(true, CardType.CoreType.Planeswalker);
public static final Predicate<CardRules> IS_PLANESWALKER = CardRulesPredicates.coreType(CardType.CoreType.Planeswalker);
public static final Predicate<CardRules> CAN_BE_TINY_LEADERS_COMMANDER = CardRulesPredicates.IS_LEGENDARY.and(CardRulesPredicates.IS_CREATURE.or(CardRulesPredicates.IS_PLANESWALKER));
public static final Predicate<CardRules> CAN_BE_BRAWL_COMMANDER = CardRulesPredicates.IS_LEGENDARY.and(CardRulesPredicates.IS_CREATURE.or(CardRulesPredicates.IS_PLANESWALKER));
public static final Predicate<CardRules> IS_BATTLE = CardRulesPredicates.coreType(true, CardType.CoreType.Battle);
public static final Predicate<CardRules> IS_INSTANT = CardRulesPredicates.coreType(true, CardType.CoreType.Instant);
public static final Predicate<CardRules> IS_SORCERY = CardRulesPredicates.coreType(true, CardType.CoreType.Sorcery);
public static final Predicate<CardRules> IS_ENCHANTMENT = CardRulesPredicates.coreType(true, CardType.CoreType.Enchantment);
public static final Predicate<CardRules> IS_BATTLE = CardRulesPredicates.coreType(CardType.CoreType.Battle);
public static final Predicate<CardRules> IS_INSTANT = CardRulesPredicates.coreType(CardType.CoreType.Instant);
public static final Predicate<CardRules> IS_SORCERY = CardRulesPredicates.coreType(CardType.CoreType.Sorcery);
public static final Predicate<CardRules> IS_ENCHANTMENT = CardRulesPredicates.coreType(CardType.CoreType.Enchantment);
public static final Predicate<CardRules> IS_NON_CREATURE_SPELL = (
CardRulesPredicates.IS_CREATURE.or(CardRulesPredicates.IS_LAND).or(CardRules::isVariant)
).negate();
public static final Predicate<CardRules> IS_PLANE = CardRulesPredicates.coreType(true, CardType.CoreType.Plane);
public static final Predicate<CardRules> IS_PHENOMENON = CardRulesPredicates.coreType(true, CardType.CoreType.Phenomenon);
public static final Predicate<CardRules> IS_PLANE = CardRulesPredicates.coreType(CardType.CoreType.Plane);
public static final Predicate<CardRules> IS_PHENOMENON = CardRulesPredicates.coreType(CardType.CoreType.Phenomenon);
public static final Predicate<CardRules> IS_PLANE_OR_PHENOMENON = IS_PLANE.or(IS_PHENOMENON);
public static final Predicate<CardRules> IS_SCHEME = CardRulesPredicates.coreType(true, CardType.CoreType.Scheme);
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_NON_LAND = CardRulesPredicates.coreType(false, CardType.CoreType.Land);
public static final Predicate<CardRules> IS_SCHEME = CardRulesPredicates.coreType(CardType.CoreType.Scheme);
public static final Predicate<CardRules> IS_VANGUARD = CardRulesPredicates.coreType(CardType.CoreType.Vanguard);
public static final Predicate<CardRules> IS_CONSPIRACY = CardRulesPredicates.coreType(CardType.CoreType.Conspiracy);
public static final Predicate<CardRules> IS_DUNGEON = CardRulesPredicates.coreType(CardType.CoreType.Dungeon);
public static final Predicate<CardRules> IS_NON_LAND = CardRulesPredicates.coreType(CardType.CoreType.Land);
public static final Predicate<CardRules> IS_WHITE = CardRulesPredicates.isColor(MagicColor.WHITE);
public static final Predicate<CardRules> IS_BLUE = CardRulesPredicates.isColor(MagicColor.BLUE);
public static final Predicate<CardRules> IS_BLACK = CardRulesPredicates.isColor(MagicColor.BLACK);

5
forge-core/src/main/java/forge/card/CardSplitType.java
View File

@@ -2,6 +2,8 @@ package forge.card;
import forge.card.CardFace.FaceSelectionMethod;
import java.util.EnumSet;
public enum CardSplitType
{
None(FaceSelectionMethod.USE_PRIMARY_FACE, null),
@@ -13,6 +15,9 @@ public enum CardSplitType
Modal(FaceSelectionMethod.USE_ACTIVE_FACE, CardStateName.Modal),
Specialize(FaceSelectionMethod.USE_ACTIVE_FACE, null);
public static final EnumSet<CardSplitType> DUAL_FACED_CARDS = EnumSet.of(
CardSplitType.Transform, CardSplitType.Meld, CardSplitType.Modal);
CardSplitType(FaceSelectionMethod calcMode, CardStateName stateName) {
method = calcMode;
this.changedStateName = stateName;

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

@@ -94,7 +94,7 @@ public interface ICardDatabase extends Iterable<PaperCard> {
int getMaxArtIndex(String cardName);
int getArtCount(String cardName, String edition);
// Utility Predicates
Predicate<? super PaperCard> wasPrintedInSets(List<String> allowedSetCodes);
Predicate<? super PaperCard> isLegal(List<String> allowedSetCodes);
Predicate<? super PaperCard> wasPrintedInSets(Collection<String> allowedSetCodes);
Predicate<? super PaperCard> isLegal(Collection<String> allowedSetCodes);
Predicate<? super PaperCard> wasPrintedAtRarity(CardRarity rarity);
}

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

@@ -387,7 +387,7 @@ public abstract class DeckGeneratorBase {
}
//filter to provide all dual lands from pool matching 2 or 3 colors from current deck
Predicate<CardRules> dualLandFilter = CardRulesPredicates.coreType(true, CardType.CoreType.Land);
Predicate<CardRules> dualLandFilter = CardRulesPredicates.coreType(CardType.CoreType.Land);
Predicate<CardRules> exceptBasicLand = CardRulesPredicates.NOT_BASIC_LAND;
Iterable<PaperCard> landCards = pool.getAllCards(PaperCardPredicates.fromRules(dualLandFilter.and(exceptBasicLand).and(canPlay)));

89
forge-core/src/main/java/forge/item/PaperCardPredicates.java
View File

@@ -2,7 +2,6 @@ package forge.item;
import com.google.common.collect.Lists;
import forge.card.*;
import forge.util.PredicateCard;
import forge.util.PredicateString;
import org.apache.commons.lang3.StringUtils;
@@ -15,13 +14,6 @@ import java.util.function.Predicate;
* Filters based on PaperCard values.
*/
public abstract class PaperCardPredicates {
public static Predicate<PaperCard> rarity(final boolean isEqual, final CardRarity value) {
return new PredicateRarity(value, isEqual);
}
public static Predicate<PaperCard> color(final boolean isEqual, final boolean noColor, final byte value) {
return new PredicateColor(value, noColor, isEqual);
}
public static Predicate<PaperCard> printedInSets(final String[] sets) {
return printedInSets(Lists.newArrayList(sets), true);
@@ -42,70 +34,50 @@ public abstract class PaperCardPredicates {
}
public static Predicate<PaperCard> name(final String what) {
return new PredicateName(PredicateString.StringOp.EQUALS_IC, what);
}
public static Predicate<PaperCard> name(final PredicateString.StringOp op, final String what) {
return new PredicateName(op, what);
return new PredicateName(what);
}
public static Predicate<PaperCard> names(final List<String> what) {
return new PredicateNames(what);
}
public static Predicate<PaperCard> cards(final List<PaperCard> what) {
return new PredicateCards(what);
}
private static final class PredicateColor implements Predicate<PaperCard> {
private final byte operand;
private final boolean noColor;
private final boolean shouldBeEqual;
private PredicateColor(final byte color, final boolean noColor, final boolean wantEqual) {
private PredicateColor(final byte color) {
this.operand = color;
this.noColor = noColor;
this.shouldBeEqual = wantEqual;
}
@Override
public boolean test(final PaperCard card) {
boolean colorFound = false;
if (noColor) {
return card.getRules().getColor().isColorless() == shouldBeEqual;
}
for (final byte color : card.getRules().getColor()) {
if (color == operand) {
colorFound = true;
break;
return true;
}
}
if (card.getRules().getType().hasType(CardType.CoreType.Land)) {
for (final byte color : card.getRules().getColorIdentity()) {
if (color == operand) {
colorFound = true;
break;
return true;
}
}
}
return colorFound == shouldBeEqual;
return false;
}
}
private static final class PredicateRarity implements Predicate<PaperCard> {
private final CardRarity operand;
private final boolean shouldBeEqual;
@Override
public boolean test(final PaperCard card) {
return (card.getRarity() == this.operand) == this.shouldBeEqual;
return (card.getRarity() == this.operand);
}
private PredicateRarity(final CardRarity type, final boolean wantEqual) {
private PredicateRarity(final CardRarity type) {
this.operand = type;
this.shouldBeEqual = wantEqual;
}
}
@@ -132,8 +104,8 @@ public abstract class PaperCardPredicates {
return this.op(card.getName(), this.operand);
}
private PredicateName(final StringOp operator, final String operand) {
super(operator);
private PredicateName(final String operand) {
super(StringOp.EQUALS_IC);
this.operand = operand;
}
}
@@ -158,42 +130,23 @@ public abstract class PaperCardPredicates {
}
}
private static final class PredicateCards extends PredicateCard<PaperCard> {
private final List<PaperCard> operand;
@Override
public boolean test(final PaperCard card) {
for (final PaperCard element : this.operand) {
if (this.op(card, element)) {
return true;
}
}
return false;
}
private PredicateCards(final List<PaperCard> operand) {
super(StringOp.EQUALS);
this.operand = operand;
}
}
public static Predicate<PaperCard> fromRules(Predicate<CardRules> cardRulesPredicate) {
return paperCard -> cardRulesPredicate.test(paperCard.getRules());
}
public static final Predicate<PaperCard> IS_COMMON = PaperCardPredicates.rarity(true, CardRarity.Common);
public static final Predicate<PaperCard> IS_UNCOMMON = PaperCardPredicates.rarity(true, CardRarity.Uncommon);
public static final Predicate<PaperCard> IS_RARE = PaperCardPredicates.rarity(true, CardRarity.Rare);
public static final Predicate<PaperCard> IS_MYTHIC_RARE = PaperCardPredicates.rarity(true, CardRarity.MythicRare);
public static final Predicate<PaperCard> IS_COMMON = new PredicateRarity(CardRarity.Common);
public static final Predicate<PaperCard> IS_UNCOMMON = new PredicateRarity(CardRarity.Uncommon);
public static final Predicate<PaperCard> IS_RARE = new PredicateRarity(CardRarity.Rare);
public static final Predicate<PaperCard> IS_MYTHIC_RARE = new PredicateRarity(CardRarity.MythicRare);
public static final Predicate<PaperCard> IS_RARE_OR_MYTHIC = PaperCardPredicates.IS_RARE.or(PaperCardPredicates.IS_MYTHIC_RARE);
public static final Predicate<PaperCard> IS_SPECIAL = PaperCardPredicates.rarity(true, CardRarity.Special);
public static final Predicate<PaperCard> IS_BASIC_LAND_RARITY = PaperCardPredicates.rarity(true, CardRarity.BasicLand);
public static final Predicate<PaperCard> IS_BLACK = PaperCardPredicates.color(true, false, MagicColor.BLACK);
public static final Predicate<PaperCard> IS_BLUE = PaperCardPredicates.color(true, false, MagicColor.BLUE);
public static final Predicate<PaperCard> IS_GREEN = PaperCardPredicates.color(true, false, MagicColor.GREEN);
public static final Predicate<PaperCard> IS_RED = PaperCardPredicates.color(true, false, MagicColor.RED);
public static final Predicate<PaperCard> IS_WHITE = PaperCardPredicates.color(true, false, MagicColor.WHITE);
public static final Predicate<PaperCard> IS_COLORLESS = PaperCardPredicates.color(true, true, MagicColor.COLORLESS);
public static final Predicate<PaperCard> IS_SPECIAL = new PredicateRarity(CardRarity.Special);
public static final Predicate<PaperCard> IS_BASIC_LAND_RARITY = new PredicateRarity(CardRarity.BasicLand);
public static final Predicate<PaperCard> IS_BLACK = new PredicateColor(MagicColor.BLACK);
public static final Predicate<PaperCard> IS_BLUE = new PredicateColor(MagicColor.BLUE);
public static final Predicate<PaperCard> IS_GREEN = new PredicateColor(MagicColor.GREEN);
public static final Predicate<PaperCard> IS_RED = new PredicateColor(MagicColor.RED);
public static final Predicate<PaperCard> IS_WHITE = new PredicateColor(MagicColor.WHITE);
public static final Predicate<PaperCard> IS_COLORLESS = paperCard -> paperCard.getRules().getColor().isColorless();
public static final Predicate<PaperCard> IS_UNREBALANCED = PaperCard::isUnRebalanced;
public static final Predicate<PaperCard> IS_REBALANCED = PaperCard::isRebalanced;

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

@@ -673,11 +673,7 @@ public class BoosterGenerator {
Predicate<PaperCard> toAdd = null;
if (operator.equalsIgnoreCase(BoosterSlots.DUAL_FACED_CARD)) {
toAdd = PaperCardPredicates.fromRules(
CardRulesPredicates.splitType(CardSplitType.Transform)
.or(CardRulesPredicates.splitType(CardSplitType.Meld))
.or(CardRulesPredicates.splitType(CardSplitType.Modal)
));
toAdd = card -> CardSplitType.DUAL_FACED_CARDS.contains(card.getRules().getSplitType());
} else if (operator.equalsIgnoreCase(BoosterSlots.LAND)) { toAdd = PaperCardPredicates.IS_LAND;
} else if (operator.equalsIgnoreCase(BoosterSlots.BASIC_LAND)) { toAdd = PaperCardPredicates.IS_BASIC_LAND_RARITY;
} else if (operator.equalsIgnoreCase(BoosterSlots.TIME_SHIFTED)) { toAdd = PaperCardPredicates.IS_SPECIAL;
@@ -718,8 +714,8 @@ public class BoosterGenerator {
toAdd = PaperCardPredicates.printedInSets(sets);
} else if (operator.startsWith("fromSheet(") && invert) {
String sheetName = StringUtils.strip(operator.substring(9), "()\" ");
Iterable<PaperCard> cards = StaticData.instance().getPrintSheets().get(sheetName).toFlatList();
toAdd = PaperCardPredicates.cards(Lists.newArrayList(cards));
Set<PaperCard> cards = Sets.newHashSet(StaticData.instance().getPrintSheets().get(sheetName).toFlatList());
toAdd = cards::contains;
}
if (toAdd == null) {

83
forge-core/src/main/java/forge/util/PredicateCard.java
View File

@@ -1,83 +0,0 @@
/*
* Forge: Play Magic: the Gathering.
* Copyright (C) 2020 Jamin W. Collins
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package forge.util;
import forge.item.PaperCard;
import java.util.function.Predicate;
/**
* Special predicate class to perform string operations.
*
* @param <T>
* the generic type
*/
public abstract class PredicateCard<T> implements Predicate<T> {
/** Possible operators for string operands. */
public enum StringOp {
/** The EQUALS. */
EQUALS,
}
/** The operator. */
private final StringOp operator;
/**
* Op.
*
* @param op1
* the op1
* @param op2
* the op2
* @return true, if successful
*/
protected final boolean op(final PaperCard op1, final PaperCard op2) {
switch (this.getOperator()) {
case EQUALS:
return op1.equals(op2);
default:
return false;
}
}
/**
* Instantiates a new predicate string.
*
* @param operator
* the operator
*/
public PredicateCard(final StringOp operator) {
this.operator = operator;
}
/**
* @return the operator
*/
public StringOp getOperator() {
return operator;
}
public static PredicateCard<PaperCard> equals(final PaperCard what) {
return new PredicateCard<PaperCard>(StringOp.EQUALS) {
public boolean test(PaperCard subject) {
return op(subject, what);
}
};
}
}

2
forge-gui/src/main/java/forge/gamemodes/limited/LimitedDeckBuilder.java
View File

@@ -84,7 +84,7 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
// keep Conspiracies in a separate list
this.draftedConspiracies = aiPlayables.stream()
.filter(PaperCardPredicates.fromRules(CardRulesPredicates.coreType(true, "Conspiracy")))
.filter(PaperCardPredicates.fromRules(CardRulesPredicates.IS_CONSPIRACY))
.collect(Collectors.toList());
this.aiPlayables.removeAll(draftedConspiracies);

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

@@ -465,7 +465,7 @@ public final class QuestUtilCards {
public static Predicate<CardEdition> isLegalInQuestFormat(final GameFormatQuest qFormat) {
if(qFormat == null)
return x -> true;
return GameFormatQuest.QPredicates.isLegalInFormatQuest(qFormat);
return edition -> qFormat.isSetLegal(edition.getCode());
}

26
forge-gui/src/main/java/forge/gamemodes/quest/data/GameFormatQuest.java
View File

@@ -162,30 +162,4 @@ public final class GameFormatQuest extends GameFormat {
return unlocksUsed;
}
public abstract static class QPredicates {
/**
* Checks if is legal in quest format.
*
* @param qFormat the format
* @return the predicate
*/
public static Predicate<CardEdition> isLegalInFormatQuest(final GameFormatQuest qFormat) {
return new LegalInFormatQuest(qFormat);
}
private static final class LegalInFormatQuest implements Predicate<CardEdition> {
private final GameFormatQuest qFormat;
private LegalInFormatQuest(final GameFormatQuest fmt) {
this.qFormat = fmt;
}
@Override
public boolean test(final CardEdition subject) {
return this.qFormat.isSetLegal(subject.getCode());
}
}
}
}