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

Guava migration - Inline Predicates.not

Browse Source
This commit is contained in:
Jetz
2024-09-03 09:41:07 -04:00
parent 22e7465212
commit 78bc9fd04e
52 changed files with 125 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
forge-ai/src/main/java/forge/ai/AiBlockController.java
View File

@@ -367,7 +367,7 @@ public class AiBlockController {
* @param combat a {@link forge.game.combat.Combat} object. * @param combat a {@link forge.game.combat.Combat} object.
*/ */
private void makeGangBlocks(final Combat combat) { private void makeGangBlocks(final Combat combat) {
List<Card> currentAttackers = CardLists.filter(attackersLeft, Predicates.not(rampagesOrNeedsManyToBlock(combat))); List<Card> currentAttackers = CardLists.filter(attackersLeft, rampagesOrNeedsManyToBlock(combat).negate());
List<Card> blockers; List<Card> blockers;
// Try to block an attacker without first strike with a gang of first strikers // Try to block an attacker without first strike with a gang of first strikers
@@ -739,11 +739,11 @@ public class AiBlockController {
List<Card> chumpBlockers; List<Card> chumpBlockers;
List<Card> tramplingAttackers = CardLists.getKeyword(attackers, Keyword.TRAMPLE); List<Card> tramplingAttackers = CardLists.getKeyword(attackers, Keyword.TRAMPLE);
tramplingAttackers = CardLists.filter(tramplingAttackers, Predicates.not(rampagesOrNeedsManyToBlock(combat))); tramplingAttackers = CardLists.filter(tramplingAttackers, rampagesOrNeedsManyToBlock(combat).negate());
// TODO - Instead of filtering out rampage-like and similar triggers, make the AI properly count P/T and // TODO - Instead of filtering out rampage-like and similar triggers, make the AI properly count P/T and
// reinforce when actually possible without losing material. // reinforce when actually possible without losing material.
tramplingAttackers = CardLists.filter(tramplingAttackers, Predicates.not(changesPTWhenBlocked(true))); tramplingAttackers = CardLists.filter(tramplingAttackers, changesPTWhenBlocked(true).negate());
for (final Card attacker : tramplingAttackers) { for (final Card attacker : tramplingAttackers) {
if (CombatUtil.getMinNumBlockersForAttacker(attacker, combat.getDefenderPlayerByAttacker(attacker)) > combat.getBlockers(attacker).size()) { if (CombatUtil.getMinNumBlockersForAttacker(attacker, combat.getDefenderPlayerByAttacker(attacker)) > combat.getBlockers(attacker).size()) {
@@ -794,11 +794,11 @@ public class AiBlockController {
private void reinforceBlockersToKill(final Combat combat) { private void reinforceBlockersToKill(final Combat combat) {
List<Card> safeBlockers; List<Card> safeBlockers;
List<Card> blockers; List<Card> blockers;
List<Card> targetAttackers = CardLists.filter(blockedButUnkilled, Predicates.not(rampagesOrNeedsManyToBlock(combat))); List<Card> targetAttackers = CardLists.filter(blockedButUnkilled, rampagesOrNeedsManyToBlock(combat).negate());
// TODO - Instead of filtering out rampage-like and similar triggers, make the AI properly count P/T and // TODO - Instead of filtering out rampage-like and similar triggers, make the AI properly count P/T and
// reinforce when actually possible without losing material. // reinforce when actually possible without losing material.
targetAttackers = CardLists.filter(targetAttackers, Predicates.not(changesPTWhenBlocked(false))); targetAttackers = CardLists.filter(targetAttackers, changesPTWhenBlocked(false).negate());
for (final Card attacker : targetAttackers) { for (final Card attacker : targetAttackers) {
blockers = getPossibleBlockers(combat, attacker, blockersLeft, false); blockers = getPossibleBlockers(combat, attacker, blockersLeft, false);

16
forge-ai/src/main/java/forge/ai/AiController.java
View File

@@ -404,7 +404,7 @@ public class AiController {
private CardCollection filterLandsToPlay(CardCollection landList) { private CardCollection filterLandsToPlay(CardCollection landList) {
final CardCollectionView hand = player.getCardsIn(ZoneType.Hand); final CardCollectionView hand = player.getCardsIn(ZoneType.Hand);
CardCollection nonLandList = CardLists.filter(hand, Predicates.not(CardPredicates.Presets.LANDS)); CardCollection nonLandList = CardLists.filter(hand, Presets.LANDS.negate());
if (landList.size() == 1 && nonLandList.size() < 3) { if (landList.size() == 1 && nonLandList.size() < 3) {
CardCollectionView cardsInPlay = player.getCardsIn(ZoneType.Battlefield); CardCollectionView cardsInPlay = player.getCardsIn(ZoneType.Battlefield);
CardCollection landsInPlay = CardLists.filter(cardsInPlay, Presets.LANDS); CardCollection landsInPlay = CardLists.filter(cardsInPlay, Presets.LANDS);
@@ -469,7 +469,7 @@ public class AiController {
return null; return null;
} }
CardCollection nonLandsInHand = CardLists.filter(player.getCardsIn(ZoneType.Hand), Predicates.not(CardPredicates.Presets.LANDS)); CardCollection nonLandsInHand = CardLists.filter(player.getCardsIn(ZoneType.Hand), Presets.LANDS.negate());
// Some considerations for Momir/MoJhoSto // Some considerations for Momir/MoJhoSto
boolean hasMomir = player.isCardInCommand("Momir Vig, Simic Visionary Avatar"); boolean hasMomir = player.isCardInCommand("Momir Vig, Simic Visionary Avatar");
@@ -598,8 +598,8 @@ public class AiController {
} }
// pick dual lands if available // pick dual lands if available
if (Iterables.any(landList, Predicates.not(CardPredicates.Presets.BASIC_LANDS))) { if (Iterables.any(landList, Presets.BASIC_LANDS.negate())) {
landList = CardLists.filter(landList, Predicates.not(CardPredicates.Presets.BASIC_LANDS)); landList = CardLists.filter(landList, Presets.BASIC_LANDS.negate());
} }
} }
return ComputerUtilCard.getBestLandToPlayAI(landList); return ComputerUtilCard.getBestLandToPlayAI(landList);
@@ -1397,12 +1397,11 @@ public class AiController {
return false; return false;
} }
CardCollection inHand = CardLists.filter(player.getCardsIn(ZoneType.Hand), CardCollection inHand = CardLists.filter(player.getCardsIn(ZoneType.Hand), Presets.LANDS.negate());
Predicates.not(CardPredicates.Presets.LANDS));
CardCollectionView otb = player.getCardsIn(ZoneType.Battlefield); CardCollectionView otb = player.getCardsIn(ZoneType.Battlefield);
if (getBooleanProperty(AiProps.HOLD_LAND_DROP_ONLY_IF_HAVE_OTHER_PERMS)) { if (getBooleanProperty(AiProps.HOLD_LAND_DROP_ONLY_IF_HAVE_OTHER_PERMS)) {
if (!Iterables.any(otb, Predicates.not(CardPredicates.Presets.LANDS))) { if (!Iterables.any(otb, Presets.LANDS.negate())) {
return false; return false;
} }
} }
@@ -1578,7 +1577,8 @@ public class AiController {
if (sa.getHostCard().hasKeyword(Keyword.STORM) if (sa.getHostCard().hasKeyword(Keyword.STORM)
&& sa.getApi() != ApiType.Counter // AI would suck at trying to deliberately proc a Storm counterspell && sa.getApi() != ApiType.Counter // AI would suck at trying to deliberately proc a Storm counterspell
&& player.getZone(ZoneType.Hand).contains(Predicates.not(Predicates.or(CardPredicates.Presets.LANDS, CardPredicates.hasKeyword("Storm"))))) { && player.getZone(ZoneType.Hand).contains(
Predicates.or(Presets.LANDS, CardPredicates.hasKeyword("Storm")).negate())) {
if (game.getView().getStormCount() < this.getIntProperty(AiProps.MIN_COUNT_FOR_STORM_SPELLS)) { if (game.getView().getStormCount() < this.getIntProperty(AiProps.MIN_COUNT_FOR_STORM_SPELLS)) {
// skip evaluating Storm unless we reached the minimum Storm count // skip evaluating Storm unless we reached the minimum Storm count
continue; continue;

5
forge-ai/src/main/java/forge/ai/AiCostDecision.java
View File

@@ -14,7 +14,6 @@ import forge.game.spellability.SpellAbility;
import forge.game.spellability.SpellAbilityStackInstance; import forge.game.spellability.SpellAbilityStackInstance;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Aggregates; import forge.util.Aggregates;
import forge.util.Predicates;
import forge.util.TextUtil; import forge.util.TextUtil;
import forge.util.collect.FCollectionView; import forge.util.collect.FCollectionView;
import org.apache.commons.lang3.ObjectUtils; import org.apache.commons.lang3.ObjectUtils;
@@ -105,13 +104,13 @@ public class AiCostDecision extends CostDecisionMakerBase {
Card chosen; Card chosen;
if (!discardMe.isEmpty()) { if (!discardMe.isEmpty()) {
chosen = Aggregates.random(discardMe); chosen = Aggregates.random(discardMe);
discardMe = CardLists.filter(discardMe, Predicates.not(CardPredicates.sharesNameWith(chosen))); discardMe = CardLists.filter(discardMe, CardPredicates.sharesNameWith(chosen).negate());
} else { } else {
final Card worst = ComputerUtilCard.getWorstAI(hand); final Card worst = ComputerUtilCard.getWorstAI(hand);
chosen = worst != null ? worst : Aggregates.random(hand); chosen = worst != null ? worst : Aggregates.random(hand);
} }
differentNames.add(chosen); differentNames.add(chosen);
hand = CardLists.filter(hand, Predicates.not(CardPredicates.sharesNameWith(chosen))); hand = CardLists.filter(hand, CardPredicates.sharesNameWith(chosen).negate());
c--; c--;
} }
return PaymentDecision.card(differentNames); return PaymentDecision.card(differentNames);

6
forge-ai/src/main/java/forge/ai/ComputerUtil.java
View File

@@ -639,7 +639,7 @@ public class ComputerUtil {
// if the source has "Casualty", don't sacrifice cards that may have granted the effect // if the source has "Casualty", don't sacrifice cards that may have granted the effect
// TODO: is there a surefire way to determine which card added Casualty? // TODO: is there a surefire way to determine which card added Casualty?
if (source.hasKeyword(Keyword.CASUALTY)) { if (source.hasKeyword(Keyword.CASUALTY)) {
typeList = CardLists.filter(typeList, Predicates.not(CardPredicates.hasSVar("AIDontSacToCasualty"))); typeList = CardLists.filter(typeList, CardPredicates.hasSVar("AIDontSacToCasualty").negate());
} }
if (typeList.size() < amount) { if (typeList.size() < amount) {
@@ -1664,7 +1664,7 @@ public class ComputerUtil {
int damage = 0; int damage = 0;
final CardCollection all = new CardCollection(ai.getCardsIn(ZoneType.Battlefield)); final CardCollection all = new CardCollection(ai.getCardsIn(ZoneType.Battlefield));
all.addAll(ai.getCardsActivatableInExternalZones(true)); all.addAll(ai.getCardsActivatableInExternalZones(true));
all.addAll(CardLists.filter(ai.getCardsIn(ZoneType.Hand), Predicates.not(Presets.PERMANENTS))); all.addAll(CardLists.filter(ai.getCardsIn(ZoneType.Hand), Presets.PERMANENTS.negate()));
for (final Card c : all) { for (final Card c : all) {
if (c.getZone().getPlayer() != null && c.getZone().getPlayer() != ai && c.mayPlay(ai).isEmpty()) { if (c.getZone().getPlayer() != null && c.getZone().getPlayer() != ai && c.mayPlay(ai).isEmpty()) {
@@ -2450,7 +2450,7 @@ public class ComputerUtil {
// not enough good choices, need to fill the rest // not enough good choices, need to fill the rest
int minDiff = min - goodChoices.size(); int minDiff = min - goodChoices.size();
if (minDiff > 0) { if (minDiff > 0) {
goodChoices.addAll(Aggregates.random(CardLists.filter(validCards, Predicates.not(goodChoices::contains)), minDiff)); goodChoices.addAll(Aggregates.random(CardLists.filter(validCards, ((Predicate<Card>) goodChoices::contains).negate()), minDiff));
return goodChoices; return goodChoices;
} }

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

@@ -206,7 +206,7 @@ public class ComputerUtilCard {
} }
// prefer to target non basic lands // prefer to target non basic lands
final List<Card> nbLand = CardLists.filter(land, Predicates.not(CardPredicates.Presets.BASIC_LANDS)); final List<Card> nbLand = CardLists.filter(land, CardPredicates.Presets.BASIC_LANDS.negate());
if (!nbLand.isEmpty()) { if (!nbLand.isEmpty()) {
// TODO - Improve ranking various non-basic lands depending on context // TODO - Improve ranking various non-basic lands depending on context

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

@@ -633,7 +633,7 @@ public class ComputerUtilCost {
if (part instanceof CostSacrifice) { if (part instanceof CostSacrifice) {
CardCollection valid = CardLists.getValidCards(player.getCardsIn(ZoneType.Battlefield), part.getType().split(";"), CardCollection valid = CardLists.getValidCards(player.getCardsIn(ZoneType.Battlefield), part.getType().split(";"),
sa.getActivatingPlayer(), sa.getHostCard(), sa); sa.getActivatingPlayer(), sa.getHostCard(), sa);
valid = CardLists.filter(valid, Predicates.not(CardPredicates.hasSVar("AIDontSacToCasualty"))); valid = CardLists.filter(valid, CardPredicates.hasSVar("AIDontSacToCasualty").negate());
if (valid.isEmpty()) { if (valid.isEmpty()) {
return false; return false;
} }
@@ -924,7 +924,7 @@ public class ComputerUtilCost {
public static CardCollection paymentChoicesWithoutTargets(Iterable<Card> choices, SpellAbility source, Player ai) { public static CardCollection paymentChoicesWithoutTargets(Iterable<Card> choices, SpellAbility source, Player ai) {
if (source.usesTargeting()) { if (source.usesTargeting()) {
final CardCollection targets = new CardCollection(source.getTargets().getTargetCards()); final CardCollection targets = new CardCollection(source.getTargets().getTargetCards());
choices = Iterables.filter(choices, Predicates.not(Predicates.and(CardPredicates.isController(ai), targets::contains))); choices = Iterables.filter(choices, Predicates.and(CardPredicates.isController(ai), targets::contains).negate());
} }
return new CardCollection(choices); return new CardCollection(choices);
} }

6
forge-ai/src/main/java/forge/ai/PlayerControllerAi.java
View File

@@ -764,7 +764,7 @@ public class PlayerControllerAi extends PlayerController {
// If we're flooding with lands, get rid of the worst land we have // If we're flooding with lands, get rid of the worst land we have
if (numLandsInHand > 0 && numLandsInHand > numLandsDesired) { if (numLandsInHand > 0 && numLandsInHand > numLandsDesired) {
CardCollection producingLands = CardLists.filter(landsInHand, Presets.LANDS_PRODUCING_MANA); CardCollection producingLands = CardLists.filter(landsInHand, Presets.LANDS_PRODUCING_MANA);
CardCollection nonProducingLands = CardLists.filter(landsInHand, Predicates.not(Presets.LANDS_PRODUCING_MANA)); CardCollection nonProducingLands = CardLists.filter(landsInHand, Presets.LANDS_PRODUCING_MANA.negate());
Card worstLand = nonProducingLands.isEmpty() ? ComputerUtilCard.getWorstLand(producingLands) Card worstLand = nonProducingLands.isEmpty() ? ComputerUtilCard.getWorstLand(producingLands)
: ComputerUtilCard.getWorstLand(nonProducingLands); : ComputerUtilCard.getWorstLand(nonProducingLands);
toReturn.add(worstLand); toReturn.add(worstLand);
@@ -1436,7 +1436,7 @@ public class PlayerControllerAi extends PlayerController {
if (consp.getState(CardStateName.Original).hasIntrinsicKeyword("Hidden agenda")) { if (consp.getState(CardStateName.Original).hasIntrinsicKeyword("Hidden agenda")) {
String chosenName = consp.getNamedCard(); String chosenName = consp.getNamedCard();
if (!chosenName.isEmpty()) { if (!chosenName.isEmpty()) {
aiLibrary = CardLists.filter(aiLibrary, Predicates.not(CardPredicates.nameEquals(chosenName))); aiLibrary = CardLists.filter(aiLibrary, CardPredicates.nameEquals(chosenName).negate());
} }
} }
} }
@@ -1469,7 +1469,7 @@ public class PlayerControllerAi extends PlayerController {
} }
} else { } else {
CardCollectionView list = CardLists.filterControlledBy(getGame().getCardsInGame(), player.getOpponents()); CardCollectionView list = CardLists.filterControlledBy(getGame().getCardsInGame(), player.getOpponents());
list = CardLists.filter(list, Predicates.not(Presets.LANDS)); list = CardLists.filter(list, Presets.LANDS.negate());
if (!list.isEmpty()) { if (!list.isEmpty()) {
return list.get(0).getName(); return list.get(0).getName();
} }

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

@@ -125,7 +125,7 @@ public class SpecialCardAi {
int numManaSrcs = manaSources.size(); int numManaSrcs = manaSources.size();
CardCollection allCards = CardLists.filter(ai.getAllCards(), Arrays.asList(CardPredicates.Presets.NON_TOKEN, CardCollection allCards = CardLists.filter(ai.getAllCards(), Arrays.asList(CardPredicates.Presets.NON_TOKEN,
Predicates.not(CardPredicates.Presets.LANDS), CardPredicates.isOwner(ai))); CardPredicates.Presets.LANDS.negate(), CardPredicates.isOwner(ai)));
int numHighCMC = CardLists.count(allCards, CardPredicates.greaterCMC(5)); int numHighCMC = CardLists.count(allCards, CardPredicates.greaterCMC(5));
int numLowCMC = CardLists.count(allCards, CardPredicates.lessCMC(3)); int numLowCMC = CardLists.count(allCards, CardPredicates.lessCMC(3));
@@ -206,7 +206,7 @@ public class SpecialCardAi {
List<Card> AiLandsOnly = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), List<Card> AiLandsOnly = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield),
CardPredicates.Presets.LANDS); CardPredicates.Presets.LANDS);
List<Card> OppPerms = CardLists.filter(ai.getOpponents().getCardsIn(ZoneType.Battlefield), List<Card> OppPerms = CardLists.filter(ai.getOpponents().getCardsIn(ZoneType.Battlefield),
Predicates.not(CardPredicates.Presets.CREATURES)); CardPredicates.Presets.CREATURES.negate());
// TODO: improve this logic (currently the AI has difficulty evaluating non-creature permanents, // TODO: improve this logic (currently the AI has difficulty evaluating non-creature permanents,
// which it can only distinguish by their CMC, considering >CMC higher value). // which it can only distinguish by their CMC, considering >CMC higher value).
@@ -331,12 +331,12 @@ public class SpecialCardAi {
public static class DeathgorgeScavenger { public static class DeathgorgeScavenger {
public static boolean consider(final Player ai, final SpellAbility sa) { public static boolean consider(final Player ai, final SpellAbility sa) {
Card worstCreat = ComputerUtilCard.getWorstAI(CardLists.filter(ai.getOpponents().getCardsIn(ZoneType.Graveyard), CardPredicates.Presets.CREATURES)); Card worstCreat = ComputerUtilCard.getWorstAI(CardLists.filter(ai.getOpponents().getCardsIn(ZoneType.Graveyard), CardPredicates.Presets.CREATURES));
Card worstNonCreat = ComputerUtilCard.getWorstAI(CardLists.filter(ai.getOpponents().getCardsIn(ZoneType.Graveyard), Predicates.not(CardPredicates.Presets.CREATURES))); Card worstNonCreat = ComputerUtilCard.getWorstAI(CardLists.filter(ai.getOpponents().getCardsIn(ZoneType.Graveyard), CardPredicates.Presets.CREATURES.negate()));
if (worstCreat == null) { if (worstCreat == null) {
worstCreat = ComputerUtilCard.getWorstAI(CardLists.filter(ai.getCardsIn(ZoneType.Graveyard), CardPredicates.Presets.CREATURES)); worstCreat = ComputerUtilCard.getWorstAI(CardLists.filter(ai.getCardsIn(ZoneType.Graveyard), CardPredicates.Presets.CREATURES));
} }
if (worstNonCreat == null) { if (worstNonCreat == null) {
worstNonCreat = ComputerUtilCard.getWorstAI(CardLists.filter(ai.getCardsIn(ZoneType.Graveyard), Predicates.not(CardPredicates.Presets.CREATURES))); worstNonCreat = ComputerUtilCard.getWorstAI(CardLists.filter(ai.getCardsIn(ZoneType.Graveyard), CardPredicates.Presets.CREATURES.negate()));
} }
sa.resetTargets(); sa.resetTargets();
@@ -786,7 +786,7 @@ public class SpecialCardAi {
int changeNum = AbilityUtils.calculateAmount(sa.getHostCard(), int changeNum = AbilityUtils.calculateAmount(sa.getHostCard(),
sa.getParamOrDefault("ChangeNum", "1"), sa); sa.getParamOrDefault("ChangeNum", "1"), sa);
CardCollection lib = CardLists.filter(ai.getCardsIn(ZoneType.Library), CardCollection lib = CardLists.filter(ai.getCardsIn(ZoneType.Library),
Predicates.not(CardPredicates.nameEquals(sa.getHostCard().getName()))); CardPredicates.nameEquals(sa.getHostCard().getName()).negate());
lib.sort(CardLists.CmcComparatorInv); lib.sort(CardLists.CmcComparatorInv);
// Additional cards which are difficult to auto-classify but which are generally good to Intuition for // Additional cards which are difficult to auto-classify but which are generally good to Intuition for
@@ -1316,7 +1316,7 @@ public class SpecialCardAi {
return false; return false;
} }
int aiLands = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), Predicates.and(CardPredicates.Presets.LANDS, Predicates.not(CardPredicates.Presets.BASIC_LANDS))).size(); int aiLands = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), Predicates.and(CardPredicates.Presets.LANDS, CardPredicates.Presets.BASIC_LANDS.negate())).size();
boolean hasBridge = false; boolean hasBridge = false;
for (Card c : ai.getCardsIn(ZoneType.Battlefield)) { for (Card c : ai.getCardsIn(ZoneType.Battlefield)) {
@@ -1334,7 +1334,7 @@ public class SpecialCardAi {
} }
for (Player opp : ai.getOpponents()) { for (Player opp : ai.getOpponents()) {
int oppLands = CardLists.filter(opp.getCardsIn(ZoneType.Battlefield), Predicates.and(CardPredicates.Presets.LANDS, Predicates.not(CardPredicates.Presets.BASIC_LANDS))).size(); int oppLands = CardLists.filter(opp.getCardsIn(ZoneType.Battlefield), Predicates.and(CardPredicates.Presets.LANDS, CardPredicates.Presets.BASIC_LANDS.negate())).size();
// Always if enemy would die and we don't! // Always if enemy would die and we don't!
// TODO : predict actual damage instead of assuming it'll be 2*lands // TODO : predict actual damage instead of assuming it'll be 2*lands
// Don't if we lose, unless we lose anyway to unblocked creatures next turn // Don't if we lose, unless we lose anyway to unblocked creatures next turn

7
forge-ai/src/main/java/forge/ai/ability/AttachAi.java
View File

@@ -1,6 +1,7 @@
package forge.ai.ability; package forge.ai.ability;
import java.util.*; import java.util.*;
import java.util.function.Predicate;
import forge.game.card.*; import forge.game.card.*;
import forge.util.Predicates; import forge.util.Predicates;
@@ -864,7 +865,7 @@ public class AttachAi extends SpellAbilityAi {
//some auras aren't useful in multiples //some auras aren't useful in multiples
if (attachSource.hasSVar("NonStackingAttachEffect")) { if (attachSource.hasSVar("NonStackingAttachEffect")) {
prefList = CardLists.filter(prefList, prefList = CardLists.filter(prefList,
Predicates.not(CardPredicates.isEnchantedBy(attachSource.getName())) CardPredicates.isEnchantedBy(attachSource.getName()).negate()
); );
} }
@@ -1143,10 +1144,10 @@ public class AttachAi extends SpellAbilityAi {
//some auras/equipments aren't useful in multiples //some auras/equipments aren't useful in multiples
if (attachSource.hasSVar("NonStackingAttachEffect")) { if (attachSource.hasSVar("NonStackingAttachEffect")) {
prefList = CardLists.filter(prefList, Predicates.not(Predicates.or( prefList = CardLists.filter(prefList, Predicates.or(
CardPredicates.isEquippedBy(attachSource.getName()), CardPredicates.isEquippedBy(attachSource.getName()),
CardPredicates.isEnchantedBy(attachSource.getName()) CardPredicates.isEnchantedBy(attachSource.getName())
))); ).negate());
} }
// Don't pump cards that will die. // Don't pump cards that will die.

16
forge-ai/src/main/java/forge/ai/ability/ChangeZoneAi.java
View File

@@ -29,10 +29,10 @@ import forge.game.zone.ZoneType;
import forge.util.Aggregates; import forge.util.Aggregates;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.Predicates;
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
import java.util.*; import java.util.*;
import java.util.function.Predicate;
public class ChangeZoneAi extends SpellAbilityAi { public class ChangeZoneAi extends SpellAbilityAi {
/* /*
@@ -371,7 +371,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
// remove cards that won't be seen if library can't be searched // remove cards that won't be seen if library can't be searched
if (!ai.canSearchLibraryWith(sa, p)) { if (!ai.canSearchLibraryWith(sa, p)) {
list = CardLists.filter(list, Predicates.not(CardPredicates.inZone(ZoneType.Library))); list = CardLists.filter(list, CardPredicates.inZone(ZoneType.Library).negate());
} }
if (type != null && p == ai) { if (type != null && p == ai) {
@@ -614,8 +614,8 @@ public class ChangeZoneAi extends SpellAbilityAi {
} }
// pick dual lands if available // pick dual lands if available
if (Iterables.any(result, Predicates.not(CardPredicates.Presets.BASIC_LANDS))) { if (Iterables.any(result, Presets.BASIC_LANDS.negate())) {
result = CardLists.filter(result, Predicates.not(CardPredicates.Presets.BASIC_LANDS)); result = CardLists.filter(result, Presets.BASIC_LANDS.negate());
} }
return result.get(0); return result.get(0);
@@ -906,7 +906,8 @@ public class ChangeZoneAi extends SpellAbilityAi {
} }
if (source.isInZone(ZoneType.Hand)) { if (source.isInZone(ZoneType.Hand)) {
list = CardLists.filter(list, Predicates.not(CardPredicates.nameEquals(source.getName()))); // Don't get the same card back. Predicate<Card> nameEquals = CardPredicates.nameEquals(source.getName());
list = CardLists.filter(list, nameEquals.negate()); // Don't get the same card back.
} }
if (sa.isSpell()) { if (sa.isSpell()) {
list.remove(source); // spells can't target their own source, because it's actually in the stack zone list.remove(source); // spells can't target their own source, because it's actually in the stack zone
@@ -1629,7 +1630,8 @@ public class ChangeZoneAi extends SpellAbilityAi {
} }
} else { } else {
// Don't fetch another tutor with the same name // Don't fetch another tutor with the same name
CardCollection sameNamed = CardLists.filter(fetchList, Predicates.not(CardPredicates.nameEquals(ComputerUtilAbility.getAbilitySourceName(sa)))); Predicate<Card> nameEquals = CardPredicates.nameEquals(ComputerUtilAbility.getAbilitySourceName(sa));
CardCollection sameNamed = CardLists.filter(fetchList, nameEquals.negate());
if (origin.contains(ZoneType.Library) && !sameNamed.isEmpty()) { if (origin.contains(ZoneType.Library) && !sameNamed.isEmpty()) {
fetchList = sameNamed; fetchList = sameNamed;
} }
@@ -1961,7 +1963,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
} }
if (logic.contains("NonLand")) { if (logic.contains("NonLand")) {
scanList = CardLists.filter(scanList, Predicates.not(Presets.LANDS)); scanList = CardLists.filter(scanList, Presets.LANDS.negate());
} }
if (logic.contains("NonExiled")) { if (logic.contains("NonExiled")) {

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

@@ -27,7 +27,6 @@ import forge.game.spellability.SpellAbility;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Aggregates; import forge.util.Aggregates;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.Predicates;
public class ChooseCardAi extends SpellAbilityAi { public class ChooseCardAi extends SpellAbilityAi {
@@ -271,7 +270,7 @@ public class ChooseCardAi extends SpellAbilityAi {
} else if (logic.equals("Phylactery")) { } else if (logic.equals("Phylactery")) {
CardCollection aiArtifacts = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), Presets.ARTIFACTS); CardCollection aiArtifacts = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), Presets.ARTIFACTS);
CardCollection indestructibles = CardLists.filter(aiArtifacts, CardPredicates.hasKeyword(Keyword.INDESTRUCTIBLE)); CardCollection indestructibles = CardLists.filter(aiArtifacts, CardPredicates.hasKeyword(Keyword.INDESTRUCTIBLE));
CardCollection nonCreatures = CardLists.filter(aiArtifacts, Predicates.not(Presets.CREATURES)); CardCollection nonCreatures = CardLists.filter(aiArtifacts, Presets.CREATURES.negate());
CardCollection creatures = CardLists.filter(aiArtifacts, Presets.CREATURES); CardCollection creatures = CardLists.filter(aiArtifacts, Presets.CREATURES);
if (!indestructibles.isEmpty()) { if (!indestructibles.isEmpty()) {
// Choose the worst (smallest) indestructible artifact so that the opponent would have to waste // Choose the worst (smallest) indestructible artifact so that the opponent would have to waste

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

@@ -135,9 +135,9 @@ public class ChooseSourceAi extends SpellAbilityAi {
// No optimal creature was found above, so try to broaden the choice. // No optimal creature was found above, so try to broaden the choice.
if (!Iterables.isEmpty(options)) { if (!Iterables.isEmpty(options)) {
List<Card> oppCreatures = CardLists.filter(options, Predicates.and(CardPredicates.Presets.CREATURES, List<Card> oppCreatures = CardLists.filter(options, Predicates.and(CardPredicates.Presets.CREATURES,
Predicates.not(CardPredicates.isOwner(aiChoser)))); CardPredicates.isOwner(aiChoser).negate()));
List<Card> aiNonCreatures = CardLists.filter(options, List<Card> aiNonCreatures = CardLists.filter(options,
Predicates.not(CardPredicates.Presets.CREATURES) CardPredicates.Presets.CREATURES.negate()
.and(CardPredicates.Presets.PERMANENTS) .and(CardPredicates.Presets.PERMANENTS)
.and(CardPredicates.isOwner(aiChoser)) .and(CardPredicates.isOwner(aiChoser))
); );

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

@@ -18,7 +18,6 @@ import forge.game.player.Player;
import forge.game.player.PlayerActionConfirmMode; import forge.game.player.PlayerActionConfirmMode;
import forge.game.spellability.SpellAbility; import forge.game.spellability.SpellAbility;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Predicates;
public class CloneAi extends SpellAbilityAi { public class CloneAi extends SpellAbilityAi {
@@ -210,7 +209,7 @@ public class CloneAi extends SpellAbilityAi {
// prevent loop of choosing copy of same card // prevent loop of choosing copy of same card
if (isVesuva) { if (isVesuva) {
options = CardLists.filter(options, Predicates.not(CardPredicates.sharesNameWith(host))); options = CardLists.filter(options, CardPredicates.sharesNameWith(host).negate());
} }
Card choice = isOpp ? ComputerUtilCard.getWorstAI(options) : ComputerUtilCard.getBestAI(options); Card choice = isOpp ? ComputerUtilCard.getWorstAI(options) : ComputerUtilCard.getBestAI(options);

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

@@ -29,7 +29,6 @@ import forge.game.player.Player;
import forge.game.spellability.SpellAbility; import forge.game.spellability.SpellAbility;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.Predicates;
/** /**
@@ -64,7 +63,7 @@ public class ControlGainVariantAi extends SpellAbilityAi {
@Override @Override
public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) { public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
Iterable<Card> otherCtrl = CardLists.filter(options, Predicates.not(CardPredicates.isController(ai))); Iterable<Card> otherCtrl = CardLists.filter(options, CardPredicates.isController(ai).negate());
if (Iterables.isEmpty(otherCtrl)) { if (Iterables.isEmpty(otherCtrl)) {
return ComputerUtilCard.getWorstAI(options); return ComputerUtilCard.getWorstAI(options);
} else { } else {

7
forge-ai/src/main/java/forge/ai/ability/CopyPermanentAi.java
View File

@@ -3,6 +3,7 @@ package forge.ai.ability;
import java.util.Collection; import java.util.Collection;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.function.Predicate;
import forge.ai.AiPlayDecision; import forge.ai.AiPlayDecision;
import forge.ai.ComputerUtil; import forge.ai.ComputerUtil;
@@ -31,7 +32,6 @@ import forge.game.player.PlayerCollection;
import forge.game.spellability.SpellAbility; import forge.game.spellability.SpellAbility;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.Predicates;
public class CopyPermanentAi extends SpellAbilityAi { public class CopyPermanentAi extends SpellAbilityAi {
@Override @Override
@@ -135,7 +135,8 @@ public class CopyPermanentAi extends SpellAbilityAi {
// TODO: possibly improve the check, currently only checks if the name is the same // TODO: possibly improve the check, currently only checks if the name is the same
// Possibly also check if the card is threatened, and then allow to copy (this will, however, require a bit // Possibly also check if the card is threatened, and then allow to copy (this will, however, require a bit
// of a rewrite in canPlayAI to allow a response form of CopyPermanentAi) // of a rewrite in canPlayAI to allow a response form of CopyPermanentAi)
list = CardLists.filter(list, Predicates.not(CardPredicates.nameEquals(host.getName()))); Predicate<Card> nameEquals = CardPredicates.nameEquals(host.getName());
list = CardLists.filter(list, nameEquals.negate());
} }
//Nothing to target //Nothing to target
@@ -143,7 +144,7 @@ public class CopyPermanentAi extends SpellAbilityAi {
return false; return false;
} }
CardCollection betterList = CardLists.filter(list, Predicates.not(CardPredicates.isRemAIDeck())); CardCollection betterList = CardLists.filter(list, CardPredicates.isRemAIDeck().negate());
if (betterList.isEmpty()) { if (betterList.isEmpty()) {
if (!mandatory) { if (!mandatory) {
return false; return false;

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

@@ -24,7 +24,6 @@ import forge.game.player.Player;
import forge.game.spellability.SpellAbility; import forge.game.spellability.SpellAbility;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.Predicates;
public class CountersMultiplyAi extends SpellAbilityAi { public class CountersMultiplyAi extends SpellAbilityAi {
@@ -104,7 +103,7 @@ public class CountersMultiplyAi extends SpellAbilityAi {
if (list.isEmpty()) { if (list.isEmpty()) {
return false; return false;
} }
Card safeMatch = Iterables.getFirst(Iterables.filter(list, Predicates.not(CardPredicates.hasCounters())), null); Card safeMatch = Iterables.getFirst(Iterables.filter(list, CardPredicates.hasCounters().negate()), null);
sa.getTargets().add(safeMatch == null ? list.getFirst() : safeMatch); sa.getTargets().add(safeMatch == null ? list.getFirst() : safeMatch);
return true; return true;
} }

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

@@ -26,11 +26,11 @@ import forge.game.zone.ZoneType;
import forge.util.Aggregates; import forge.util.Aggregates;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.Predicates;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.function.Predicate;
public class CountersPutAi extends CountersAi { public class CountersPutAi extends CountersAi {
@@ -271,8 +271,9 @@ public class CountersPutAi extends CountersAi {
return false; return false;
} }
Predicate<Card> predicate = CardPredicates.hasCounter(CounterType.getType(type));
CardCollection oppCreats = CardLists.filter(ai.getOpponents().getCreaturesInPlay(), CardCollection oppCreats = CardLists.filter(ai.getOpponents().getCreaturesInPlay(),
Predicates.not(CardPredicates.hasCounter(CounterType.getType(type))), predicate.negate(),
CardPredicates.isTargetableBy(sa)); CardPredicates.isTargetableBy(sa));
if (!oppCreats.isEmpty()) { if (!oppCreats.isEmpty()) {

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

@@ -14,7 +14,8 @@ import forge.game.player.Player;
import forge.game.spellability.SpellAbility; import forge.game.spellability.SpellAbility;
import forge.game.staticability.StaticAbilityMustTarget; import forge.game.staticability.StaticAbilityMustTarget;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Predicates;
import java.util.function.Predicate;
public class DestroyAi extends SpellAbilityAi { public class DestroyAi extends SpellAbilityAi {
@Override @Override
@@ -167,7 +168,8 @@ public class DestroyAi extends SpellAbilityAi {
list = ComputerUtilCard.prioritizeCreaturesWorthRemovingNow(ai, list, false); list = ComputerUtilCard.prioritizeCreaturesWorthRemovingNow(ai, list, false);
} }
if (!playReusable(ai, sa)) { if (!playReusable(ai, sa)) {
list = CardLists.filter(list, Predicates.not(CardPredicates.hasCounter(CounterEnumType.SHIELD, 1))); Predicate<Card> hasCounter = CardPredicates.hasCounter(CounterEnumType.SHIELD, 1);
list = CardLists.filter(list, hasCounter.negate());
list = CardLists.filter(list, c -> { list = CardLists.filter(list, c -> {
//Check for cards that can be sacrificed in response //Check for cards that can be sacrificed in response
@@ -321,7 +323,8 @@ public class DestroyAi extends SpellAbilityAi {
CardCollection preferred = CardLists.getNotKeyword(list, Keyword.INDESTRUCTIBLE); CardCollection preferred = CardLists.getNotKeyword(list, Keyword.INDESTRUCTIBLE);
preferred = CardLists.filterControlledBy(preferred, ai.getOpponents()); preferred = CardLists.filterControlledBy(preferred, ai.getOpponents());
preferred = CardLists.filter(preferred, Predicates.not(CardPredicates.hasCounter(CounterEnumType.SHIELD, 1))); Predicate<Card> hasCounter = CardPredicates.hasCounter(CounterEnumType.SHIELD, 1);
preferred = CardLists.filter(preferred, hasCounter.negate());
if (CardLists.getNotType(preferred, "Creature").isEmpty()) { if (CardLists.getNotType(preferred, "Creature").isEmpty()) {
preferred = ComputerUtilCard.prioritizeCreaturesWorthRemovingNow(ai, preferred, false); preferred = ComputerUtilCard.prioritizeCreaturesWorthRemovingNow(ai, preferred, false);
} }

4
forge-ai/src/main/java/forge/ai/ability/EffectAi.java
View File

@@ -338,7 +338,7 @@ public class EffectAi extends SpellAbilityAi {
runParams.put(AbilityKey.Regeneration, true); runParams.put(AbilityKey.Regeneration, true);
List<ReplacementEffect> repDestoryList = game.getReplacementHandler().getReplacementList(ReplacementType.Destroy, runParams, ReplacementLayer.Other); List<ReplacementEffect> repDestoryList = game.getReplacementHandler().getReplacementList(ReplacementType.Destroy, runParams, ReplacementLayer.Other);
// no Destroy Replacement, or one non-Regeneration one like Totem-Armor // no Destroy Replacement, or one non-Regeneration one like Totem-Armor
if (repDestoryList.isEmpty() || Iterables.any(repDestoryList, Predicates.not(CardTraitPredicates.hasParam("Regeneration")))) { if (repDestoryList.isEmpty() || Iterables.any(repDestoryList, CardTraitPredicates.hasParam("Regeneration").negate())) {
return false; return false;
} }
@@ -369,7 +369,7 @@ public class EffectAi extends SpellAbilityAi {
runParams.put(AbilityKey.Regeneration, true); runParams.put(AbilityKey.Regeneration, true);
List<ReplacementEffect> repDestoryList = game.getReplacementHandler().getReplacementList(ReplacementType.Destroy, runParams, ReplacementLayer.Other); List<ReplacementEffect> repDestoryList = game.getReplacementHandler().getReplacementList(ReplacementType.Destroy, runParams, ReplacementLayer.Other);
// no Destroy Replacement, or one non-Regeneration one like Totem-Armor // no Destroy Replacement, or one non-Regeneration one like Totem-Armor
if (repDestoryList.isEmpty() || Iterables.any(repDestoryList, Predicates.not(CardTraitPredicates.hasParam("Regeneration")))) { if (repDestoryList.isEmpty() || Iterables.any(repDestoryList, CardTraitPredicates.hasParam("Regeneration").negate())) {
return false; return false;
} }

6
forge-ai/src/main/java/forge/ai/ability/MutateAi.java
View File

@@ -13,7 +13,6 @@ import forge.game.keyword.Keyword;
import forge.game.player.Player; import forge.game.player.Player;
import forge.game.player.PlayerActionConfirmMode; import forge.game.player.PlayerActionConfirmMode;
import forge.game.spellability.SpellAbility; import forge.game.spellability.SpellAbility;
import forge.util.Predicates;
public class MutateAi extends SpellAbilityAi { public class MutateAi extends SpellAbilityAi {
@Override @Override
@@ -23,12 +22,13 @@ public class MutateAi extends SpellAbilityAi {
// Filter out some abilities that are useless // Filter out some abilities that are useless
// TODO: add other stuff useless for Mutate here // TODO: add other stuff useless for Mutate here
mutateTgts = CardLists.filter(mutateTgts, Predicates.not( mutateTgts = CardLists.filter(mutateTgts,
CardPredicates.hasKeyword(Keyword.DEFENDER) CardPredicates.hasKeyword(Keyword.DEFENDER)
.or(CardPredicates.hasKeyword("CARDNAME can't attack.")) .or(CardPredicates.hasKeyword("CARDNAME can't attack."))
.or(CardPredicates.hasKeyword("CARDNAME can't block.")) .or(CardPredicates.hasKeyword("CARDNAME can't block."))
.or(card -> ComputerUtilCard.isUselessCreature(aiPlayer, card)) .or(card -> ComputerUtilCard.isUselessCreature(aiPlayer, card))
)); .negate()
);
if (mutateTgts.isEmpty()) { if (mutateTgts.isEmpty()) {
return false; return false;

6
forge-ai/src/main/java/forge/ai/ability/PermanentAi.java
View File

@@ -141,10 +141,10 @@ public class PermanentAi extends SpellAbilityAi {
&& card.getState(CardStateName.Original).getManaCost() != null && card.getState(CardStateName.Original).getManaCost() != null
&& card.getState(CardStateName.Original).getManaCost().getCMC() == manaValue); && card.getState(CardStateName.Original).getManaCost().getCMC() == manaValue);
if (manaValue == 0) { if (manaValue == 0) {
aiCards = CardLists.filter(aiCards, Predicates.not(CardPredicates.isType("Land"))); aiCards = CardLists.filter(aiCards, CardPredicates.isType("Land").negate());
oppCards = CardLists.filter(oppCards, Predicates.not(CardPredicates.isType("Land"))); oppCards = CardLists.filter(oppCards, CardPredicates.isType("Land").negate());
// also filter out other Chalices in our own deck // also filter out other Chalices in our own deck
aiCards = CardLists.filter(aiCards, Predicates.not(CardPredicates.nameEquals("Chalice of the Void"))); aiCards = CardLists.filter(aiCards, CardPredicates.nameEquals("Chalice of the Void").negate());
} }
if (oppCards.size() > 3 && oppCards.size() >= aiCards.size() * 2) { if (oppCards.size() > 3 && oppCards.size() >= aiCards.size() * 2) {
sa.setXManaCostPaid(manaValue); sa.setXManaCostPaid(manaValue);

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

@@ -15,11 +15,11 @@ import forge.game.spellability.SpellAbility;
import forge.game.spellability.TargetRestrictions; import forge.game.spellability.TargetRestrictions;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.Predicates;
import java.util.Collection; import java.util.Collection;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.function.Predicate;
public class PhasesAi extends SpellAbilityAi { public class PhasesAi extends SpellAbilityAi {
@Override @Override
@@ -117,7 +117,8 @@ public class PhasesAi extends SpellAbilityAi {
// in general, if it's our own creature, choose the weakest one, if it's the opponent's creature, // in general, if it's our own creature, choose the weakest one, if it's the opponent's creature,
// choose the strongest one // choose the strongest one
if (!list.isEmpty()) { if (!list.isEmpty()) {
CardCollectionView oppList = CardLists.filter(list, Predicates.not(CardPredicates.isController(source.getController()))); Predicate<Card> isController = CardPredicates.isController(source.getController());
CardCollectionView oppList = CardLists.filter(list, isController.negate());
sa.resetTargets(); sa.resetTargets();
sa.getTargets().add(!oppList.isEmpty() ? ComputerUtilCard.getBestAI(oppList) : ComputerUtilCard.getWorstAI(list)); sa.getTargets().add(!oppList.isEmpty() ? ComputerUtilCard.getBestAI(oppList) : ComputerUtilCard.getWorstAI(list));
return true; return true;

2
forge-ai/src/main/java/forge/ai/ability/PumpAiBase.java
View File

@@ -222,7 +222,7 @@ public abstract class PumpAiBase extends SpellAbilityAi {
&& !ph.getPhase().isAfter(PhaseType.COMBAT_DECLARE_ATTACKERS) && !ph.getPhase().isAfter(PhaseType.COMBAT_DECLARE_ATTACKERS)
&& newPower > 0 && newPower > 0
&& Iterables.any(CardLists.filter(opp.getCreaturesInPlay(), CardPredicates.possibleBlockers(card)), && Iterables.any(CardLists.filter(opp.getCreaturesInPlay(), CardPredicates.possibleBlockers(card)),
Predicates.not(flyingOrReach)); flyingOrReach.negate());
} else if (keyword.endsWith("Horsemanship")) { } else if (keyword.endsWith("Horsemanship")) {
if (ph.isPlayerTurn(opp) if (ph.isPlayerTurn(opp)
&& ph.getPhase().equals(PhaseType.COMBAT_DECLARE_ATTACKERS) && ph.getPhase().equals(PhaseType.COMBAT_DECLARE_ATTACKERS)

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

@@ -16,7 +16,6 @@ import forge.game.player.PlayerActionConfirmMode;
import forge.game.spellability.SpellAbility; import forge.game.spellability.SpellAbility;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.Predicates;
public class ScryAi extends SpellAbilityAi { public class ScryAi extends SpellAbilityAi {
@@ -100,7 +99,7 @@ public class ScryAi extends SpellAbilityAi {
private boolean doBestOpportunityLogic(Player ai, SpellAbility sa, PhaseHandler ph) { private boolean doBestOpportunityLogic(Player ai, SpellAbility sa, PhaseHandler ph) {
// Check to see if there are any cards in hand that may be worth casting // Check to see if there are any cards in hand that may be worth casting
boolean hasSomethingElse = false; boolean hasSomethingElse = false;
for (Card c : CardLists.filter(ai.getCardsIn(ZoneType.Hand), Predicates.not(CardPredicates.Presets.LANDS))) { for (Card c : CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.Presets.LANDS.negate())) {
for (SpellAbility ab : c.getAllSpellAbilities()) { for (SpellAbility ab : c.getAllSpellAbilities()) {
if (ab.getPayCosts().hasManaCost() if (ab.getPayCosts().hasManaCost()
&& ComputerUtilMana.hasEnoughManaSourcesToCast(ab, ai)) { && ComputerUtilMana.hasEnoughManaSourcesToCast(ab, ai)) {

6
forge-ai/src/main/java/forge/ai/ability/UntapAi.java
View File

@@ -8,7 +8,6 @@ import forge.game.ability.ApiType;
import forge.game.card.Card; import forge.game.card.Card;
import forge.game.card.CardCollection; import forge.game.card.CardCollection;
import forge.game.card.CardLists; import forge.game.card.CardLists;
import forge.game.card.CardPredicates;
import forge.game.card.CardPredicates.Presets; import forge.game.card.CardPredicates.Presets;
import forge.game.combat.Combat; import forge.game.combat.Combat;
import forge.game.cost.Cost; import forge.game.cost.Cost;
@@ -23,7 +22,6 @@ import forge.game.spellability.SpellAbility;
import forge.game.spellability.TargetRestrictions; import forge.game.spellability.TargetRestrictions;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.Predicates;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@@ -340,7 +338,7 @@ public class UntapAi extends SpellAbilityAi {
} }
// See if there's anything to untap that is tapped and that doesn't untap during the next untap step by itself // See if there's anything to untap that is tapped and that doesn't untap during the next untap step by itself
CardCollection noAutoUntap = CardLists.filter(untapList, Predicates.not(Untap.CANUNTAP)); CardCollection noAutoUntap = CardLists.filter(untapList, Untap.CANUNTAP.negate());
if (!noAutoUntap.isEmpty()) { if (!noAutoUntap.isEmpty()) {
return ComputerUtilCard.getBestAI(noAutoUntap); return ComputerUtilCard.getBestAI(noAutoUntap);
} }
@@ -402,7 +400,7 @@ public class UntapAi extends SpellAbilityAi {
} }
// Check if something is playable if we untap for an additional mana with this, then proceed // Check if something is playable if we untap for an additional mana with this, then proceed
CardCollection inHand = CardLists.filter(ai.getCardsIn(ZoneType.Hand), Predicates.not(CardPredicates.Presets.LANDS)); CardCollection inHand = CardLists.filter(ai.getCardsIn(ZoneType.Hand), Presets.LANDS.negate());
// The AI is not very good at timing non-permanent spells this way, so filter them out // The AI is not very good at timing non-permanent spells this way, so filter them out
// (it may actually be possible to enable this for sorceries, but that'll need some canPlay shenanigans) // (it may actually be possible to enable this for sorceries, but that'll need some canPlay shenanigans)
CardCollection playable = CardLists.filter(inHand, Presets.PERMANENTS); CardCollection playable = CardLists.filter(inHand, Presets.PERMANENTS);

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

@@ -234,7 +234,7 @@ public abstract class DeckGeneratorBase {
addSome(targetSize - actualSize, tDeck.toFlatList()); addSome(targetSize - actualSize, tDeck.toFlatList());
} }
else if (actualSize > targetSize) { else if (actualSize > targetSize) {
Predicate<PaperCard> exceptBasicLand = Predicates.not(Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules)); Predicate<PaperCard> exceptBasicLand = Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules).negate();
for (int i = 0; i < 3 && actualSize > targetSize; i++) { for (int i = 0; i < 3 && actualSize > targetSize; i++) {
Iterable<PaperCard> matchingCards = Iterables.filter(tDeck.toFlatList(), exceptBasicLand); Iterable<PaperCard> matchingCards = Iterables.filter(tDeck.toFlatList(), exceptBasicLand);
@@ -388,7 +388,7 @@ public abstract class DeckGeneratorBase {
//filter to provide all dual lands from pool matching 2 or 3 colors from current deck //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(true, CardType.CoreType.Land);
Predicate<CardRules> exceptBasicLand = Predicates.not(CardRulesPredicates.Presets.IS_BASIC_LAND); Predicate<CardRules> exceptBasicLand = CardRulesPredicates.Presets.IS_BASIC_LAND.negate();
Iterable<PaperCard> landCards = pool.getAllCards(Predicates.compose(dualLandFilter.and(exceptBasicLand).and(canPlay), PaperCard::getRules)); Iterable<PaperCard> landCards = pool.getAllCards(Predicates.compose(dualLandFilter.and(exceptBasicLand).and(canPlay), PaperCard::getRules));
Iterable<String> dualLandPatterns = Arrays.asList("Add \\{([WUBRG])\\} or \\{([WUBRG])\\}", Iterable<String> dualLandPatterns = Arrays.asList("Add \\{([WUBRG])\\} or \\{([WUBRG])\\}",

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

@@ -726,7 +726,7 @@ public class BoosterGenerator {
itOp.remove(); itOp.remove();
if (invert) { if (invert) {
toAdd = Predicates.not(toAdd); toAdd = toAdd.negate();
} }
conditions.add(toAdd); conditions.add(toAdd);
} }

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

@@ -1,6 +1,5 @@
package forge.util; package forge.util;
import java.util.Objects;
import java.util.function.Function; import java.util.function.Function;
import java.util.function.Predicate; import java.util.function.Predicate;
@@ -24,10 +23,6 @@ public class Predicates {
//TODO: Inline everything below. //TODO: Inline everything below.
public static <T> Predicate<T> not(Predicate<T> predicate) {
return predicate.negate();
}
public static <T> Predicate<T> and(Predicate<? super T> first, Predicate<? super T> second) { public static <T> Predicate<T> and(Predicate<? super T> first, Predicate<? super T> second) {
//TODO: remove casting? //TODO: remove casting?
return ((Predicate<T>) first).and(second); return ((Predicate<T>) first).and(second);

2
forge-game/src/main/java/forge/game/Game.java
View File

@@ -1099,7 +1099,7 @@ public class Game {
private void chooseRandomCardsForAnte(final Player player, final Multimap<Player, Card> anteed) { private void chooseRandomCardsForAnte(final Player player, final Multimap<Player, Card> anteed) {
final CardCollectionView lib = player.getCardsIn(ZoneType.Library); final CardCollectionView lib = player.getCardsIn(ZoneType.Library);
Predicate<Card> goodForAnte = Predicates.not(CardPredicates.Presets.BASIC_LANDS); Predicate<Card> goodForAnte = CardPredicates.Presets.BASIC_LANDS.negate();
Card ante = Aggregates.random(Iterables.filter(lib, goodForAnte)); Card ante = Aggregates.random(Iterables.filter(lib, goodForAnte));
if (ante == null) { if (ante == null) {
getGameLog().add(GameLogEntryType.ANTE, "Only basic lands found. Will ante one of them"); getGameLog().add(GameLogEntryType.ANTE, "Only basic lands found. Will ante one of them");

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

@@ -138,12 +138,12 @@ public class GameFormat implements Comparable<GameFormat> {
this.filterPrinted = this.buildFilterPrinted(); this.filterPrinted = this.buildFilterPrinted();
} }
protected Predicate<PaperCard> buildFilter(boolean printed) { protected Predicate<PaperCard> buildFilter(boolean printed) {
Predicate<PaperCard> p = Predicates.not(IPaperCard.Predicates.names(this.getBannedCardNames())); Predicate<PaperCard> p = IPaperCard.Predicates.names(this.getBannedCardNames()).negate();
if (FormatSubType.ARENA.equals(this.getFormatSubType())) { if (FormatSubType.ARENA.equals(this.getFormatSubType())) {
p = Predicates.and(p, Predicates.not(IPaperCard.Predicates.Presets.IS_UNREBALANCED)); p = Predicates.and(p, IPaperCard.Predicates.Presets.IS_UNREBALANCED.negate());
} else { } else {
p = Predicates.and(p, Predicates.not(IPaperCard.Predicates.Presets.IS_REBALANCED)); p = Predicates.and(p, IPaperCard.Predicates.Presets.IS_REBALANCED.negate());
} }
if (!this.getAllowedSetCodes().isEmpty()) { if (!this.getAllowedSetCodes().isEmpty()) {

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

@@ -1141,12 +1141,12 @@ public class ChangeZoneEffect extends SpellAbilityEffect {
for (int i = 0; i < changeNum && destination != null; i++) { for (int i = 0; i < changeNum && destination != null; i++) {
if (sa.hasParam("DifferentNames")) { if (sa.hasParam("DifferentNames")) {
for (Card c : chosenCards) { for (Card c : chosenCards) {
fetchList = CardLists.filter(fetchList, Predicates.not(CardPredicates.sharesNameWith(c))); fetchList = CardLists.filter(fetchList, CardPredicates.sharesNameWith(c).negate());
} }
} }
if (sa.hasParam("DifferentCMC")) { if (sa.hasParam("DifferentCMC")) {
for (Card c : chosenCards) { for (Card c : chosenCards) {
fetchList = CardLists.filter(fetchList, Predicates.not(CardPredicates.sharesCMCWith(c))); fetchList = CardLists.filter(fetchList, CardPredicates.sharesCMCWith(c).negate());
} }
} }
if (sa.hasParam("DifferentPower")) { if (sa.hasParam("DifferentPower")) {

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

@@ -219,7 +219,7 @@ public class CopyPermanentEffect extends TokenEffectBase {
if (choosen != null) { if (choosen != null) {
tgtCards.add(choosen); tgtCards.add(choosen);
choices = CardLists.filter(choices, Predicates.not(CardPredicates.sharesNameWith(choosen))); choices = CardLists.filter(choices, CardPredicates.sharesNameWith(choosen).negate());
} else if (chooser.getController().confirmAction(sa, PlayerActionConfirmMode.OptionalChoose, Localizer.getInstance().getMessage("lblCancelChooseConfirm"), null)) { } else if (chooser.getController().confirmAction(sa, PlayerActionConfirmMode.OptionalChoose, Localizer.getInstance().getMessage("lblCancelChooseConfirm"), null)) {
break; break;
} }

9
forge-game/src/main/java/forge/game/ability/effects/InternalRadiationEffect.java
View File

@@ -7,18 +7,13 @@ import com.google.common.collect.Maps;
import forge.game.Game; import forge.game.Game;
import forge.game.ability.AbilityKey; import forge.game.ability.AbilityKey;
import forge.game.ability.SpellAbilityEffect; import forge.game.ability.SpellAbilityEffect;
import forge.game.card.CardCollectionView; import forge.game.card.*;
import forge.game.card.CardLists;
import forge.game.card.CardPredicates;
import forge.game.card.CardZoneTable;
import forge.game.card.CounterEnumType;
import forge.game.player.Player; import forge.game.player.Player;
import forge.game.player.PlayerCollection; import forge.game.player.PlayerCollection;
import forge.game.spellability.SpellAbility; import forge.game.spellability.SpellAbility;
import forge.game.staticability.StaticAbilityGainLifeRadiation; import forge.game.staticability.StaticAbilityGainLifeRadiation;
import forge.game.trigger.TriggerType; import forge.game.trigger.TriggerType;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Predicates;
public class InternalRadiationEffect extends SpellAbilityEffect { public class InternalRadiationEffect extends SpellAbilityEffect {
@@ -34,7 +29,7 @@ public class InternalRadiationEffect extends SpellAbilityEffect {
final CardCollectionView milled = game.getAction().mill(new PlayerCollection(p), numRad, ZoneType.Graveyard, sa, moveParams); final CardCollectionView milled = game.getAction().mill(new PlayerCollection(p), numRad, ZoneType.Graveyard, sa, moveParams);
table.triggerChangesZoneAll(game, sa); table.triggerChangesZoneAll(game, sa);
int n = CardLists.count(milled, Predicates.not(CardPredicates.Presets.LANDS)); int n = CardLists.count(milled, CardPredicates.Presets.LANDS.negate());
if (StaticAbilityGainLifeRadiation.gainLifeRadiation(p)) { if (StaticAbilityGainLifeRadiation.gainLifeRadiation(p)) {
p.gainLife(n, sa.getHostCard(), sa); p.gainLife(n, sa.getHostCard(), sa);

2
forge-game/src/main/java/forge/game/card/Card.java
View File

@@ -3372,7 +3372,7 @@ public class Card extends GameEntity implements Comparable<Card>, IHasSVars {
// List only has nonMana // List only has nonMana
if (null == mana) { if (null == mana) {
List<SpellAbility> toRemove = Lists.newArrayList( List<SpellAbility> toRemove = Lists.newArrayList(
Iterables.filter(list, Predicates.not(SpellAbilityPredicates.isManaAbility()))); Iterables.filter(list, SpellAbilityPredicates.isManaAbility().negate()));
list.removeAll(toRemove); list.removeAll(toRemove);
} else if (false == mana) { } else if (false == mana) {
list.clear(); list.clear();

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

@@ -261,11 +261,11 @@ public class CardLists {
} }
public static CardCollection getNotKeyword(Iterable<Card> cardList, String keyword) { public static CardCollection getNotKeyword(Iterable<Card> cardList, String keyword) {
return CardLists.filter(cardList, Predicates.not(CardPredicates.hasKeyword(keyword))); return CardLists.filter(cardList, CardPredicates.hasKeyword(keyword).negate());
} }
public static CardCollection getNotKeyword(Iterable<Card> cardList, final Keyword keyword) { public static CardCollection getNotKeyword(Iterable<Card> cardList, final Keyword keyword) {
return CardLists.filter(cardList, Predicates.not(CardPredicates.hasKeyword(keyword))); return CardLists.filter(cardList, CardPredicates.hasKeyword(keyword).negate());
} }
public static int getAmountOfKeyword(final Iterable<Card> cardList, final String keyword) { public static int getAmountOfKeyword(final Iterable<Card> cardList, final String keyword) {
@@ -285,7 +285,7 @@ public class CardLists {
// cardType is like "Land" or "Goblin", returns a new CardCollection that is a // cardType is like "Land" or "Goblin", returns a new CardCollection that is a
// subset of current CardList // subset of current CardList
public static CardCollection getNotType(Iterable<Card> cardList, String cardType) { public static CardCollection getNotType(Iterable<Card> cardList, String cardType) {
return CardLists.filter(cardList, Predicates.not(CardPredicates.isType(cardType))); return CardLists.filter(cardList, CardPredicates.isType(cardType).negate());
} }
public static CardCollection getType(Iterable<Card> cardList, String cardType) { public static CardCollection getType(Iterable<Card> cardList, String cardType) {
@@ -293,7 +293,7 @@ public class CardLists {
} }
public static CardCollection getNotColor(Iterable<Card> cardList, byte color) { public static CardCollection getNotColor(Iterable<Card> cardList, byte color) {
return CardLists.filter(cardList, Predicates.not(CardPredicates.isColor(color))); return CardLists.filter(cardList, CardPredicates.isColor(color).negate());
} }
public static CardCollection getColor(Iterable<Card> cardList, byte color) { public static CardCollection getColor(Iterable<Card> cardList, byte color) {

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

@@ -24,7 +24,7 @@ public enum AttackRestrictionType {
return Predicates.and( return Predicates.and(
CardPredicates.isColor((byte) (MagicColor.BLACK | MagicColor.GREEN)), CardPredicates.isColor((byte) (MagicColor.BLACK | MagicColor.GREEN)),
// may explicitly not be black/green itself // may explicitly not be black/green itself
Predicates.not(attacker::equals)); ((Predicate<Card>) attacker::equals).negate());
case NOT_ALONE: case NOT_ALONE:
return x -> true; return x -> true;
default: default:

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

@@ -353,7 +353,7 @@ public class Player extends GameEntity implements Comparable<Player> {
* Should keep player relations somewhere in the match structure * Should keep player relations somewhere in the match structure
*/ */
public final PlayerCollection getAllies() { public final PlayerCollection getAllies() {
return getAllOtherPlayers().filter(Predicates.not(PlayerPredicates.isOpponentOf(this))); return getAllOtherPlayers().filter(PlayerPredicates.isOpponentOf(this).negate());
} }
public final PlayerCollection getTeamMates(final boolean inclThis) { public final PlayerCollection getTeamMates(final boolean inclThis) {

3
forge-game/src/main/java/forge/game/player/PlayerPredicates.java
View File

@@ -11,7 +11,6 @@ import forge.game.card.CounterEnumType;
import forge.game.card.CounterType; import forge.game.card.CounterType;
import forge.game.spellability.SpellAbility; import forge.game.spellability.SpellAbility;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Predicates;
public final class PlayerPredicates { public final class PlayerPredicates {
@@ -36,7 +35,7 @@ public final class PlayerPredicates {
} }
public static Predicate<Player> isNotCardInPlay(final String cardName) { public static Predicate<Player> isNotCardInPlay(final String cardName) {
return Predicates.not(isCardInPlay(cardName)); return isCardInPlay(cardName).negate();
} }
public static Predicate<Player> hasCounters() { public static Predicate<Player> hasCounters() {

5
forge-game/src/main/java/forge/game/staticability/StaticAbilityDisableTriggers.java
View File

@@ -8,10 +8,10 @@ import forge.game.ability.AbilityKey;
import forge.game.trigger.Trigger; import forge.game.trigger.Trigger;
import forge.game.trigger.TriggerType; import forge.game.trigger.TriggerType;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.Predicates;
import org.apache.commons.lang3.ArrayUtils; import org.apache.commons.lang3.ArrayUtils;
import java.util.Map; import java.util.Map;
import java.util.function.Predicate;
public class StaticAbilityDisableTriggers { public class StaticAbilityDisableTriggers {
@@ -108,7 +108,8 @@ public class StaticAbilityDisableTriggers {
CardCollection changers = cell.getValue(); CardCollection changers = cell.getValue();
if ((origin == null || cell.getRowKey() == ZoneType.valueOf(origin)) && if ((origin == null || cell.getRowKey() == ZoneType.valueOf(origin)) &&
(destination == null || cell.getColumnKey() == ZoneType.valueOf(destination))) { (destination == null || cell.getColumnKey() == ZoneType.valueOf(destination))) {
changers = CardLists.filter(changers, Predicates.not(CardPredicates.restriction(stAb.getParam("ValidCause").split(","), stAb.getHostCard().getController(), stAb.getHostCard(), stAb))); Predicate<Card> validCause = CardPredicates.restriction(stAb.getParam("ValidCause").split(","), stAb.getHostCard().getController(), stAb.getHostCard(), stAb);
changers = CardLists.filter(changers, validCause.negate());
// static will match some of the causes // static will match some of the causes
if (changers.size() < cell.getValue().size()) { if (changers.size() < cell.getValue().size()) {
possiblyDisabled = true; possiblyDisabled = true;

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

@@ -70,7 +70,7 @@ public enum CDeckgen implements ICDoc {
final Deck randomDeck = new Deck(); final Deck randomDeck = new Deck();
final Predicate<PaperCard> notBasicLand = Predicates.not(Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules)); final Predicate<PaperCard> notBasicLand = Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND, PaperCard::getRules).negate();
final Iterable<PaperCard> source = Iterables.filter(FModel.getMagicDb().getCommonCards().getUniqueCards(), notBasicLand); final Iterable<PaperCard> source = Iterables.filter(FModel.getMagicDb().getCommonCards().getUniqueCards(), notBasicLand);
randomDeck.getMain().addAllFlat(Aggregates.random(source, 15 * 5)); randomDeck.getMain().addAllFlat(Aggregates.random(source, 15 * 5));

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

@@ -481,7 +481,7 @@ public class EnemySprite extends CharacterSprite implements Steerable<Vector2> {
if(data.rewards != null) { //Collect standard rewards. if(data.rewards != null) { //Collect standard rewards.
Deck enemyDeck = Current.latestDeck(); Deck enemyDeck = Current.latestDeck();
// By popular demand, remove basic lands from the reward pool. // By popular demand, remove basic lands from the reward pool.
CardPool deckNoBasicLands = enemyDeck.getMain().getFilteredPool(Predicates.compose(Predicates.not(CardRulesPredicates.Presets.IS_BASIC_LAND), PaperCard::getRules)); CardPool deckNoBasicLands = enemyDeck.getMain().getFilteredPool(Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND.negate(), PaperCard::getRules));
for (RewardData rdata : data.rewards) { for (RewardData rdata : data.rewards) {
ret.addAll(rdata.generate(false, enemyDeck == null ? null : deckNoBasicLands.toFlatList(),true )); ret.addAll(rdata.generate(false, enemyDeck == null ? null : deckNoBasicLands.toFlatList(),true ));

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

@@ -74,7 +74,7 @@ public final class CardRelationMatrixGenerator {
true); true);
final Iterable<PaperCard> cards = Iterables.filter(format.getAllCards() final Iterable<PaperCard> cards = Iterables.filter(format.getAllCards()
, Predicates.compose(Predicates.not(CardRulesPredicates.Presets.IS_BASIC_LAND_NOT_WASTES), PaperCard::getRules)); , Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND_NOT_WASTES.negate(), PaperCard::getRules));
List<PaperCard> cardList = Lists.newArrayList(cards); List<PaperCard> cardList = Lists.newArrayList(cards);
cardList.add(FModel.getMagicDb().getCommonCards().getCard("Wastes")); cardList.add(FModel.getMagicDb().getCommonCards().getCard("Wastes"));
Map<String, Integer> cardIntegerMap = new HashMap<>(); Map<String, Integer> cardIntegerMap = new HashMap<>();
@@ -90,7 +90,7 @@ public final class CardRelationMatrixGenerator {
for (Deck deck:decks){ for (Deck deck:decks){
if (deck.getMain().contains(card)){ if (deck.getMain().contains(card)){
for (PaperCard pairCard:Iterables.filter(deck.getMain().toFlatList(), for (PaperCard pairCard:Iterables.filter(deck.getMain().toFlatList(),
Predicates.compose(Predicates.not(CardRulesPredicates.Presets.IS_BASIC_LAND_NOT_WASTES), PaperCard::getRules))){ Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND_NOT_WASTES.negate(), PaperCard::getRules))){
if (!pairCard.getName().equals(card.getName())){ if (!pairCard.getName().equals(card.getName())){
try { try {
int old = matrix[cardIntegerMap.get(card.getName())][cardIntegerMap.get(pairCard.getName())]; int old = matrix[cardIntegerMap.get(card.getName())][cardIntegerMap.get(pairCard.getName())];
@@ -143,7 +143,7 @@ public final class CardRelationMatrixGenerator {
//get all cards //get all cards
final Iterable<PaperCard> cards = Iterables.filter(FModel.getMagicDb().getCommonCards().getUniqueCards() final Iterable<PaperCard> cards = Iterables.filter(FModel.getMagicDb().getCommonCards().getUniqueCards()
, Predicates.compose(Predicates.not(CardRulesPredicates.Presets.IS_BASIC_LAND_NOT_WASTES), PaperCard::getRules)); , Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND_NOT_WASTES.negate(), PaperCard::getRules));
List<PaperCard> cardList = Lists.newArrayList(cards); List<PaperCard> cardList = Lists.newArrayList(cards);
cardList.add(FModel.getMagicDb().getCommonCards().getCard("Wastes")); cardList.add(FModel.getMagicDb().getCommonCards().getCard("Wastes"));
Map<String, Integer> cardIntegerMap = new HashMap<>(); Map<String, Integer> cardIntegerMap = new HashMap<>();
@@ -200,7 +200,7 @@ public final class CardRelationMatrixGenerator {
public static void updateLegendMatrix(Deck deck, PaperCard legend, Map<String, Integer> cardIntegerMap, public static void updateLegendMatrix(Deck deck, PaperCard legend, Map<String, Integer> cardIntegerMap,
Map<String, Integer> legendIntegerMap, int[][] matrix){ Map<String, Integer> legendIntegerMap, int[][] matrix){
for (PaperCard pairCard:Iterables.filter(deck.getMain().toFlatList(), for (PaperCard pairCard:Iterables.filter(deck.getMain().toFlatList(),
Predicates.compose(Predicates.not(CardRulesPredicates.Presets.IS_BASIC_LAND_NOT_WASTES), PaperCard::getRules))){ Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND_NOT_WASTES.negate(), PaperCard::getRules))){
if (!pairCard.getName().equals(legend.getName())){ if (!pairCard.getName().equals(legend.getName())){
try { try {
int old = matrix[legendIntegerMap.get(legend.getName())][cardIntegerMap.get(pairCard.getName())]; int old = matrix[legendIntegerMap.get(legend.getName())][cardIntegerMap.get(pairCard.getName())];

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

@@ -265,7 +265,7 @@ public class LimitedPlayerAI extends LimitedPlayer {
DeckGeneratorBase.MatchColorIdentity hasColor = new DeckGeneratorBase.MatchColorIdentity(colors); DeckGeneratorBase.MatchColorIdentity hasColor = new DeckGeneratorBase.MatchColorIdentity(colors);
Iterable<PaperCard> colorList = Iterables.filter(deckCards, Iterable<PaperCard> colorList = Iterables.filter(deckCards,
Predicates.not(Predicates.compose(hasColor, PaperCard::getRules))); Predicates.compose(hasColor, PaperCard::getRules).negate());
PaperCard exchangeCard = null; PaperCard exchangeCard = null;

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

@@ -11,7 +11,6 @@ import forge.deck.Deck;
import forge.item.PaperCard; import forge.item.PaperCard;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.Predicates;
public class WinstonDraft extends BoosterDraft { public class WinstonDraft extends BoosterDraft {
private WinstonDraftAI draftAI = null; private WinstonDraftAI draftAI = null;
@@ -41,7 +40,7 @@ public class WinstonDraft extends BoosterDraft {
for (final Supplier<List<PaperCard>> supply : this.product) { for (final Supplier<List<PaperCard>> supply : this.product) {
for (int j = 0; j < NUM_PLAYERS; j++) { for (int j = 0; j < NUM_PLAYERS; j++) {
// Remove Basic Lands from draft for simplicity // Remove Basic Lands from draft for simplicity
for (final PaperCard paperCard : Iterables.filter(supply.get(), Predicates.not(PaperCard.Predicates.Presets.IS_BASIC_LAND))) { for (final PaperCard paperCard : Iterables.filter(supply.get(), PaperCard.Predicates.Presets.IS_BASIC_LAND.negate())) {
this.deck.add(paperCard); this.deck.add(paperCard);
} }
} }

5
forge-gui/src/main/java/forge/gamemodes/net/server/FServerManager.java
View File

@@ -11,7 +11,6 @@ import forge.gui.interfaces.IGuiGame;
import forge.interfaces.IGameController; import forge.interfaces.IGameController;
import forge.interfaces.ILobbyListener; import forge.interfaces.ILobbyListener;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.Predicates;
import io.netty.bootstrap.ServerBootstrap; import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*; import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup;
@@ -33,6 +32,7 @@ import java.util.Collection;
import java.util.Collections; import java.util.Collections;
import java.util.Enumeration; import java.util.Enumeration;
import java.util.Map; import java.util.Map;
import java.util.function.Predicate;
public final class FServerManager { public final class FServerManager {
private static FServerManager instance = null; private static FServerManager instance = null;
@@ -147,7 +147,8 @@ public final class FServerManager {
broadcastExcept(event, Collections.singleton(notTo)); broadcastExcept(event, Collections.singleton(notTo));
} }
public void broadcastExcept(final NetEvent event, final Collection<RemoteClient> notTo) { public void broadcastExcept(final NetEvent event, final Collection<RemoteClient> notTo) {
broadcastTo(event, Iterables.filter(clients.values(), Predicates.not(notTo::contains))); Predicate<RemoteClient> filter = ((Predicate<RemoteClient>) notTo::contains).negate();
broadcastTo(event, Iterables.filter(clients.values(), filter));
} }
private void broadcastTo(final NetEvent event, final Iterable<RemoteClient> to) { private void broadcastTo(final NetEvent event, final Iterable<RemoteClient> to) {
for (final RemoteClient client : to) { for (final RemoteClient client : to) {

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

@@ -77,15 +77,15 @@ public final class BoosterUtils {
private static final Predicate<CardEdition> filterPioneerNotStandard = Predicates.and( private static final Predicate<CardEdition> filterPioneerNotStandard = Predicates.and(
CardEdition.Predicates.CAN_MAKE_BOOSTER, CardEdition.Predicates.CAN_MAKE_BOOSTER,
Predicates.and(filterPioneer, Predicates.not(formats.getStandard().editionLegalPredicate))); Predicates.and(filterPioneer, formats.getStandard().editionLegalPredicate.negate()));
private static final Predicate<CardEdition> filterModernNotPioneer = Predicates.and( private static final Predicate<CardEdition> filterModernNotPioneer = Predicates.and(
CardEdition.Predicates.CAN_MAKE_BOOSTER, CardEdition.Predicates.CAN_MAKE_BOOSTER,
Predicates.and(filterModern, Predicates.not(filterPioneer))); Predicates.and(filterModern, filterPioneer.negate()));
/** The filter not ext. */ /** The filter not ext. */
private static final Predicate<CardEdition> filterNotModern = Predicates.and(CardEdition.Predicates.CAN_MAKE_BOOSTER, private static final Predicate<CardEdition> filterNotModern = Predicates.and(CardEdition.Predicates.CAN_MAKE_BOOSTER,
Predicates.not(filterModern)); filterModern.negate());
/** /**
* Gets the quest starter deck. * Gets the quest starter deck.

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

@@ -1574,7 +1574,7 @@ public class AdvancedSearch {
predPiece = ((AdvancedSearch.Filter<T>) piece).getPredicate(); predPiece = ((AdvancedSearch.Filter<T>) piece).getPredicate();
} }
if (applyNot) { if (applyNot) {
predPiece = Predicates.not(predPiece); predPiece = predPiece.negate();
applyNot = false; applyNot = false;
} }
if (pred == null) { if (pred == null) {

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

@@ -133,7 +133,7 @@ public class BooleanExpression {
case NOT: case NOT:
operators.pop(); operators.pop();
left = operands.pop(); left = operands.pop();
operands.push(Predicates.not(left)); operands.push(left.negate());
break; break;
default: default:
if (alwaysPopOperator) { if (alwaysPopOperator) {

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

@@ -50,7 +50,7 @@ public class SFilterUtil {
try { try {
Predicate<CardRules> filter = expression.evaluate(); Predicate<CardRules> filter = expression.evaluate();
if (filter != null) { if (filter != null) {
return Predicates.compose(invert ? Predicates.not(filter) : filter, PaperCard::getRules); return Predicates.compose(invert ? filter.negate() : filter, PaperCard::getRules);
} }
} }
catch (Exception ignored) { catch (Exception ignored) {
@@ -71,7 +71,8 @@ public class SFilterUtil {
terms.add(Predicates.or(subands)); terms.add(Predicates.or(subands));
} }
Predicate<CardRules> textFilter = invert ? Predicates.not(Predicates.or(terms)) : Predicates.and(terms); Predicate<CardRules> textFilter;
textFilter = invert ? Predicates.or(terms).negate() : Predicates.and(terms);
return Predicates.compose(textFilter, PaperCard::getRules); return Predicates.compose(textFilter, PaperCard::getRules);
} }

3
forge-gui/src/main/java/forge/localinstance/achievements/AgainstAllOdds.java
View File

@@ -6,7 +6,6 @@ import forge.game.player.PlayerCollection;
import forge.game.player.PlayerPredicates; import forge.game.player.PlayerPredicates;
import forge.util.Iterables; import forge.util.Iterables;
import forge.util.Localizer; import forge.util.Localizer;
import forge.util.Predicates;
public class AgainstAllOdds extends Achievement { public class AgainstAllOdds extends Achievement {
public AgainstAllOdds() { public AgainstAllOdds() {
@@ -28,7 +27,7 @@ public class AgainstAllOdds extends Achievement {
otherOpps.remove(opp); otherOpps.remove(opp);
if (Iterables.all(otherOpps, PlayerPredicates.sameTeam(opp))) { if (Iterables.all(otherOpps, PlayerPredicates.sameTeam(opp))) {
teamNum++; teamNum++;
} else if (Iterables.all(otherOpps, Predicates.not(PlayerPredicates.sameTeam(opp)))) { } else if (Iterables.all(otherOpps, PlayerPredicates.sameTeam(opp).negate())) {
teamNum--; teamNum--;
} }
} }

4
forge-gui/src/main/java/forge/player/HumanCostDecision.java
View File

@@ -123,7 +123,7 @@ public class HumanCostDecision extends CostDecisionMakerBase {
} }
final Card first = inp.getFirstSelected(); final Card first = inp.getFirstSelected();
discarded.add(first); discarded.add(first);
hand = CardLists.filter(hand, Predicates.not(CardPredicates.sharesNameWith(first))); hand = CardLists.filter(hand, CardPredicates.sharesNameWith(first).negate());
c--; c--;
} }
return PaymentDecision.card(discarded); return PaymentDecision.card(discarded);
@@ -1182,7 +1182,7 @@ public class HumanCostDecision extends CostDecisionMakerBase {
} }
final Card first = inp.getFirstSelected(); final Card first = inp.getFirstSelected();
chosen.add(first); chosen.add(first);
list = CardLists.filter(list, Predicates.not(CardPredicates.sharesNameWith(first))); list = CardLists.filter(list, CardPredicates.sharesNameWith(first).negate());
c--; c--;
} }
return PaymentDecision.card(chosen); return PaymentDecision.card(chosen);

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

@@ -291,7 +291,7 @@ public final class LDAModelGenetrator {
//get all cards //get all cards
final Iterable<PaperCard> cards = Iterables.filter(FModel.getMagicDb().getCommonCards().getUniqueCards() final Iterable<PaperCard> cards = Iterables.filter(FModel.getMagicDb().getCommonCards().getUniqueCards()
, Predicates.compose(Predicates.not(CardRulesPredicates.Presets.IS_BASIC_LAND_NOT_WASTES), PaperCard::getRules)); , Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND_NOT_WASTES.negate(), PaperCard::getRules));
List<PaperCard> cardList = Lists.newArrayList(cards); List<PaperCard> cardList = Lists.newArrayList(cards);
cardList.add(FModel.getMagicDb().getCommonCards().getCard("Wastes")); cardList.add(FModel.getMagicDb().getCommonCards().getCard("Wastes"));
Map<String, Integer> cardIntegerMap = new HashMap<>(); Map<String, Integer> cardIntegerMap = new HashMap<>();
@@ -350,7 +350,7 @@ public final class LDAModelGenetrator {
public static void updateLegendMatrix(Deck deck, PaperCard legend, Map<String, Integer> cardIntegerMap, public static void updateLegendMatrix(Deck deck, PaperCard legend, Map<String, Integer> cardIntegerMap,
Map<String, Integer> legendIntegerMap, int[][] matrix){ Map<String, Integer> legendIntegerMap, int[][] matrix){
for (PaperCard pairCard:Iterables.filter(deck.getMain().toFlatList(), for (PaperCard pairCard:Iterables.filter(deck.getMain().toFlatList(),
Predicates.compose(Predicates.not(CardRulesPredicates.Presets.IS_BASIC_LAND_NOT_WASTES), PaperCard::getRules))){ Predicates.compose(CardRulesPredicates.Presets.IS_BASIC_LAND_NOT_WASTES.negate(), PaperCard::getRules))){
if (!pairCard.getName().equals(legend.getName())){ if (!pairCard.getName().equals(legend.getName())){
try { try {
int old = matrix[legendIntegerMap.get(legend.getName())][cardIntegerMap.get(pairCard.getName())]; int old = matrix[legendIntegerMap.get(legend.getName())][cardIntegerMap.get(pairCard.getName())];