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

Guava migration - Helper method for composing CardRules into PaperCards

Browse Source
This commit is contained in:
Jetz
2024-09-06 19:17:28 -04:00
parent 85f80bb5f1
commit 734bcec8bf
44 changed files with 178 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
forge-core/src/main/java/forge/card/DeckHints.java
View File

@@ -205,6 +205,7 @@ public class DeckHints {
private Iterable<PaperCard> getMatchingItems(Iterable<PaperCard> source, Predicate<CardRules> predicate, Function<PaperCard, CardRules> fn) {
// TODO should token generators be counted differently for their potential?
// And would there ever be a circumstance where `fn` should be anything but PaperCard::getRules?
return Iterables.filter(source, Predicates.compose(tokens ? rulesWithTokens(predicate) : predicate, fn));
}

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

@@ -29,6 +29,7 @@ import forge.deck.generation.DeckGeneratorBase.FilterCMC;
import forge.deck.generation.IDeckGenPool;
import forge.item.IPaperCard;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.util.Aggregates;
import forge.util.Iterables;
import forge.util.Predicates;
@@ -540,6 +541,6 @@ public enum DeckFormat {
//Notably, no partner ability or combination of partner abilities can ever let a player have more than two commanders.
predicate = predicate.or(CardRulesPredicates.canBePartnerCommanderWith(commanders.get(0).getRules()));
}
return Predicates.compose(predicate, PaperCard::getRules);
return PaperCardPredicates.fromRules(predicate);
}
}

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

@@ -87,12 +87,12 @@ public abstract class DeckGeneratorBase {
final Iterable<PaperCard> cards = selectCardsOfMatchingColorForPlayer(forAi);
// build subsets based on type
final Iterable<PaperCard> creatures = Iterables.filter(cards, Predicates.compose(CardRulesPredicates.IS_CREATURE, PaperCard::getRules));
final Iterable<PaperCard> creatures = Iterables.filter(cards, PaperCardPredicates.fromRules(CardRulesPredicates.IS_CREATURE));
final int creatCnt = (int) Math.ceil(getCreaturePercentage() * size);
trace.append("Creatures to add:").append(creatCnt).append("\n");
addCmcAdjusted(creatures, creatCnt, cmcLevels);
Predicate<PaperCard> preSpells = Predicates.compose(CardRulesPredicates.IS_NON_CREATURE_SPELL, PaperCard::getRules);
Predicate<PaperCard> preSpells = PaperCardPredicates.fromRules(CardRulesPredicates.IS_NON_CREATURE_SPELL);
final Iterable<PaperCard> spells = Iterables.filter(cards, preSpells);
final int spellCnt = (int) Math.ceil(getSpellPercentage() * size);
trace.append("Spells to add:").append(spellCnt).append("\n");
@@ -107,11 +107,11 @@ public abstract class DeckGeneratorBase {
protected boolean setBasicLandPool(String edition){
Predicate<PaperCard> isSetBasicLand;
if (edition !=null){
if (edition != null){
isSetBasicLand = PaperCardPredicates.printedInSet(edition)
.and(Predicates.compose(CardRulesPredicates.IS_BASIC_LAND, PaperCard::getRules));
}else{
isSetBasicLand = Predicates.compose(CardRulesPredicates.IS_BASIC_LAND, PaperCard::getRules);
.and(PaperCardPredicates.fromRules(CardRulesPredicates.IS_BASIC_LAND));
} else {
isSetBasicLand = PaperCardPredicates.fromRules(CardRulesPredicates.IS_BASIC_LAND);
}
landPool = new DeckGenPool(StaticData.instance().getCommonCards().getAllCards(isSetBasicLand));
@@ -234,7 +234,7 @@ public abstract class DeckGeneratorBase {
addSome(targetSize - actualSize, tDeck.toFlatList());
}
else if (actualSize > targetSize) {
Predicate<PaperCard> exceptBasicLand = Predicates.compose(CardRulesPredicates.NOT_BASIC_LAND, PaperCard::getRules);
Predicate<PaperCard> exceptBasicLand = PaperCardPredicates.fromRules(CardRulesPredicates.NOT_BASIC_LAND);
for (int i = 0; i < 3 && actualSize > targetSize; i++) {
Iterable<PaperCard> matchingCards = Iterables.filter(tDeck.toFlatList(), exceptBasicLand);
@@ -261,7 +261,7 @@ public abstract class DeckGeneratorBase {
float requestedOverTotal = (float)cnt / totalWeight;
for (ImmutablePair<FilterCMC, Integer> pair : cmcLevels) {
Iterable<PaperCard> matchingCards = Iterables.filter(source, Predicates.compose(pair.getLeft(), PaperCard::getRules));
Iterable<PaperCard> matchingCards = Iterables.filter(source, PaperCardPredicates.fromRules(pair.getLeft()));
int cmcCountForPool = (int) Math.ceil(pair.getRight() * desiredOverTotal);
int addOfThisCmc = Math.round(pair.getRight() * requestedOverTotal);
@@ -291,7 +291,7 @@ public abstract class DeckGeneratorBase {
if (useArtifacts) {
hasColor = hasColor.or(COLORLESS_CARDS);
}
return Iterables.filter(pool.getAllCards(), Predicates.compose(canPlay.and(hasColor).and(canUseInFormat), PaperCard::getRules));
return Iterables.filter(pool.getAllCards(), PaperCardPredicates.fromRules(canPlay.and(hasColor).and(canUseInFormat)));
}
protected static Map<String, Integer> countLands(ItemPool<PaperCard> outList) {
@@ -390,7 +390,7 @@ public abstract class DeckGeneratorBase {
Predicate<CardRules> dualLandFilter = CardRulesPredicates.coreType(true, CardType.CoreType.Land);
Predicate<CardRules> exceptBasicLand = CardRulesPredicates.NOT_BASIC_LAND;
Iterable<PaperCard> landCards = pool.getAllCards(Predicates.compose(dualLandFilter.and(exceptBasicLand).and(canPlay), PaperCard::getRules));
Iterable<PaperCard> landCards = pool.getAllCards(PaperCardPredicates.fromRules(dualLandFilter.and(exceptBasicLand).and(canPlay)));
Iterable<String> dualLandPatterns = Arrays.asList("Add \\{([WUBRG])\\} or \\{([WUBRG])\\}",
"Add \\{([WUBRG])\\}, \\{([WUBRG])\\}, or \\{([WUBRG])\\}",
"Add \\{([WUBRG])\\}\\{([WUBRG])\\}",

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

@@ -1,9 +1,7 @@
package forge.item;
import com.google.common.collect.Lists;
import forge.card.CardRarity;
import forge.card.CardType;
import forge.card.MagicColor;
import forge.card.*;
import forge.util.PredicateCard;
import forge.util.PredicateString;
import org.apache.commons.lang3.StringUtils;
@@ -179,6 +177,11 @@ public abstract class PaperCardPredicates {
}
}
//TODO: Remove
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);

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

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

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

@@ -668,13 +668,12 @@ public class BoosterGenerator {
Predicate<PaperCard> toAdd = null;
if (operator.equalsIgnoreCase(BoosterSlots.DUAL_FACED_CARD)) {
toAdd = Predicates.compose(
toAdd = PaperCardPredicates.fromRules(
CardRulesPredicates.splitType(CardSplitType.Transform)
.or(CardRulesPredicates.splitType(CardSplitType.Meld))
.or(CardRulesPredicates.splitType(CardSplitType.Modal)
),
PaperCard::getRules);
} else if (operator.equalsIgnoreCase(BoosterSlots.LAND)) { toAdd = Predicates.compose(CardRulesPredicates.IS_LAND, PaperCard::getRules);
));
} else if (operator.equalsIgnoreCase(BoosterSlots.LAND)) { toAdd = PaperCardPredicates.fromRules(CardRulesPredicates.IS_LAND);
} else if (operator.equalsIgnoreCase(BoosterSlots.BASIC_LAND)) { toAdd = PaperCardPredicates.IS_BASIC_LAND;
} else if (operator.equalsIgnoreCase(BoosterSlots.TIME_SHIFTED)) { toAdd = PaperCardPredicates.IS_SPECIAL;
} else if (operator.equalsIgnoreCase(BoosterSlots.SPECIAL)) { toAdd = PaperCardPredicates.IS_SPECIAL;

7
forge-game/src/main/java/forge/game/ability/effects/CopyPermanentEffect.java
View File

@@ -5,6 +5,7 @@ import java.util.List;
import java.util.function.Predicate;
import forge.card.GamePieceType;
import forge.item.PaperCardPredicates;
import forge.util.*;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.mutable.MutableBoolean;
@@ -156,11 +157,11 @@ public class CopyPermanentEffect extends TokenEffectBase {
"X", Integer.toString(AbilityUtils.calculateAmount(host, "X", sa)));
}
if (StringUtils.containsIgnoreCase(valid, "creature")) {
Predicate<PaperCard> cpp = Predicates.compose(CardRulesPredicates.IS_CREATURE, PaperCard::getRules);
Predicate<PaperCard> cpp = PaperCardPredicates.fromRules(CardRulesPredicates.IS_CREATURE);
cards = Lists.newArrayList(Iterables.filter(cards, cpp));
}
if (StringUtils.containsIgnoreCase(valid, "equipment")) {
Predicate<PaperCard> cpp = Predicates.compose(CardRulesPredicates.IS_EQUIPMENT, PaperCard::getRules);
Predicate<PaperCard> cpp = PaperCardPredicates.fromRules(CardRulesPredicates.IS_EQUIPMENT);
cards = Lists.newArrayList(Iterables.filter(cards, cpp));
}
if (sa.hasParam("RandomCopied")) {
@@ -193,7 +194,7 @@ public class CopyPermanentEffect extends TokenEffectBase {
}
}
Predicate<PaperCard> cpp = Predicates.compose(CardRulesPredicates.name(StringOp.EQUALS, name), PaperCard::getRules);
Predicate<PaperCard> cpp = PaperCardPredicates.fromRules(CardRulesPredicates.name(StringOp.EQUALS, name));
cards = Lists.newArrayList(Iterables.filter(cards, cpp));
if (!cards.isEmpty()) {

5
forge-game/src/main/java/forge/game/ability/effects/PlayEffect.java
View File

@@ -9,6 +9,7 @@ import java.util.function.Predicate;
import forge.card.CardStateName;
import forge.card.GamePieceType;
import forge.item.PaperCardPredicates;
import forge.util.*;
import org.apache.commons.lang3.StringUtils;
@@ -121,11 +122,11 @@ public class PlayEffect extends SpellAbilityEffect {
}
} else if (valid.equalsIgnoreCase("sorcery")) {
cards = Lists.newArrayList(StaticData.instance().getCommonCards().getUniqueCards());
final Predicate<PaperCard> cpp = Predicates.compose(CardRulesPredicates.IS_SORCERY, PaperCard::getRules);
final Predicate<PaperCard> cpp = PaperCardPredicates.fromRules(CardRulesPredicates.IS_SORCERY);
cards = Lists.newArrayList(Iterables.filter(cards, cpp));
} else if (valid.equalsIgnoreCase("instant")) {
cards = Lists.newArrayList(StaticData.instance().getCommonCards().getUniqueCards());
final Predicate<PaperCard> cpp = Predicates.compose(CardRulesPredicates.IS_INSTANT, PaperCard::getRules);
final Predicate<PaperCard> cpp = PaperCardPredicates.fromRules(CardRulesPredicates.IS_INSTANT);
cards = Lists.newArrayList(Iterables.filter(cards, cpp));
}
if (sa.hasParam("RandomCopied")) {

3
forge-game/src/main/java/forge/game/ability/effects/PlayLandVariantEffect.java
View File

@@ -16,6 +16,7 @@ import forge.game.card.CardFactory;
import forge.game.player.Player;
import forge.game.spellability.SpellAbility;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.util.Aggregates;
import forge.util.Iterables;
import forge.util.Predicates;
@@ -30,7 +31,7 @@ public class PlayLandVariantEffect extends SpellAbilityEffect {
final String landType = sa.getParam("Clone");
List<PaperCard> cards = Lists.newArrayList(StaticData.instance().getCommonCards().getUniqueCards());
if ("BasicLand".equals(landType)) {
final Predicate<PaperCard> cpp = Predicates.compose(CardRulesPredicates.IS_BASIC_LAND, PaperCard::getRules);
final Predicate<PaperCard> cpp = PaperCardPredicates.fromRules(CardRulesPredicates.IS_BASIC_LAND);
cards = Lists.newArrayList(Iterables.filter(cards, cpp));
}
// current color of source card

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

@@ -3,8 +3,10 @@ package forge.game.ability.effects;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Predicate;
import forge.StaticData;
import forge.card.CardRules;
import forge.card.CardRulesPredicates;
import forge.game.Game;
import forge.game.ability.AbilityKey;
@@ -21,6 +23,7 @@ import forge.game.trigger.TriggerType;
import forge.game.trigger.WrappedAbility;
import forge.game.zone.ZoneType;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.util.Localizer;
import forge.util.PredicateString.StringOp;
import forge.util.Predicates;
@@ -44,15 +47,14 @@ public class VentureEffect extends SpellAbilityEffect {
List<PaperCard> dungeonCards = null;
if (sa.hasParam("Dungeon")) {
dungeonCards = StaticData.instance().getVariantCards()
.getAllCards(Predicates.compose(
CardRulesPredicates.IS_DUNGEON
.and(CardRulesPredicates.subType(StringOp.EQUALS, sa.getParam("Dungeon"))),
PaperCard::getRules));
String dungeonType = sa.getParam("Dungeon");
Predicate<CardRules> rulesPredicate = CardRulesPredicates.IS_DUNGEON.and(CardRulesPredicates.subType(StringOp.EQUALS, dungeonType));
dungeonCards = StaticData.instance().getVariantCards().getAllCards(
PaperCardPredicates.fromRules(rulesPredicate));
} else {
// Create a new dungeon card chosen by player in command zone.
dungeonCards = StaticData.instance().getVariantCards().getAllCards(
Predicates.compose(CardRulesPredicates.IS_DUNGEON, PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_DUNGEON));
dungeonCards.removeIf(c -> !c.getRules().isEnterableDungeon());
}
String message = Localizer.getInstance().getMessage("lblChooseDungeon");

3
forge-gui-desktop/src/main/java/forge/itemmanager/filters/CardCMCFilter.java
View File

@@ -8,6 +8,7 @@ import javax.swing.JPanel;
import forge.card.CardRules;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.ItemManager;
import forge.itemmanager.SItemManagerUtil.StatTypes;
import forge.itemmanager.SpellShopManager;
@@ -55,6 +56,6 @@ public class CardCMCFilter extends StatTypeFilter<PaperCard> {
//use custom return true delegate to validate the item is a card
return card -> true;
}
return Predicates.compose(Predicates.or(cmcs), PaperCard::getRules);
return PaperCardPredicates.fromRules(Predicates.or(cmcs));
}
}

3
forge-gui-desktop/src/main/java/forge/itemmanager/filters/CardCMCRangeFilter.java
View File

@@ -3,6 +3,7 @@ package forge.itemmanager.filters;
import forge.card.CardRules;
import forge.card.CardRulesPredicates;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.ItemManager;
import forge.util.Predicates;
@@ -33,6 +34,6 @@ public class CardCMCRangeFilter extends ValueRangeFilter<PaperCard> {
if (predicate == null) {
return x -> true;
}
return Predicates.compose(predicate, PaperCard::getRules);
return PaperCardPredicates.fromRules(predicate);
}
}

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

@@ -3,6 +3,7 @@ package forge.itemmanager.filters;
import forge.card.CardRules;
import forge.card.CardRulesPredicates;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.ItemManager;
import forge.util.Predicates;
@@ -34,6 +35,6 @@ public class CardPowerFilter extends ValueRangeFilter<PaperCard> {
return x -> true;
}
predicate = predicate.and(CardRulesPredicates.IS_CREATURE);
return Predicates.compose(predicate, PaperCard::getRules);
return PaperCardPredicates.fromRules(predicate);
}
}

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

@@ -3,6 +3,7 @@ package forge.itemmanager.filters;
import forge.card.CardRules;
import forge.card.CardRulesPredicates;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.ItemManager;
import forge.util.Predicates;
@@ -34,6 +35,6 @@ public class CardToughnessFilter extends ValueRangeFilter<PaperCard> {
return x -> true;
}
predicate = predicate.and(CardRulesPredicates.IS_CREATURE);
return Predicates.compose(predicate, PaperCard::getRules);
return PaperCardPredicates.fromRules(predicate);
}
}

3
forge-gui-desktop/src/main/java/forge/itemmanager/filters/CardTypeFilter.java
View File

@@ -8,6 +8,7 @@ import javax.swing.JPanel;
import forge.card.CardRules;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.ItemManager;
import forge.itemmanager.SItemManagerUtil.StatTypes;
import forge.itemmanager.SpellShopManager;
@@ -53,6 +54,6 @@ public class CardTypeFilter extends StatTypeFilter<PaperCard> {
//use custom return true delegate to validate the item is a card
return card -> true;
}
return Predicates.compose(Predicates.or(types), PaperCard::getRules);
return PaperCardPredicates.fromRules(Predicates.or(types));
}
}

3
forge-gui-desktop/src/main/java/forge/itemmanager/filters/StatTypeFilter.java
View File

@@ -10,6 +10,7 @@ import forge.gui.UiCommand;
import forge.item.InventoryItem;
import forge.item.ItemPredicate;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.ItemManager;
import forge.itemmanager.SFilterUtil;
import forge.itemmanager.SItemManagerUtil.StatTypes;
@@ -76,7 +77,7 @@ public abstract class StatTypeFilter<T extends InventoryItem> extends ToggleButt
for (StatTypes statTypes : buttonMap.keySet()) {
if (statTypes.predicate != null) {
int count = items.countAll(Predicates.compose(statTypes.predicate, PaperCard::getRules), PaperCard.class);
int count = items.countAll(PaperCardPredicates.fromRules(statTypes.predicate), PaperCard.class);
buttonMap.get(statTypes).setText(String.valueOf(count));
}
}

3
forge-gui-desktop/src/main/java/forge/screens/deckeditor/controllers/CDeckgen.java
View File

@@ -16,6 +16,7 @@ import forge.gui.UiCommand;
import forge.gui.framework.ICDoc;
import forge.item.InventoryItem;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.localinstance.properties.ForgePreferences.FPref;
import forge.model.FModel;
import forge.screens.deckeditor.CDeckEditorUI;
@@ -70,7 +71,7 @@ public enum CDeckgen implements ICDoc {
final Deck randomDeck = new Deck();
final Predicate<PaperCard> notBasicLand = Predicates.compose(CardRulesPredicates.NOT_BASIC_LAND, PaperCard::getRules);
final Predicate<PaperCard> notBasicLand = PaperCardPredicates.fromRules(CardRulesPredicates.NOT_BASIC_LAND);
final Iterable<PaperCard> source = Iterables.filter(FModel.getMagicDb().getCommonCards().getUniqueCards(), notBasicLand);
randomDeck.getMain().addAllFlat(Aggregates.random(source, 15 * 5));

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

@@ -28,6 +28,7 @@ import forge.gui.UiCommand;
import forge.gui.framework.DragCell;
import forge.gui.framework.FScreen;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.CardManager;
import forge.itemmanager.ItemManagerConfig;
import forge.model.CardCollections;
@@ -83,14 +84,14 @@ public final class CEditorCommander extends CDeckEditor<Deck> {
if (gameType == GameType.Brawl){
GameFormat format = FModel.getFormats().get("Brawl");
Predicate<CardRules> commanderFilter = CardRulesPredicates.CAN_BE_BRAWL_COMMANDER;
commanderPool = ItemPool.createFrom(commonCards.getAllCardsNoAlt(format.getFilterPrinted().and(Predicates.compose(commanderFilter, PaperCard::getRules))), PaperCard.class);
commanderPool = ItemPool.createFrom(commonCards.getAllCardsNoAlt(format.getFilterPrinted().and(PaperCardPredicates.fromRules(commanderFilter))), PaperCard.class);
normalPool = ItemPool.createFrom(format.getAllCards(), PaperCard.class);
}
else {
Predicate<CardRules> commanderFilter = gameType == GameType.Oathbreaker
? CardRulesPredicates.CAN_BE_OATHBREAKER.or(CardRulesPredicates.CAN_BE_SIGNATURE_SPELL)
: CardRulesPredicates.CAN_BE_COMMANDER;
commanderPool = ItemPool.createFrom(commonCards.getAllCardsNoAlt(Predicates.compose(commanderFilter, PaperCard::getRules)),PaperCard.class);
commanderPool = ItemPool.createFrom(commonCards.getAllCardsNoAlt(PaperCardPredicates.fromRules(commanderFilter)),PaperCard.class);
normalPool = ItemPool.createFrom(commonCards.getAllCardsNoAlt(), PaperCard.class);
}

3
forge-gui-desktop/src/main/java/forge/screens/deckeditor/controllers/CEditorQuest.java
View File

@@ -44,6 +44,7 @@ import forge.gui.framework.DragCell;
import forge.gui.framework.FScreen;
import forge.item.InventoryItem;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.CardManager;
import forge.itemmanager.ColumnDef;
import forge.itemmanager.ItemManagerConfig;
@@ -346,7 +347,7 @@ public final class CEditorQuest extends CDeckEditor<Deck> {
}
private ItemPool<PaperCard> getCommanderCardPool(){
Predicate<PaperCard> commanderPredicate = Predicates.compose(CardRulesPredicates.CAN_BE_COMMANDER, PaperCard::getRules);
Predicate<PaperCard> commanderPredicate = PaperCardPredicates.fromRules(CardRulesPredicates.CAN_BE_COMMANDER);
return getRemainingCardPool().getFilteredPool(commanderPredicate);
}

3
forge-gui-desktop/src/main/java/forge/screens/deckeditor/controllers/CStatistics.java
View File

@@ -12,6 +12,7 @@ import forge.deck.DeckBase;
import forge.gui.framework.ICDoc;
import forge.item.InventoryItem;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.SItemManagerUtil.StatTypes;
import forge.screens.deckeditor.CDeckEditorUI;
import forge.screens.deckeditor.views.VStatistics;
@@ -51,7 +52,7 @@ public enum CStatistics implements ICDoc {
}
private void setLabelValue(final JLabel label, final ItemPool<PaperCard> deck, final Predicate<CardRules> predicate, final int total) {
final int tmp = deck.countAll(Predicates.compose(predicate, PaperCard::getRules));
final int tmp = deck.countAll(PaperCardPredicates.fromRules(predicate));
label.setText(tmp + " (" + calculatePercentage(tmp, total) + "%)");
}

3
forge-gui-desktop/src/main/java/forge/screens/deckeditor/controllers/CStatisticsImporter.java
View File

@@ -7,6 +7,7 @@ import forge.deck.CardPool;
import forge.deck.DeckRecognizer;
import forge.deck.DeckSection;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.SItemManagerUtil;
import forge.screens.deckeditor.views.VStatisticsImporter;
import forge.util.ItemPool;
@@ -100,7 +101,7 @@ public class CStatisticsImporter {
}
private void setLabelValue(final JLabel label, final ItemPool<PaperCard> deck, final Predicate<CardRules> predicate, final int total) {
final int tmp = deck.countAll(Predicates.compose(predicate, PaperCard::getRules));
final int tmp = deck.countAll(PaperCardPredicates.fromRules(predicate));
label.setText(tmp + " (" + calculatePercentage(tmp, total) + "%)");
}

9
forge-gui-desktop/src/test/java/forge/planarconquestgenerate/PlanarConquestCommanderGeneraterGA.java
View File

@@ -20,6 +20,7 @@ import forge.game.GameType;
import forge.gamemodes.limited.CardRanker;
import forge.gui.GuiBase;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.localinstance.properties.ForgeConstants;
import forge.localinstance.properties.ForgePreferences;
import forge.model.FModel;
@@ -76,10 +77,10 @@ public class PlanarConquestCommanderGeneraterGA extends PlanarConquestGeneraterG
}
Iterable<PaperCard> filtered= Iterables.filter(cards,
Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules)
.and(Predicates.compose(CardRulesPredicates.IS_PLANESWALKER, PaperCard::getRules))
//.and(Predicates.compose(CardRulesPredicates.IS_LEGENDARY, PaperCard::getRules))
.and(gameFormat.getFilterPrinted())
PaperCardPredicates.fromRules(CardRulesPredicates.IS_KEPT_IN_AI_DECKS
.and(CardRulesPredicates.IS_PLANESWALKER)
//.and(CardRulesPredicates.IS_LEGENDARY)
).and(gameFormat.getFilterPrinted())
);
List<PaperCard> filteredList = Lists.newArrayList(filtered);

7
forge-gui-desktop/src/test/java/forge/planarconquestgenerate/PlanarConquestGeneraterGA.java
View File

@@ -5,6 +5,7 @@ import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import forge.item.PaperCardPredicates;
import forge.util.*;
import org.apache.commons.lang3.tuple.Pair;
@@ -106,9 +107,9 @@ public class PlanarConquestGeneraterGA extends AbstractGeneticAlgorithm<Deck> {
}
Iterable<PaperCard> filtered= Iterables.filter(cards,
Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules)
.and(Predicates.compose(CardRulesPredicates.IS_NON_LAND, PaperCard::getRules))
.and(gameFormat.getFilterPrinted())
PaperCardPredicates.fromRules(CardRulesPredicates.IS_KEPT_IN_AI_DECKS
.and(CardRulesPredicates.IS_NON_LAND)
).and(gameFormat.getFilterPrinted())
);
List<PaperCard> filteredList = Lists.newArrayList(filtered);

9
forge-gui-desktop/src/test/java/forge/planarconquestgenerate/PlanarConquestTribalGeneraterGA.java
View File

@@ -19,6 +19,7 @@ import forge.game.GameType;
import forge.gamemodes.limited.CardRanker;
import forge.gui.GuiBase;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.localinstance.properties.ForgeConstants;
import forge.localinstance.properties.ForgePreferences;
import forge.model.FModel;
@@ -78,10 +79,10 @@ public class PlanarConquestTribalGeneraterGA extends PlanarConquestGeneraterGA {
}
Iterable<PaperCard> filteredTribe= Iterables.filter(cards,
Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules)
.and(Predicates.compose(CardRulesPredicates.hasCreatureType("Pirate"), PaperCard::getRules))
.and(Predicates.compose(CardRulesPredicates.IS_CREATURE, PaperCard::getRules))
.and(gameFormat.getFilterPrinted())
PaperCardPredicates.fromRules(CardRulesPredicates.IS_KEPT_IN_AI_DECKS
.and(CardRulesPredicates.hasCreatureType("Pirate"))
.and(CardRulesPredicates.IS_CREATURE)
).and(gameFormat.getFilterPrinted())
);
List<PaperCard> filteredListTribe = Lists.newArrayList(filteredTribe);

3
forge-gui-mobile/src/forge/adventure/character/EnemySprite.java
View File

@@ -30,6 +30,7 @@ import forge.card.CardRulesPredicates;
import forge.deck.CardPool;
import forge.deck.Deck;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.util.Aggregates;
import forge.util.MyRandom;
import forge.util.Predicates;
@@ -481,7 +482,7 @@ public class EnemySprite extends CharacterSprite implements Steerable<Vector2> {
if(data.rewards != null) { //Collect standard rewards.
Deck enemyDeck = Current.latestDeck();
// By popular demand, remove basic lands from the reward pool.
CardPool deckNoBasicLands = enemyDeck.getMain().getFilteredPool(Predicates.compose(CardRulesPredicates.NOT_BASIC_LAND, PaperCard::getRules));
CardPool deckNoBasicLands = enemyDeck.getMain().getFilteredPool(PaperCardPredicates.fromRules(CardRulesPredicates.NOT_BASIC_LAND));
for (RewardData rdata : data.rewards) {
ret.addAll(rdata.generate(false, enemyDeck == null ? null : deckNoBasicLands.toFlatList(),true ));

3
forge-gui-mobile/src/forge/itemmanager/filters/CardCMCFilter.java
View File

@@ -3,6 +3,7 @@ package forge.itemmanager.filters;
import forge.card.CardRules;
import forge.card.CardRulesPredicates;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.ItemManager;
import forge.util.Predicates;
@@ -30,6 +31,6 @@ public class CardCMCFilter extends ValueRangeFilter<PaperCard> {
if (predicate == null) {
return x -> true;
}
return Predicates.compose(predicate, PaperCard::getRules);
return PaperCardPredicates.fromRules(predicate);
}
}

3
forge-gui-mobile/src/forge/itemmanager/filters/CardColorlessCostFilter.java
View File

@@ -3,6 +3,7 @@ package forge.itemmanager.filters;
import forge.card.CardRules;
import forge.card.CardRulesPredicates;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.ItemManager;
import forge.util.Predicates;
@@ -30,6 +31,6 @@ public class CardColorlessCostFilter extends ValueRangeFilter<PaperCard> {
if (predicate == null) {
return x -> true;
}
return Predicates.compose(predicate, PaperCard::getRules);
return PaperCardPredicates.fromRules(predicate);
}
}

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

@@ -3,6 +3,7 @@ package forge.itemmanager.filters;
import forge.card.CardRules;
import forge.card.CardRulesPredicates;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.ItemManager;
import forge.util.Predicates;
@@ -31,6 +32,6 @@ public class CardPowerFilter extends ValueRangeFilter<PaperCard> {
return x -> true;
}
predicate = predicate.and(CardRulesPredicates.IS_CREATURE);
return Predicates.compose(predicate, PaperCard::getRules);
return PaperCardPredicates.fromRules(predicate);
}
}

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

@@ -3,6 +3,7 @@ package forge.itemmanager.filters;
import forge.card.CardRules;
import forge.card.CardRulesPredicates;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.ItemManager;
import forge.util.Predicates;
@@ -31,6 +32,6 @@ public class CardToughnessFilter extends ValueRangeFilter<PaperCard> {
return x -> true;
}
predicate = predicate.and(CardRulesPredicates.IS_CREATURE);
return Predicates.compose(predicate, PaperCard::getRules);
return PaperCardPredicates.fromRules(predicate);
}
}

3
forge-gui-mobile/src/forge/itemmanager/filters/CardTypeFilter.java
View File

@@ -6,6 +6,7 @@ import java.util.function.Predicate;
import forge.card.CardRules;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.ItemManager;
import forge.itemmanager.SItemManagerUtil.StatTypes;
import forge.util.Predicates;
@@ -50,6 +51,6 @@ public class CardTypeFilter extends StatTypeFilter<PaperCard> {
//use custom return true delegate to validate the item is a card
return card -> true;
}
return Predicates.compose(Predicates.or(types), PaperCard::getRules);
return PaperCardPredicates.fromRules(Predicates.or(types));
}
}

13
forge-gui/src/main/java/forge/deck/CardRelationMatrixGenerator.java
View File

@@ -10,6 +10,7 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import forge.item.PaperCardPredicates;
import forge.util.Iterables;
import forge.util.Predicates;
import org.apache.commons.lang3.ArrayUtils;
@@ -73,8 +74,8 @@ public final class CardRelationMatrixGenerator {
ForgeConstants.DECK_GEN_DIR, false),
true);
final Iterable<PaperCard> cards = Iterables.filter(format.getAllCards()
, Predicates.compose(CardRulesPredicates.NOT_TRUE_BASIC_LAND, PaperCard::getRules));
final Iterable<PaperCard> cards = Iterables.filter(format.getAllCards(),
PaperCardPredicates.fromRules(CardRulesPredicates.NOT_TRUE_BASIC_LAND));
List<PaperCard> cardList = Lists.newArrayList(cards);
cardList.add(FModel.getMagicDb().getCommonCards().getCard("Wastes"));
Map<String, Integer> cardIntegerMap = new HashMap<>();
@@ -90,7 +91,7 @@ public final class CardRelationMatrixGenerator {
for (Deck deck:decks){
if (deck.getMain().contains(card)){
for (PaperCard pairCard:Iterables.filter(deck.getMain().toFlatList(),
Predicates.compose(CardRulesPredicates.NOT_TRUE_BASIC_LAND, PaperCard::getRules))){
PaperCardPredicates.fromRules(CardRulesPredicates.NOT_TRUE_BASIC_LAND))){
if (!pairCard.getName().equals(card.getName())){
try {
int old = matrix[cardIntegerMap.get(card.getName())][cardIntegerMap.get(pairCard.getName())];
@@ -142,8 +143,8 @@ public final class CardRelationMatrixGenerator {
true);
//get all cards
final Iterable<PaperCard> cards = Iterables.filter(FModel.getMagicDb().getCommonCards().getUniqueCards()
, Predicates.compose(CardRulesPredicates.NOT_TRUE_BASIC_LAND, PaperCard::getRules));
final Iterable<PaperCard> cards = Iterables.filter(FModel.getMagicDb().getCommonCards().getUniqueCards(),
PaperCardPredicates.fromRules(CardRulesPredicates.NOT_TRUE_BASIC_LAND));
List<PaperCard> cardList = Lists.newArrayList(cards);
cardList.add(FModel.getMagicDb().getCommonCards().getCard("Wastes"));
Map<String, Integer> cardIntegerMap = new HashMap<>();
@@ -200,7 +201,7 @@ public final class CardRelationMatrixGenerator {
public static void updateLegendMatrix(Deck deck, PaperCard legend, Map<String, Integer> cardIntegerMap,
Map<String, Integer> legendIntegerMap, int[][] matrix){
for (PaperCard pairCard:Iterables.filter(deck.getMain().toFlatList(),
Predicates.compose(CardRulesPredicates.NOT_TRUE_BASIC_LAND, PaperCard::getRules))){
PaperCardPredicates.fromRules(CardRulesPredicates.NOT_TRUE_BASIC_LAND))){
if (!pairCard.getName().equals(legend.getName())){
try {
int old = matrix[legendIntegerMap.get(legend.getName())][cardIntegerMap.get(pairCard.getName())];

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

@@ -10,6 +10,7 @@ import forge.card.CardRules;
import forge.card.CardRulesPredicates;
import forge.deck.generation.DeckGeneratorBase;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.model.FModel;
import forge.util.ItemPool;
import forge.util.Iterables;
@@ -41,7 +42,7 @@ 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(), format.isLegalCommanderPredicate()
.and(Predicates.compose(canPlay, PaperCard::getRules)));
.and(PaperCardPredicates.fromRules(canPlay)));
final List<DeckProxy> decks = new ArrayList<>();
for (PaperCard legend: legends) {
decks.add(new CommanderDeckGenerator(legend, format, isForAi, isCardGen));
@@ -65,7 +66,7 @@ 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(), format.isLegalCardPredicate()
.and(Predicates.compose(CardRulesPredicates.CAN_BE_BRAWL_COMMANDER.and(canPlay), PaperCard::getRules)));
.and(PaperCardPredicates.fromRules(CardRulesPredicates.CAN_BE_BRAWL_COMMANDER.and(canPlay))));
final List<DeckProxy> decks = new ArrayList<>();
for (PaperCard legend: legends) {
decks.add(new CommanderDeckGenerator(legend, format, isForAi, isCardGen));

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

@@ -215,8 +215,8 @@ public class DeckgenUtil {
System.out.println("Wrong card count "+deck.getMain().countAll());
deck=buildLDACArchetypeDeck(format,isForAI);
}
if(deck.getMain().countAll(Predicates.compose(CardRulesPredicates.IS_LAND, PaperCard::getRules))>27){
System.out.println("Too many lands "+deck.getMain().countAll(Predicates.compose(CardRulesPredicates.IS_LAND, PaperCard::getRules)));
if(deck.getMain().countAll(PaperCardPredicates.fromRules(CardRulesPredicates.IS_LAND))>27){
System.out.println("Too many lands "+deck.getMain().countAll(PaperCardPredicates.fromRules(CardRulesPredicates.IS_LAND)));
deck=buildLDACArchetypeDeck(format,isForAI);
}
while(deck.get(DeckSection.Sideboard).countAll()>15){
@@ -314,8 +314,8 @@ public class DeckgenUtil {
System.out.println("Wrong card count "+deck.getMain().countAll());
deck=buildLDACArchetypeDeck(format,isForAI);
}
if(deck.getMain().countAll(Predicates.compose(CardRulesPredicates.IS_LAND, PaperCard::getRules))>27){
System.out.println("Too many lands "+deck.getMain().countAll(Predicates.compose(CardRulesPredicates.IS_LAND, PaperCard::getRules)));
if(deck.getMain().countAll(PaperCardPredicates.fromRules(CardRulesPredicates.IS_LAND))>27){
System.out.println("Too many lands "+deck.getMain().countAll(PaperCardPredicates.fromRules(CardRulesPredicates.IS_LAND)));
deck=buildLDACArchetypeDeck(format,isForAI);
}
while(deck.get(DeckSection.Sideboard).countAll()>15){
@@ -667,7 +667,7 @@ public class DeckgenUtil {
final DeckFormat format = gameType.getDeckFormat();
Predicate<CardRules> canPlay = forAi ? DeckGeneratorBase.AI_CAN_PLAY : CardRulesPredicates.IS_KEPT_IN_RANDOM_DECKS;
Predicate<PaperCard> legal = format.isLegalCardPredicate().and(format.isLegalCommanderPredicate());
Iterable<PaperCard> legends = cardDb.getAllCards(legal.and(Predicates.compose(canPlay, PaperCard::getRules)));
Iterable<PaperCard> legends = cardDb.getAllCards(legal.and(PaperCardPredicates.fromRules(canPlay)));
commander = Aggregates.random(legends);
return generateRandomCommanderDeck(commander, format, forAi, false);
@@ -761,10 +761,9 @@ public class DeckgenUtil {
cardDb = FModel.getMagicDb().getCommonCards();
//shuffle first 400 random cards
Iterable<PaperCard> colorList = Iterables.filter(format.getCardPool(cardDb).getAllCards(),
format.isLegalCardPredicate().and(Predicates.compose(
format.isLegalCardPredicate().and(PaperCardPredicates.fromRules(
new CardThemedDeckBuilder.MatchColorIdentity(commander.getRules().getColorIdentity())
.or(DeckGeneratorBase.COLORLESS_CARDS),
PaperCard::getRules)));
.or(DeckGeneratorBase.COLORLESS_CARDS))));
switch (format) {
case Brawl: //for Brawl - add additional filterprinted rule to remove old reprints for a consistent look
colorList = Iterables.filter(colorList,FModel.getFormats().getStandard().getFilterPrinted());
@@ -842,7 +841,7 @@ public class DeckgenUtil {
// determine how many additional lands we need, but don't take lands already in deck into consideration,
// or we risk incorrectly determining the target deck size
int numLands = Iterables.size(Iterables.filter(cards, Predicates.compose(CardRulesPredicates.IS_LAND, PaperCard::getRules)));
int numLands = Iterables.size(Iterables.filter(cards, PaperCardPredicates.fromRules(CardRulesPredicates.IS_LAND)));
int sizeNoLands = cards.size() - numLands;
// attempt to determine if building for sealed, constructed or EDH

3
forge-gui/src/main/java/forge/gamemodes/limited/CardThemedCommanderDeckBuilder.java
View File

@@ -9,6 +9,7 @@ import forge.card.ColorSet;
import forge.deck.DeckFormat;
import forge.deck.generation.DeckGenPool;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.model.FModel;
import forge.util.Iterables;
import forge.util.Predicates;
@@ -26,7 +27,7 @@ public class CardThemedCommanderDeckBuilder extends CardThemedDeckBuilder {
// remove Unplayables
if(isForAI) {
final Iterable<PaperCard> playables = Iterables.filter(availableList,
Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_KEPT_IN_AI_DECKS));
this.aiPlayables = Lists.newArrayList(playables);
}else{
this.aiPlayables = Lists.newArrayList(availableList);

3
forge-gui/src/main/java/forge/gamemodes/limited/CardThemedConquestDeckBuilder.java
View File

@@ -10,6 +10,7 @@ import forge.deck.DeckFormat;
import forge.deck.generation.DeckGenPool;
import forge.game.GameFormat;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.model.FModel;
import forge.util.Iterables;
import forge.util.Predicates;
@@ -30,7 +31,7 @@ public class CardThemedConquestDeckBuilder extends CardThemedDeckBuilder {
// remove Unplayables
if(isForAI) {
final Iterable<PaperCard> playables = Iterables.filter(availableList,
Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_KEPT_IN_AI_DECKS));
this.aiPlayables = Lists.newArrayList(playables);
}else{
this.aiPlayables = Lists.newArrayList(availableList);

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

@@ -106,7 +106,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
// remove Unplayables
if(isForAI) {
final Iterable<PaperCard> playables = Iterables.filter(availableList,
Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_DECKS, PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_KEPT_IN_AI_DECKS));
this.aiPlayables = Lists.newArrayList(playables);
}else{
this.aiPlayables = Lists.newArrayList(availableList);
@@ -190,11 +190,11 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
System.out.println("Colors: " + colors.toEnumSet().toString());
}
Iterable<PaperCard> colorList = Iterables.filter(aiPlayables,
Predicates.compose(hasColor, PaperCard::getRules));
PaperCardPredicates.fromRules(hasColor));
rankedColorList = Lists.newArrayList(colorList);
onColorCreaturesAndSpells = Iterables.filter(rankedColorList,
Predicates.compose(CardRulesPredicates.IS_CREATURE
.or(CardRulesPredicates.IS_NON_CREATURE_SPELL), PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_CREATURE
.or(CardRulesPredicates.IS_NON_CREATURE_SPELL)));
// Guava iterables do not copy the collection contents, instead they act
// as filters and iterate over _source_ collection each time. So even if
@@ -320,8 +320,7 @@ 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.compose(hasColor, PaperCard::getRules)
.and(Predicates.compose(CardRulesPredicates.IS_NON_LAND, PaperCard::getRules)));
PaperCardPredicates.fromRules(hasColor.and(CardRulesPredicates.IS_NON_LAND)));
int i=0;
while(i<15 && potentialSideboard.iterator().hasNext()){
PaperCard sbCard = potentialSideboard.iterator().next();
@@ -463,7 +462,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
protected void addThirdColorCards(int num) {
if (num > 0) {
final Iterable<PaperCard> others = Iterables.filter(aiPlayables,
Predicates.compose(CardRulesPredicates.IS_NON_LAND, PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_NON_LAND));
// We haven't yet ranked the off-color cards.
// Compare them to the cards already in the deckList.
//List<PaperCard> rankedOthers = CardRanker.rankCardsInPack(others, deckList, colors, true);
@@ -480,7 +479,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
hasColor = CardRulesPredicates.IS_NON_LAND.and(new MatchColorIdentity(colors)
.or(DeckGeneratorBase.COLORLESS_CARDS));
final Iterable<PaperCard> threeColorList = Iterables.filter(aiPlayables,
Predicates.compose(hasColor, PaperCard::getRules));
PaperCardPredicates.fromRules(hasColor));
for (final PaperCard card : threeColorList) {
if (num > 0) {
toAdd.add(card);
@@ -500,7 +499,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
protected void addLowCMCCard(){
final Iterable<PaperCard> nonLands = Iterables.filter(rankedColorList,
Predicates.compose(CardRulesPredicates.IS_NON_LAND, PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_NON_LAND));
final PaperCard card = Iterables.getFirst(nonLands, null);
if (card != null) {
deckList.add(card);
@@ -523,9 +522,9 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
Predicate<PaperCard> isSetBasicLand;
if (edition !=null){
isSetBasicLand = PaperCardPredicates.printedInSet(edition)
.and(Predicates.compose(CardRulesPredicates.IS_BASIC_LAND, PaperCard::getRules));
}else{
isSetBasicLand = Predicates.compose(CardRulesPredicates.IS_BASIC_LAND, PaperCard::getRules);
.and(PaperCardPredicates.fromRules(CardRulesPredicates.IS_BASIC_LAND));
} else {
isSetBasicLand = PaperCardPredicates.fromRules(CardRulesPredicates.IS_BASIC_LAND);
}
landPool = new DeckGenPool(format.getCardPool(fullCardDB).getAllCards(isSetBasicLand));
@@ -668,7 +667,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
*/
private void addLands(final int[] clrCnts) {
// basic lands that are available in the deck
final Iterable<PaperCard> basicLands = Iterables.filter(aiPlayables, Predicates.compose(CardRulesPredicates.IS_BASIC_LAND, PaperCard::getRules));
final Iterable<PaperCard> basicLands = Iterables.filter(aiPlayables, PaperCardPredicates.fromRules(CardRulesPredicates.IS_BASIC_LAND));
// total of all ClrCnts
int totalColor = 0;
@@ -810,7 +809,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
*/
private void addNonBasicLands() {
Iterable<PaperCard> lands = Iterables.filter(aiPlayables,
Predicates.compose(CardRulesPredicates.IS_NONBASIC_LAND, PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_NONBASIC_LAND));
List<PaperCard> landsToAdd = new ArrayList<>();
int minBasics;//Keep a minimum number of basics to ensure playable decks
if(colors.isColorless()) {
@@ -824,7 +823,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
}
lands = Iterables.filter(aiPlayables,
Predicates.compose(CardRulesPredicates.IS_NONBASIC_LAND, PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_NONBASIC_LAND));
for (final PaperCard card : lands) {
if (landsNeeded > minBasics) {
@@ -924,8 +923,7 @@ public class CardThemedDeckBuilder extends DeckGeneratorBase {
for (int i = 1; i < 7; i++) {
creatureCosts.put(i, 0);
}
final Predicate<PaperCard> filter = Predicates.compose(CardRulesPredicates.IS_CREATURE,
PaperCard::getRules);
final Predicate<PaperCard> filter = PaperCardPredicates.fromRules(CardRulesPredicates.IS_CREATURE);
for (final IPaperCard creature : Iterables.filter(deckList, filter)) {
int cmc = creature.getRules().getManaCost().getCMC();
if (cmc < 1) {

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

@@ -26,6 +26,7 @@ import forge.deck.DeckSection;
import forge.deck.generation.DeckGeneratorBase;
import forge.item.IPaperCard;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.model.FModel;
import forge.util.Iterables;
import forge.util.MyRandom;
@@ -83,13 +84,13 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
// remove Unplayables
final Iterable<PaperCard> playables = Iterables.filter(availableList,
Predicates.compose(CardRulesPredicates.IS_KEPT_IN_AI_LIMITED_DECKS, PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_KEPT_IN_AI_LIMITED_DECKS));
this.aiPlayables = Lists.newArrayList(playables);
this.availableList.removeAll(aiPlayables);
// keep Conspiracies in a separate list
final Iterable<PaperCard> conspiracies = Iterables.filter(aiPlayables,
Predicates.compose(CardRulesPredicates.coreType(true, "Conspiracy"), PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.coreType(true, "Conspiracy")));
this.draftedConspiracies = Lists.newArrayList(conspiracies);
this.aiPlayables.removeAll(draftedConspiracies);
@@ -136,19 +137,19 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
// 1. Prepare
hasColor = new MatchColorIdentity(colors).or(COLORLESS_CARDS);
Iterable<PaperCard> colorList = Iterables.filter(aiPlayables,
Predicates.compose(hasColor, PaperCard::getRules));
PaperCardPredicates.fromRules(hasColor));
rankedColorList = CardRanker.rankCardsInDeck(colorList);
onColorCreatures = Iterables.filter(rankedColorList,
Predicates.compose(CardRulesPredicates.IS_CREATURE, PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_CREATURE));
onColorNonCreatures = Iterables.filter(rankedColorList,
Predicates.compose(CardRulesPredicates.IS_NON_CREATURE_SPELL, PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_NON_CREATURE_SPELL));
// Guava iterables do not copy the collection contents, instead they act
// as filters and iterate over _source_ collection each time. So even if
// aiPlayable has changed, there is no need to create a new iterable.
// 2. Add any planeswalkers
final Iterable<PaperCard> onColorWalkers = Iterables.filter(colorList,
Predicates.compose(CardRulesPredicates.IS_PLANESWALKER, PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_PLANESWALKER));
final List<PaperCard> walkers = Lists.newArrayList(onColorWalkers);
deckList.addAll(walkers);
aiPlayables.removeAll(walkers);
@@ -171,7 +172,7 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
// an extra.
if (deckList.size() == numSpellsNeeded && getAverageCMC(deckList) < 4) {
final Iterable<PaperCard> nonLands = Iterables.filter(rankedColorList,
Predicates.compose(CardRulesPredicates.IS_NON_LAND, PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_NON_LAND));
final PaperCard card = Iterables.getFirst(nonLands, null);
if (card != null) {
deckList.add(card);
@@ -342,7 +343,8 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
*/
private void addLands(final int[] clrCnts, final String landSetCode) {
// basic lands that are available in the deck
final Iterable<PaperCard> basicLands = Iterables.filter(aiPlayables, Predicates.compose(CardRulesPredicates.IS_BASIC_LAND, PaperCard::getRules));
final Iterable<PaperCard> basicLands = Iterables.filter(aiPlayables,
PaperCardPredicates.fromRules(CardRulesPredicates.IS_BASIC_LAND));
final Set<PaperCard> snowLands = new HashSet<>();
// total of all ClrCnts
@@ -455,7 +457,7 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
*/
private void addNonBasicLands() {
final Iterable<PaperCard> lands = Iterables.filter(aiPlayables,
Predicates.compose(CardRulesPredicates.IS_NONBASIC_LAND, PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_NONBASIC_LAND));
List<PaperCard> landsToAdd = new ArrayList<>();
for (final PaperCard card : lands) {
if (landsNeeded > 0) {
@@ -483,7 +485,7 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
private void addThirdColorCards(int num) {
if (num > 0) {
final Iterable<PaperCard> others = Iterables.filter(aiPlayables,
Predicates.compose(CardRulesPredicates.IS_NON_LAND, PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_NON_LAND));
// We haven't yet ranked the off-color cards.
// Compare them to the cards already in the deckList.
List<PaperCard> rankedOthers = CardRanker.rankCardsInPack(others, deckList, colors, true);
@@ -499,7 +501,7 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
hasColor = new MatchColorIdentity(colors).or(DeckGeneratorBase.COLORLESS_CARDS);
final Iterable<PaperCard> threeColorList = Iterables.filter(rankedOthers,
Predicates.compose(hasColor, PaperCard::getRules));
PaperCardPredicates.fromRules(hasColor));
for (final PaperCard card : threeColorList) {
if (num > 0) {
toAdd.add(card);
@@ -526,7 +528,7 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
*/
private void addRandomCards(int num) {
final Iterable<PaperCard> others = Iterables.filter(aiPlayables,
Predicates.compose(CardRulesPredicates.IS_NON_LAND, PaperCard::getRules));
PaperCardPredicates.fromRules(CardRulesPredicates.IS_NON_LAND));
List <PaperCard> toAdd = new ArrayList<>();
for (final PaperCard card : others) {
if (num > 0) {
@@ -669,8 +671,7 @@ public class LimitedDeckBuilder extends DeckGeneratorBase {
for (int i = 1; i < 7; i++) {
creatureCosts.put(i, 0);
}
final Predicate<PaperCard> filter = Predicates.compose(CardRulesPredicates.IS_CREATURE,
PaperCard::getRules);
final Predicate<PaperCard> filter = PaperCardPredicates.fromRules(CardRulesPredicates.IS_CREATURE);
for (final IPaperCard creature : Iterables.filter(deckList, filter)) {
int cmc = creature.getRules().getManaCost().getCMC();
if (cmc < 1) {

3
forge-gui/src/main/java/forge/gamemodes/limited/LimitedPlayerAI.java
View File

@@ -7,6 +7,7 @@ import forge.deck.Deck;
import forge.deck.DeckSection;
import forge.deck.generation.DeckGeneratorBase;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.localinstance.properties.ForgePreferences;
import forge.util.Iterables;
import forge.util.MyRandom;
@@ -265,7 +266,7 @@ public class LimitedPlayerAI extends LimitedPlayer {
DeckGeneratorBase.MatchColorIdentity hasColor = new DeckGeneratorBase.MatchColorIdentity(colors);
Iterable<PaperCard> colorList = Iterables.filter(deckCards,
Predicates.compose(hasColor, PaperCard::getRules).negate());
PaperCardPredicates.fromRules(hasColor).negate());
PaperCard exchangeCard = null;

3
forge-gui/src/main/java/forge/gamemodes/planarconquest/ConquestRegion.java
View File

@@ -12,6 +12,7 @@ import forge.deck.generation.DeckGenPool;
import forge.game.card.Card;
import forge.gui.GuiBase;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.localinstance.skin.ISkinImage;
import forge.model.FModel;
import forge.util.Predicates;
@@ -130,7 +131,7 @@ public class ConquestRegion {
break;
case "colors":
colorSet = ColorSet.fromNames(value.toCharArray());
pred = Predicates.compose(CardRulesPredicates.hasColorIdentity(colorSet.getColor()), PaperCard::getRules);
pred = PaperCardPredicates.fromRules(CardRulesPredicates.hasColorIdentity(colorSet.getColor()));
break;
case "sets":
final String[] sets = value.split(",");

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

@@ -305,7 +305,7 @@ public final class BoosterUtils {
if (preferredColors.contains(MagicColor.COLORLESS) && preferredColors.size() == 1) {
Predicate<CardRules> predicateRules = CardRulesPredicates.cost(StringOp.CONTAINS_IC, "p/");
Predicate<PaperCard> predicateCard = Predicates.compose(predicateRules, PaperCard::getRules);
Predicate<PaperCard> predicateCard = PaperCardPredicates.fromRules(predicateRules);
int size = Iterables.size(Iterables.filter(cardPool, predicateCard));
int totalSize = cardPool.size();
@@ -324,7 +324,7 @@ public final class BoosterUtils {
//Try to get multicolored cards that fit into the preferred colors.
Predicate<CardRules> predicateRules = CardRulesPredicates.isColor(preferredColors.get(index))
.and(CardRulesPredicates.IS_MULTICOLOR);
Predicate<PaperCard> predicateCard = Predicates.compose(predicateRules, PaperCard::getRules);
Predicate<PaperCard> predicateCard = PaperCardPredicates.fromRules(predicateRules);
//Adjust for the number of multicolored possibilities. This prevents flooding of non-selected
//colors if multicolored cards aren't in the selected sets. The more multi-colored cards in the
@@ -401,7 +401,7 @@ public final class BoosterUtils {
//handful of multi-colored cards.
do {
if (color2 != null) {
Predicate<PaperCard> color2c = Predicates.compose(color2, PaperCard::getRules);
Predicate<PaperCard> color2c = PaperCardPredicates.fromRules(color2);
card = Aggregates.random(Iterables.filter(source, filter.and(color2c)));
}
} while (card == null && colorMisses++ < 10);
@@ -483,7 +483,7 @@ public final class BoosterUtils {
if (temp.length > 2) {
Predicate<CardRules> cr = parseRulesLimitation(temp[1]);
if (cr != null) {
preds.add(Predicates.compose(cr, PaperCard::getRules));
preds.add(PaperCardPredicates.fromRules(cr));
}
}

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

@@ -106,7 +106,7 @@ public abstract class QuestRewardCard implements IQuestRewardCard {
}
if (filterRules != null) {
final Predicate<PaperCard> rulesPrinted = Predicates.compose(filterRules, PaperCard::getRules);
final Predicate<PaperCard> rulesPrinted = PaperCardPredicates.fromRules(filterRules);
filters = filters.and(rulesPrinted);
}
if (filterRarity != null) {

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

@@ -19,6 +19,7 @@ import forge.gamemodes.quest.data.StarRating;
import forge.gui.interfaces.IButton;
import forge.item.InventoryItem;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.SItemManagerUtil.StatTypes;
import forge.localinstance.properties.ForgePreferences;
import forge.model.FModel;
@@ -50,7 +51,7 @@ public class SFilterUtil {
try {
Predicate<CardRules> filter = expression.evaluate();
if (filter != null) {
return Predicates.compose(invert ? filter.negate() : filter, PaperCard::getRules);
return PaperCardPredicates.fromRules(invert ? filter.negate() : filter);
}
}
catch (Exception ignored) {
@@ -74,7 +75,7 @@ public class SFilterUtil {
Predicate<CardRules> textFilter;
textFilter = invert ? Predicates.or(terms).negate() : Predicates.and(terms);
return Predicates.compose(textFilter, PaperCard::getRules);
return PaperCardPredicates.fromRules(textFilter);
}
private static List<String> getSplitText(String text) {

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

@@ -49,6 +49,7 @@ import forge.gui.GuiBase;
import forge.gui.card.CardPreferences;
import forge.gui.interfaces.IProgressBar;
import forge.item.PaperCard;
import forge.item.PaperCardPredicates;
import forge.itemmanager.ItemManagerConfig;
import forge.localinstance.achievements.*;
import forge.localinstance.properties.ForgeConstants;
@@ -324,13 +325,13 @@ public final class FModel {
public static ItemPool<PaperCard> getArchenemyCards() {
if (archenemyCards == null)
return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(Predicates.compose(CardRulesPredicates.IS_SCHEME, PaperCard::getRules)), PaperCard.class);
return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(PaperCardPredicates.fromRules(CardRulesPredicates.IS_SCHEME)), PaperCard.class);
return archenemyCards;
}
public static ItemPool<PaperCard> getPlanechaseCards() {
if (planechaseCards == null)
return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(Predicates.compose(CardRulesPredicates.IS_PLANE_OR_PHENOMENON, PaperCard::getRules)), PaperCard.class);
return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(PaperCardPredicates.fromRules(CardRulesPredicates.IS_PLANE_OR_PHENOMENON)), PaperCard.class);
return planechaseCards;
}
@@ -338,7 +339,7 @@ public final class FModel {
if (brawlCommander == null) {
return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(
FModel.getFormats().get("Brawl").getFilterPrinted()
.and(Predicates.compose(CardRulesPredicates.CAN_BE_BRAWL_COMMANDER, PaperCard::getRules))
.and(PaperCardPredicates.fromRules(CardRulesPredicates.CAN_BE_BRAWL_COMMANDER))
), PaperCard.class);
}
return brawlCommander;
@@ -346,44 +347,50 @@ public final class FModel {
public static ItemPool<PaperCard> getOathbreakerCommander() {
if (oathbreakerCommander == null)
return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(Predicates.compose(
CardRulesPredicates.CAN_BE_OATHBREAKER.or(CardRulesPredicates.CAN_BE_SIGNATURE_SPELL), PaperCard::getRules)), PaperCard.class);
return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(PaperCardPredicates.fromRules(
CardRulesPredicates.CAN_BE_OATHBREAKER.or(CardRulesPredicates.CAN_BE_SIGNATURE_SPELL))), PaperCard.class);
return oathbreakerCommander;
}
public static ItemPool<PaperCard> getTinyLeadersCommander() {
if (tinyLeadersCommander == null)
return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(Predicates.compose(CardRulesPredicates.CAN_BE_TINY_LEADERS_COMMANDER, PaperCard::getRules)), PaperCard.class);
return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(PaperCardPredicates.fromRules(
CardRulesPredicates.CAN_BE_TINY_LEADERS_COMMANDER)), PaperCard.class);
return tinyLeadersCommander;
}
public static ItemPool<PaperCard> getCommanderPool() {
if (commanderPool == null)
return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(Predicates.compose(CardRulesPredicates.CAN_BE_COMMANDER, PaperCard::getRules)), PaperCard.class);
return ItemPool.createFrom(getMagicDb().getCommonCards().getAllCardsNoAlt(PaperCardPredicates.fromRules(
CardRulesPredicates.CAN_BE_COMMANDER)), PaperCard.class);
return commanderPool;
}
public static ItemPool<PaperCard> getAvatarPool() {
if (avatarPool == null)
return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(Predicates.compose(CardRulesPredicates.IS_VANGUARD, PaperCard::getRules)), PaperCard.class);
return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(PaperCardPredicates.fromRules(
CardRulesPredicates.IS_VANGUARD)), PaperCard.class);
return avatarPool;
}
public static ItemPool<PaperCard> getConspiracyPool() {
if (conspiracyPool == null)
return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(Predicates.compose(CardRulesPredicates.IS_CONSPIRACY, PaperCard::getRules)), PaperCard.class);
return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(PaperCardPredicates.fromRules(
CardRulesPredicates.IS_CONSPIRACY)), PaperCard.class);
return conspiracyPool;
}
public static ItemPool<PaperCard> getDungeonPool() {
if (dungeonPool == null)
return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(Predicates.compose(CardRulesPredicates.IS_DUNGEON, PaperCard::getRules)), PaperCard.class);
return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(PaperCardPredicates.fromRules(
CardRulesPredicates.IS_DUNGEON)), PaperCard.class);
return dungeonPool;
}
public static ItemPool<PaperCard> getAttractionPool() {
if (attractionPool == null)
return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(Predicates.compose(CardRulesPredicates.IS_ATTRACTION, PaperCard::getRules)), PaperCard.class);
return ItemPool.createFrom(getMagicDb().getVariantCards().getAllCards(PaperCardPredicates.fromRules(
CardRulesPredicates.IS_ATTRACTION)), PaperCard.class);
return attractionPool;
}
private static boolean keywordsLoaded = false;

13
forge-lda/src/main/java/forge/lda/LDAModelGenetrator.java
View File

@@ -11,6 +11,7 @@ import forge.deck.io.Archetype;
import forge.deck.io.CardThemedLDAIO;
import forge.deck.io.DeckStorage;
import forge.gui.GuiBase;
import forge.item.PaperCardPredicates;
import forge.lda.dataset.Dataset;
import forge.lda.lda.LDA;
import forge.game.GameFormat;
@@ -290,8 +291,8 @@ public final class LDAModelGenetrator {
true);
//get all cards
final Iterable<PaperCard> cards = Iterables.filter(FModel.getMagicDb().getCommonCards().getUniqueCards()
, Predicates.compose(CardRulesPredicates.NOT_TRUE_BASIC_LAND, PaperCard::getRules));
final Iterable<PaperCard> cards = Iterables.filter(FModel.getMagicDb().getCommonCards().getUniqueCards(),
PaperCardPredicates.fromRules(CardRulesPredicates.NOT_TRUE_BASIC_LAND));
List<PaperCard> cardList = Lists.newArrayList(cards);
cardList.add(FModel.getMagicDb().getCommonCards().getCard("Wastes"));
Map<String, Integer> cardIntegerMap = new HashMap<>();
@@ -305,9 +306,9 @@ public final class LDAModelGenetrator {
}
//filter to just legal commanders
List<PaperCard> legends = Lists.newArrayList(Iterables.filter(cardList,Predicates.compose(
DeckFormat.Commander::isLegalCommander, PaperCard::getRules
)));
List<PaperCard> legends = Lists.newArrayList(Iterables.filter(cardList, PaperCardPredicates.fromRules(
DeckFormat.Commander::isLegalCommander))
);
//generate lookups for legends to link commander names to matrix rows
for (int i=0; i<legends.size(); ++i){
@@ -350,7 +351,7 @@ public final class LDAModelGenetrator {
public static void updateLegendMatrix(Deck deck, PaperCard legend, Map<String, Integer> cardIntegerMap,
Map<String, Integer> legendIntegerMap, int[][] matrix){
for (PaperCard pairCard:Iterables.filter(deck.getMain().toFlatList(),
Predicates.compose(CardRulesPredicates.NOT_TRUE_BASIC_LAND, PaperCard::getRules))){
PaperCardPredicates.fromRules(CardRulesPredicates.NOT_TRUE_BASIC_LAND))){
if (!pairCard.getName().equals(legend.getName())){
try {
int old = matrix[legendIntegerMap.get(legend.getName())][cardIntegerMap.get(pairCard.getName())];