mirror of
https://github.com/Card-Forge/forge.git
synced 2025-11-17 19:28:01 +00:00
Predicate: isTrue renamed to apply, this class now implements com.google.common.base.Predicate (Guava iterables may use them now)
This commit is contained in:
@@ -235,7 +235,7 @@ public abstract class AllZoneUtil {
|
||||
CardList cards = player.getCardsIn(ZoneType.Battlefield);
|
||||
cards = cards.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
final List<String> colorList = CardUtil.getColors(c);
|
||||
return colorList.contains(color);
|
||||
}
|
||||
|
||||
@@ -21,6 +21,8 @@ import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.Comparator;
|
||||
|
||||
import com.google.common.collect.Iterables;
|
||||
|
||||
import forge.card.spellability.SpellAbility;
|
||||
import forge.game.player.Player;
|
||||
import forge.util.MyRandom;
|
||||
@@ -148,7 +150,7 @@ public class CardList extends ArrayList<Card> {
|
||||
public final CardList getValidCards(final String[] restrictions, final Player sourceController, final Card source) {
|
||||
return this.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (c != null) && c.isValid(restrictions, sourceController, source);
|
||||
}
|
||||
});
|
||||
|
||||
@@ -47,7 +47,7 @@ public class CardListUtil {
|
||||
return in.filter(
|
||||
new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.getNetDefense() <= atLeastToughness;
|
||||
}
|
||||
}
|
||||
@@ -202,7 +202,7 @@ public class CardListUtil {
|
||||
public static CardList getColor(final CardList list, final String color) {
|
||||
return list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return CardUtil.getColors(c).contains(color);
|
||||
}
|
||||
});
|
||||
@@ -220,7 +220,7 @@ public class CardListUtil {
|
||||
public static CardList getGoldCards(final CardList list) {
|
||||
return list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return CardUtil.getColors(c).size() >= 2;
|
||||
}
|
||||
});
|
||||
|
||||
@@ -37,7 +37,7 @@ public final class CardPredicates {
|
||||
public static Predicate<Card> isController(final Player p) {
|
||||
return new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getController().isPlayer(p);
|
||||
}
|
||||
};
|
||||
@@ -45,7 +45,7 @@ public final class CardPredicates {
|
||||
public static Predicate<Card> isOwner(final Player p) {
|
||||
return new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getOwner().isPlayer(p);
|
||||
}
|
||||
};
|
||||
@@ -54,7 +54,7 @@ public final class CardPredicates {
|
||||
public static Predicate<Card> isType(final String cardType) {
|
||||
return new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.isType(cardType);
|
||||
}
|
||||
};
|
||||
@@ -63,7 +63,7 @@ public final class CardPredicates {
|
||||
public static Predicate<Card> hasKeyword(final String keyword) {
|
||||
return new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.hasKeyword(keyword);
|
||||
}
|
||||
};
|
||||
@@ -72,7 +72,7 @@ public final class CardPredicates {
|
||||
public static Predicate<Card> containsKeyword(final String keyword) {
|
||||
return new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return PredicateString.contains(keyword).any(c.getKeyword());
|
||||
}
|
||||
};
|
||||
@@ -81,7 +81,7 @@ public final class CardPredicates {
|
||||
public static Predicate<Card> isTargetableBy(final SpellAbility source) {
|
||||
return new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return source.canTarget(c);
|
||||
}
|
||||
};
|
||||
@@ -90,7 +90,7 @@ public final class CardPredicates {
|
||||
public static Predicate<Card> nameEquals(final String name) {
|
||||
return new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.getName().equals(name);
|
||||
}
|
||||
};
|
||||
@@ -100,7 +100,7 @@ public final class CardPredicates {
|
||||
public static Predicate<Card> possibleBlockers(final Card attacker) {
|
||||
return new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (c.isCreature() && CombatUtil.canBlock(attacker, c));
|
||||
}
|
||||
};
|
||||
@@ -108,7 +108,7 @@ public final class CardPredicates {
|
||||
|
||||
public static final Predicate<Card> possibleAttackers = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (c.isCreature() && CombatUtil.canAttack(c));
|
||||
}
|
||||
};
|
||||
@@ -116,7 +116,7 @@ public final class CardPredicates {
|
||||
public static Predicate<Card> isProtectedFrom(final Card source) {
|
||||
return new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !c.hasProtectionFrom(source);
|
||||
}
|
||||
};
|
||||
@@ -130,7 +130,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> TAPPED = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.isTapped();
|
||||
}
|
||||
};
|
||||
@@ -139,7 +139,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> UNTAPPED = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.isUntapped();
|
||||
}
|
||||
};
|
||||
@@ -148,7 +148,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> CREATURES = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.isCreature();
|
||||
}
|
||||
};
|
||||
@@ -157,7 +157,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> ENCHANTMENTS = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.isEnchantment();
|
||||
}
|
||||
};
|
||||
@@ -166,7 +166,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> EQUIPMENT = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.isEquipment();
|
||||
}
|
||||
};
|
||||
@@ -175,7 +175,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> UNENCHANTED = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return !c.isEnchanted();
|
||||
}
|
||||
};
|
||||
@@ -184,7 +184,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> ENCHANTED = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.isEnchanted();
|
||||
}
|
||||
};
|
||||
@@ -193,7 +193,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> NON_TOKEN = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return !c.isToken();
|
||||
}
|
||||
};
|
||||
@@ -202,7 +202,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> TOKEN = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.isToken();
|
||||
}
|
||||
};
|
||||
@@ -211,7 +211,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> NON_BASIC_LAND = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return !c.isBasicLand();
|
||||
}
|
||||
};
|
||||
@@ -220,7 +220,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> BASIC_LANDS = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
// the isBasicLand() check here may be sufficient...
|
||||
return c.isLand() && c.isBasicLand();
|
||||
}
|
||||
@@ -230,7 +230,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> ARTIFACTS = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.isArtifact();
|
||||
}
|
||||
};
|
||||
@@ -239,7 +239,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> NON_ARTIFACTS = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return !c.isArtifact();
|
||||
}
|
||||
};
|
||||
@@ -248,7 +248,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> LANDS = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.isLand();
|
||||
}
|
||||
};
|
||||
@@ -257,7 +257,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> NON_LANDS = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return !c.isLand();
|
||||
}
|
||||
};
|
||||
@@ -266,7 +266,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> BLACK = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.isBlack();
|
||||
}
|
||||
};
|
||||
@@ -275,7 +275,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> BLUE = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.isBlue();
|
||||
}
|
||||
};
|
||||
@@ -284,7 +284,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> GREEN = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.isGreen();
|
||||
}
|
||||
};
|
||||
@@ -293,7 +293,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> RED = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.isRed();
|
||||
}
|
||||
};
|
||||
@@ -302,7 +302,7 @@ public final class CardPredicates {
|
||||
*/
|
||||
public static final Predicate<Card> WHITE = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.isWhite();
|
||||
}
|
||||
};
|
||||
@@ -310,13 +310,13 @@ public final class CardPredicates {
|
||||
|
||||
public static final Predicate<Card> hasFirstStrike = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.isCreature() && (c.hasFirstStrike() || c.hasDoubleStrike());
|
||||
}
|
||||
};
|
||||
public static final Predicate<Card> hasSecondStrike = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(Card c) {
|
||||
public boolean apply(Card c) {
|
||||
return c.isCreature() && (!c.hasFirstStrike() || c.hasDoubleStrike());
|
||||
}
|
||||
};
|
||||
|
||||
@@ -458,7 +458,7 @@ public final class CardUtil {
|
||||
final String set = card.getCurSetCode();
|
||||
final Predicate<EditionInfo> findSetInfo = new Predicate<EditionInfo>() {
|
||||
@Override
|
||||
public boolean isTrue(final EditionInfo subject) {
|
||||
public boolean apply(final EditionInfo subject) {
|
||||
return subject.getCode().equals(set);
|
||||
}
|
||||
};
|
||||
|
||||
@@ -1258,7 +1258,7 @@ public class GameAction {
|
||||
b = b.getType("Legendary");
|
||||
b = b.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !c.isFaceDown();
|
||||
}
|
||||
});
|
||||
@@ -1320,7 +1320,7 @@ public class GameAction {
|
||||
CardList list = new CardList(c.getEnchantedBy());
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card crd) {
|
||||
public boolean apply(final Card crd) {
|
||||
return crd.hasKeyword("Totem armor");
|
||||
}
|
||||
});
|
||||
@@ -1503,7 +1503,7 @@ public class GameAction {
|
||||
CardList list = new CardList(c.getEnchantedBy());
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card crd) {
|
||||
public boolean apply(final Card crd) {
|
||||
return crd.hasKeyword("Totem armor");
|
||||
}
|
||||
});
|
||||
@@ -1773,7 +1773,7 @@ public class GameAction {
|
||||
CardList untappedCreats = spell.getActivatingPlayer().getCardsIn(ZoneType.Battlefield).getType("Creature");
|
||||
untappedCreats = untappedCreats.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !c.isTapped();
|
||||
}
|
||||
});
|
||||
|
||||
@@ -1305,7 +1305,7 @@ public final class GameActionUtil {
|
||||
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getName().equals("Avatar") && c.getImageName().equals("W N N Avatar");
|
||||
}
|
||||
});
|
||||
@@ -1367,7 +1367,7 @@ public final class GameActionUtil {
|
||||
CardList list = c.getController().getCardsIn(ZoneType.Battlefield);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getName().equals("Guan Yu, Sainted Warrior")
|
||||
|| c.getName().equals("Zhang Fei, Fierce Warrior");
|
||||
}
|
||||
@@ -1387,7 +1387,7 @@ public final class GameActionUtil {
|
||||
CardList list = AllZoneUtil.getCardsIn(ZoneType.Battlefield);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getName().equals("Wolf")
|
||||
&& c.hasKeyword("This creature gets +1/+1 for each card "
|
||||
+ "named Sound the Call in each graveyard.");
|
||||
@@ -1517,7 +1517,7 @@ public final class GameActionUtil {
|
||||
CardList lands = AllZoneUtil.getPlayerLandsInPlay(p);
|
||||
lands = lands.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getManaAbility().size() > 0;
|
||||
}
|
||||
});
|
||||
|
||||
@@ -186,7 +186,7 @@ public final class CardEdition implements Comparable<CardEdition> { // immutable
|
||||
|
||||
private static class CanMakeBooster extends Predicate<CardEdition> {
|
||||
@Override
|
||||
public boolean isTrue(final CardEdition subject) {
|
||||
public boolean apply(final CardEdition subject) {
|
||||
return Singletons.getModel().getBoosters().contains(subject.getCode());
|
||||
}
|
||||
}
|
||||
@@ -194,7 +194,7 @@ public final class CardEdition implements Comparable<CardEdition> { // immutable
|
||||
public static final Predicate<CardEdition> HAS_TOURNAMENT_PACK = new CanMakeStarter();
|
||||
private static class CanMakeStarter extends Predicate<CardEdition> {
|
||||
@Override
|
||||
public boolean isTrue(final CardEdition subject) {
|
||||
public boolean apply(final CardEdition subject) {
|
||||
return Singletons.getModel().getTournamentPacks().contains(subject.getCode());
|
||||
}
|
||||
}
|
||||
@@ -202,7 +202,7 @@ public final class CardEdition implements Comparable<CardEdition> { // immutable
|
||||
public static final Predicate<CardEdition> HAS_FAT_PACK = new CanMakeFatPack();
|
||||
private static class CanMakeFatPack extends Predicate<CardEdition> {
|
||||
@Override
|
||||
public boolean isTrue(final CardEdition subject) {
|
||||
public boolean apply(final CardEdition subject) {
|
||||
return Singletons.getModel().getFatPacks().contains(subject.getCode());
|
||||
}
|
||||
}
|
||||
@@ -225,7 +225,7 @@ public final class CardEdition implements Comparable<CardEdition> { // immutable
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final CardEdition subject) {
|
||||
public boolean apply(final CardEdition subject) {
|
||||
return this.format.isSetLegal(subject.getCode());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -399,7 +399,7 @@ public final class CardRules {
|
||||
/** The Constant isKeptInAiDecks. */
|
||||
public static final Predicate<CardRules> IS_KEPT_IN_AI_DECKS = new Predicate<CardRules>() {
|
||||
@Override
|
||||
public boolean isTrue(final CardRules card) {
|
||||
public boolean apply(final CardRules card) {
|
||||
return !card.isRemovedFromAIDecks;
|
||||
}
|
||||
};
|
||||
@@ -407,7 +407,7 @@ public final class CardRules {
|
||||
/** The Constant isKeptInRandomDecks. */
|
||||
public static final Predicate<CardRules> IS_KEPT_IN_RANDOM_DECKS = new Predicate<CardRules>() {
|
||||
@Override
|
||||
public boolean isTrue(final CardRules card) {
|
||||
public boolean apply(final CardRules card) {
|
||||
return !card.isRemovedFromRandomDecks;
|
||||
}
|
||||
};
|
||||
@@ -525,7 +525,7 @@ public final class CardRules {
|
||||
public static Predicate<CardRules> hasKeyword(final String keyword) {
|
||||
return new Predicate<CardRules>() {
|
||||
@Override
|
||||
public boolean isTrue(final CardRules card) {
|
||||
public boolean apply(final CardRules card) {
|
||||
return card.getKeywords().contains(keyword);
|
||||
}
|
||||
};
|
||||
@@ -668,7 +668,7 @@ public final class CardRules {
|
||||
private final CardField field;
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final CardRules card) {
|
||||
public boolean apply(final CardRules card) {
|
||||
boolean shouldContain;
|
||||
switch (this.field) {
|
||||
case NAME:
|
||||
@@ -709,7 +709,7 @@ public final class CardRules {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final CardRules subject) {
|
||||
public boolean apply(final CardRules subject) {
|
||||
switch (this.op) {
|
||||
case CountColors:
|
||||
return subject.getColor().countColors() == this.color;
|
||||
@@ -743,7 +743,7 @@ public final class CardRules {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final CardRules card) {
|
||||
public boolean apply(final CardRules card) {
|
||||
int value;
|
||||
switch (this.field) {
|
||||
case CMC:
|
||||
@@ -784,7 +784,7 @@ public final class CardRules {
|
||||
private final boolean shouldBeEqual;
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final CardRules card) {
|
||||
public boolean apply(final CardRules card) {
|
||||
return this.shouldBeEqual == card.getType().typeContains(this.operand);
|
||||
}
|
||||
|
||||
@@ -799,7 +799,7 @@ public final class CardRules {
|
||||
private final boolean shouldBeEqual;
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final CardRules card) {
|
||||
public boolean apply(final CardRules card) {
|
||||
return this.shouldBeEqual == card.getType().superTypeContains(this.operand);
|
||||
}
|
||||
|
||||
@@ -814,7 +814,7 @@ public final class CardRules {
|
||||
private final boolean shouldBeEqual;
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final CardRules card) {
|
||||
public boolean apply(final CardRules card) {
|
||||
return card.getRarityFromLatestSet().equals(this.operand) == this.shouldBeEqual;
|
||||
}
|
||||
|
||||
@@ -832,7 +832,7 @@ public final class CardRules {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final CardRules subject) {
|
||||
public boolean apply(final CardRules subject) {
|
||||
for (final String s : this.sets) {
|
||||
if (subject.setsPrinted.containsKey(s)) {
|
||||
return true;
|
||||
@@ -859,7 +859,7 @@ public final class CardRules {
|
||||
/** The Constant isBasicLand. */
|
||||
public static final Predicate<CardRules> IS_BASIC_LAND = new Predicate<CardRules>() {
|
||||
@Override
|
||||
public boolean isTrue(final CardRules subject) {
|
||||
public boolean apply(final CardRules subject) {
|
||||
return subject.getType().isBasicLand();
|
||||
}
|
||||
};
|
||||
|
||||
@@ -501,7 +501,7 @@ public class AbilityFactoryAttach {
|
||||
if (sa.getSourceCard().getName().equals("Animate Artifact")) {
|
||||
betterList = betterList.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getCMC() > 0;
|
||||
}
|
||||
});
|
||||
@@ -693,7 +693,7 @@ public class AbilityFactoryAttach {
|
||||
stCheck = "EnchantedBy";
|
||||
magnetList = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if ( !c.isCreature() ) return false;
|
||||
String sVar = c.getSVar("EnchantMe");
|
||||
return sVar.equals("Multiple") || (sVar.equals("Once") && !c.isEnchanted());
|
||||
@@ -703,7 +703,7 @@ public class AbilityFactoryAttach {
|
||||
stCheck = "EquippedBy";
|
||||
magnetList = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if ( !c.isCreature() ) return false;
|
||||
String sVar = c.getSVar("EquipMe");
|
||||
return sVar.equals("Multiple") || (sVar.equals("Once") && !c.isEquipped());
|
||||
@@ -718,7 +718,7 @@ public class AbilityFactoryAttach {
|
||||
|
||||
magnetList = magnetList.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return CombatUtil.canAttack(c);
|
||||
}
|
||||
});
|
||||
@@ -770,7 +770,7 @@ public class AbilityFactoryAttach {
|
||||
final int tgh = totToughness;
|
||||
prefList = prefList.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getLethalDamage() > Math.abs(tgh);
|
||||
}
|
||||
});
|
||||
@@ -780,7 +780,7 @@ public class AbilityFactoryAttach {
|
||||
if (totToughness + totPower < 4 && !keywords.isEmpty()) {
|
||||
prefList = prefList.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return containsUsefulKeyword(keywords, c, sa);
|
||||
}
|
||||
});
|
||||
@@ -789,7 +789,7 @@ public class AbilityFactoryAttach {
|
||||
// Don't pump cards that will die.
|
||||
prefList = prefList.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !c.getSVar("Targeting").equals("Dies");
|
||||
}
|
||||
});
|
||||
@@ -805,7 +805,7 @@ public class AbilityFactoryAttach {
|
||||
// Filter out creatures that can't Attack or have Defender
|
||||
prefList = prefList.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !c.isCreature() || CombatUtil.canAttackNextTurn(c);
|
||||
}
|
||||
});
|
||||
@@ -888,7 +888,7 @@ public class AbilityFactoryAttach {
|
||||
final int tgh = totToughness;
|
||||
prefList = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (!c.hasKeyword("Indestructible") && (c.getLethalDamage() <= Math.abs(tgh))) {
|
||||
return true;
|
||||
}
|
||||
@@ -914,7 +914,7 @@ public class AbilityFactoryAttach {
|
||||
|| keywords.contains("CARDNAME attacks each turn if able.")) {
|
||||
prefList = prefList.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !(c.hasKeyword("CARDNAME can't attack.") || c.hasKeyword("Defender"));
|
||||
}
|
||||
});
|
||||
@@ -992,7 +992,7 @@ public class AbilityFactoryAttach {
|
||||
// AI For Cards like Paralyzing Grasp and Glimmerdust Nap
|
||||
final CardList prefList = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
// Don't do Untapped Vigilance cards
|
||||
if (c.isCreature() && c.hasKeyword("Vigilance") && c.isUntapped()) {
|
||||
return false;
|
||||
|
||||
@@ -1169,7 +1169,7 @@ public final class AbilityFactoryChangeZone {
|
||||
if (ZoneType.Battlefield.equals(destination)) {
|
||||
fetchList = fetchList.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (c.isType("Legendary")) {
|
||||
if (!AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield, c.getName()).isEmpty()) {
|
||||
return false;
|
||||
@@ -1181,7 +1181,7 @@ public final class AbilityFactoryChangeZone {
|
||||
if (player.isHuman() && params.containsKey("GainControl")) {
|
||||
fetchList = fetchList.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (!c.getSVar("RemAIDeck").equals("") || !c.getSVar("RemRandomDeck").equals("")) {
|
||||
return false;
|
||||
}
|
||||
@@ -1664,7 +1664,7 @@ public final class AbilityFactoryChangeZone {
|
||||
// Don't blink cards that will die.
|
||||
aiPermanents = aiPermanents.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !c.getSVar("Targeting").equals("Dies");
|
||||
}
|
||||
});
|
||||
@@ -1709,7 +1709,7 @@ public final class AbilityFactoryChangeZone {
|
||||
else if (sa.isAbility() && (sa.getPayCosts() != null) && AbilityFactory.playReusable(sa)) {
|
||||
aiPermanents = aiPermanents.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (c.getNumberOfCounters() > 0) {
|
||||
return false; // don't blink something with
|
||||
}
|
||||
@@ -1758,7 +1758,7 @@ public final class AbilityFactoryChangeZone {
|
||||
list = list.getController(AllZone.getHumanPlayer());
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
for (Card aura : c.getEnchantedBy()) {
|
||||
if (c.getOwner().isHuman() && aura.getController().isComputer()) {
|
||||
return false;
|
||||
|
||||
@@ -1062,7 +1062,7 @@ public final class AbilityFactoryCombat {
|
||||
list = list.getValidCards(abTgt.getValidTgts(), source.getController(), source);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
boolean tapped = c.isTapped();
|
||||
c.setTapped(false);
|
||||
if (!CombatUtil.canBlock(definedAttacker, c)) {
|
||||
|
||||
@@ -312,7 +312,7 @@ public class AbilityFactoryCounters {
|
||||
list = player.getCardsIn(ZoneType.Battlefield);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.canBeTargetedBy(sa) && !c.hasKeyword("CARDNAME can't have counters placed on it.")
|
||||
&& !(c.hasKeyword("CARDNAME can't have -1/-1 counters placed on it.") && type.equals("M1M1"));
|
||||
}
|
||||
@@ -476,7 +476,7 @@ public class AbilityFactoryCounters {
|
||||
while (abTgt.getNumTargeted() < abTgt.getMaxTargets(sa.getSourceCard(), sa)) {
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return sa.canTarget(c);
|
||||
}
|
||||
});
|
||||
@@ -658,7 +658,7 @@ public class AbilityFactoryCounters {
|
||||
// try to kill the best killable creature, or reduce the best one
|
||||
final CardList killable = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getNetDefense() <= amount;
|
||||
}
|
||||
});
|
||||
@@ -692,7 +692,7 @@ public class AbilityFactoryCounters {
|
||||
} else if (type.equals("DIVINITY")) {
|
||||
final CardList boon = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getCounters(Counters.DIVINITY) == 0;
|
||||
}
|
||||
});
|
||||
@@ -1447,7 +1447,7 @@ public class AbilityFactoryCounters {
|
||||
CardList cperms = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
|
||||
cperms = cperms.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card crd) {
|
||||
public boolean apply(final Card crd) {
|
||||
for (final Counters c1 : Counters.values()) {
|
||||
if (crd.getCounters(c1) != 0 && !CardFactoryUtil.isNegativeCounter(c1)) {
|
||||
return true;
|
||||
@@ -1459,7 +1459,7 @@ public class AbilityFactoryCounters {
|
||||
|
||||
hperms = hperms.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card crd) {
|
||||
public boolean apply(final Card crd) {
|
||||
for (final Counters c1 : Counters.values()) {
|
||||
if (crd.getCounters(c1) != 0 && CardFactoryUtil.isNegativeCounter(c1)) {
|
||||
return true;
|
||||
@@ -1575,7 +1575,7 @@ public class AbilityFactoryCounters {
|
||||
} else { // Compy
|
||||
cperms = cperms.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card crd) {
|
||||
public boolean apply(final Card crd) {
|
||||
for (final Counters c1 : Counters.values()) {
|
||||
if (crd.getCounters(c1) != 0) {
|
||||
if (!CardFactoryUtil.isNegativeCounter(c1)) {
|
||||
@@ -1589,7 +1589,7 @@ public class AbilityFactoryCounters {
|
||||
|
||||
hperms = hperms.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card crd) {
|
||||
public boolean apply(final Card crd) {
|
||||
for (final Counters c1 : Counters.values()) {
|
||||
if (crd.getCounters(c1) != 0) {
|
||||
if (CardFactoryUtil.isNegativeCounter(c1)) {
|
||||
@@ -1918,7 +1918,7 @@ public class AbilityFactoryCounters {
|
||||
if (type.equals("M1M1")) {
|
||||
final CardList killable = hList.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getNetDefense() <= amount;
|
||||
}
|
||||
});
|
||||
|
||||
@@ -536,7 +536,7 @@ public class AbilityFactoryDealDamage {
|
||||
|
||||
final CardList killables = hPlay.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (c.getEnoughDamageToKill(d, source, false, noPrevention) <= d) && !ComputerUtil.canRegenerate(c)
|
||||
&& !(c.getSVar("SacMe").length() > 0);
|
||||
}
|
||||
@@ -1233,7 +1233,7 @@ public class AbilityFactoryDealDamage {
|
||||
|
||||
final Predicate<Card> filterKillable = new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (c.predictDamage(dmg, source, false) >= c.getKillDamage());
|
||||
}
|
||||
};
|
||||
@@ -1865,7 +1865,7 @@ public class AbilityFactoryDealDamage {
|
||||
aiCreatures = aiCreatures.getTargetableCards(sa);
|
||||
aiCreatures = aiCreatures.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !c.getSVar("Targeting").equals("Dies");
|
||||
}
|
||||
});
|
||||
|
||||
@@ -450,7 +450,7 @@ public final class AbilityFactoryDebuff {
|
||||
if (!list.isEmpty()) {
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.hasAnyKeyword(kws); // don't add duplicate negative
|
||||
// keywords
|
||||
}
|
||||
@@ -799,7 +799,7 @@ public final class AbilityFactoryDebuff {
|
||||
// only count creatures that can attack
|
||||
human = human.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return CombatUtil.canAttack(c);
|
||||
}
|
||||
});
|
||||
|
||||
@@ -254,7 +254,7 @@ public class AbilityFactoryDestroy {
|
||||
if (!AbilityFactory.playReusable(sa)) {
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (!c.hasKeyword("Undying") || c.getCounters(Counters.P1P1) > 0);
|
||||
}
|
||||
});
|
||||
@@ -266,7 +266,7 @@ public class AbilityFactoryDestroy {
|
||||
// TODO filter out things that might be tougher?
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return ((c.getShield() == 0) && !ComputerUtil.canRegenerate(c));
|
||||
}
|
||||
});
|
||||
@@ -394,7 +394,7 @@ public class AbilityFactoryDestroy {
|
||||
// might be tougher?
|
||||
preferred = preferred.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getShield() == 0;
|
||||
}
|
||||
});
|
||||
@@ -862,13 +862,13 @@ public class AbilityFactoryDestroy {
|
||||
computerlist = computerlist.getValidCards(valid.split(","), source.getController(), source);
|
||||
humanlist = humanlist.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !(c.hasKeyword("Indestructible") || c.getSVar("SacMe").length() > 0);
|
||||
}
|
||||
});
|
||||
computerlist = computerlist.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !(c.hasKeyword("Indestructible") || c.getSVar("SacMe").length() > 0);
|
||||
}
|
||||
});
|
||||
@@ -945,13 +945,13 @@ public class AbilityFactoryDestroy {
|
||||
|
||||
humanlist = humanlist.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !(c.hasKeyword("Indestructible") || c.getSVar("SacMe").length() > 0);
|
||||
}
|
||||
});
|
||||
computerlist = computerlist.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !(c.hasKeyword("Indestructible") || c.getSVar("SacMe").length() > 0);
|
||||
}
|
||||
});
|
||||
|
||||
@@ -301,13 +301,13 @@ public class AbilityFactoryEffect {
|
||||
// only count creatures that can attack or block
|
||||
comp = comp.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return CombatUtil.canAttack(c);
|
||||
}
|
||||
});
|
||||
human = human.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return CombatUtil.canBlock(c);
|
||||
}
|
||||
});
|
||||
|
||||
@@ -337,7 +337,7 @@ public class AbilityFactoryGainControl {
|
||||
// purpose
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
final Map<String, String> vars = c.getSVars();
|
||||
return !vars.containsKey("RemAIDeck") && c.canBeTargetedBy(sa);
|
||||
}
|
||||
@@ -856,7 +856,7 @@ public class AbilityFactoryGainControl {
|
||||
// purpose
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
final Map<String, String> vars = c.getSVars();
|
||||
return !vars.containsKey("RemAIDeck") && c.canBeTargetedBy(sa);
|
||||
}
|
||||
|
||||
@@ -1034,7 +1034,7 @@ public class AbilityFactoryPermanentState {
|
||||
final CardList attackers = AllZone.getCombat().getAttackerList();
|
||||
CardList creatureList = tapList.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (c.isCreature()) {
|
||||
return CombatUtil.canBlockAtLeastOne(c, attackers);
|
||||
}
|
||||
@@ -1049,7 +1049,7 @@ public class AbilityFactoryPermanentState {
|
||||
attackers.remove(sa.getSourceCard());
|
||||
CardList creatureList = tapList.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (c.isCreature()) {
|
||||
return CombatUtil.canBlockAtLeastOne(c, attackers);
|
||||
}
|
||||
@@ -1066,7 +1066,7 @@ public class AbilityFactoryPermanentState {
|
||||
if (!tapList.getType("Creature").isEmpty()) {
|
||||
CardList creatureList = tapList.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (c.isCreature()) {
|
||||
return CombatUtil.canAttack(c);
|
||||
}
|
||||
@@ -1763,13 +1763,13 @@ public class AbilityFactoryPermanentState {
|
||||
if (validTappables.size() > 0) {
|
||||
final CardList human = validTappables.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getController().isHuman();
|
||||
}
|
||||
});
|
||||
final CardList compy = validTappables.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getController().isComputer();
|
||||
}
|
||||
});
|
||||
@@ -1878,13 +1878,13 @@ public class AbilityFactoryPermanentState {
|
||||
if (validTappables.size() > 0) {
|
||||
final CardList human = validTappables.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getController().isHuman();
|
||||
}
|
||||
});
|
||||
final CardList compy = validTappables.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getController().isComputer();
|
||||
}
|
||||
});
|
||||
|
||||
@@ -395,7 +395,7 @@ public final class AbilityFactoryPlay {
|
||||
// AI
|
||||
tgtCards = tgtCards.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
ArrayList<SpellAbility> spellAbilities = c.getBasicSpells();
|
||||
ArrayList<SpellAbility> sas = new ArrayList<SpellAbility>();
|
||||
for (SpellAbility s : spellAbilities) {
|
||||
|
||||
@@ -248,7 +248,7 @@ public final class AbilityFactoryProtection {
|
||||
CardList list = AllZoneUtil.getCreaturesInPlay(AllZone.getComputerPlayer());
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (!c.canBeTargetedBy(sa)) {
|
||||
return false;
|
||||
}
|
||||
@@ -416,7 +416,7 @@ public final class AbilityFactoryProtection {
|
||||
// Don't target cards that will die.
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
System.out.println("Not Protecting");
|
||||
return !c.getSVar("Targeting").equals("Dies");
|
||||
}
|
||||
@@ -483,7 +483,7 @@ public final class AbilityFactoryProtection {
|
||||
CardList pref = list.getController(AllZone.getComputerPlayer());
|
||||
pref = pref.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !AbilityFactoryProtection.hasProtectionFromAll(c,
|
||||
AbilityFactoryProtection.getProtectionList(host, params));
|
||||
}
|
||||
@@ -491,7 +491,7 @@ public final class AbilityFactoryProtection {
|
||||
final CardList pref2 = list.getController(AllZone.getComputerPlayer());
|
||||
pref = pref.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !AbilityFactoryProtection.hasProtectionFromAny(c,
|
||||
AbilityFactoryProtection.getProtectionList(host, params));
|
||||
}
|
||||
|
||||
@@ -680,7 +680,7 @@ public class AbilityFactoryPump {
|
||||
CardList list = AllZoneUtil.getCreaturesInPlay(AllZone.getComputerPlayer());
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return shouldPumpCard(sa, c);
|
||||
}
|
||||
});
|
||||
@@ -708,7 +708,7 @@ public class AbilityFactoryPump {
|
||||
// creature
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (c.getNetDefense() <= -defense) {
|
||||
return true; // can kill indestructible creatures
|
||||
}
|
||||
@@ -732,7 +732,7 @@ public class AbilityFactoryPump {
|
||||
if (Singletons.getModel().getGameState().getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (!c.isAttacking()) {
|
||||
return false;
|
||||
}
|
||||
@@ -759,7 +759,7 @@ public class AbilityFactoryPump {
|
||||
if (addsKeywords) {
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return containsUsefulKeyword(keywords, c, sa);
|
||||
}
|
||||
});
|
||||
@@ -1007,7 +1007,7 @@ public class AbilityFactoryPump {
|
||||
// Don't target cards that will die.
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !c.getSVar("Targeting").equals("Dies");
|
||||
}
|
||||
});
|
||||
@@ -1714,7 +1714,7 @@ public class AbilityFactoryPump {
|
||||
if (defense < 0) { // try to destroy creatures
|
||||
comp = comp.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (c.getNetDefense() <= -defense) {
|
||||
return true; // can kill indestructible creatures
|
||||
}
|
||||
@@ -1723,7 +1723,7 @@ public class AbilityFactoryPump {
|
||||
}); // leaves all creatures that will be destroyed
|
||||
human = human.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (c.getNetDefense() <= -defense) {
|
||||
return true; // can kill indestructible creatures
|
||||
}
|
||||
@@ -1748,7 +1748,7 @@ public class AbilityFactoryPump {
|
||||
// only count creatures that can attack
|
||||
comp = comp.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (power <= 0 && !containsUsefulKeyword(keywords, c, sa)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -185,7 +185,7 @@ class CardFactoryArtifacts {
|
||||
CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Hand);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (c.isLand());
|
||||
}
|
||||
});
|
||||
@@ -223,7 +223,7 @@ class CardFactoryArtifacts {
|
||||
list.remove(card);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (c.isLand());
|
||||
}
|
||||
});
|
||||
|
||||
@@ -271,7 +271,7 @@ class CardFactoryAuras {
|
||||
|
||||
final Predicate<Card> f = new Predicate<Card>() {
|
||||
@Override
|
||||
public final boolean isTrue(final Card c) {
|
||||
public final boolean apply(final Card c) {
|
||||
return (c.getNetDefense() - c.getDamage()) <= 2;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -119,7 +119,7 @@ public class CardFactoryCreatures {
|
||||
CardList perms = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
|
||||
perms = perms.getTargetableCards(this).filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (c.sumAllCounters() > 0);
|
||||
}
|
||||
});
|
||||
@@ -132,7 +132,7 @@ public class CardFactoryCreatures {
|
||||
CardList perms = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
|
||||
perms = perms.getTargetableCards(this).filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (c.sumAllCounters() > 0);
|
||||
}
|
||||
});
|
||||
@@ -228,7 +228,7 @@ public class CardFactoryCreatures {
|
||||
CardList list = new CardList(art);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getIntrinsicKeyword().contains("Indestructible");
|
||||
}
|
||||
});
|
||||
@@ -546,7 +546,7 @@ public class CardFactoryCreatures {
|
||||
|
||||
wolves = wolves.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.isUntapped() && c.isCreature();
|
||||
}
|
||||
});
|
||||
@@ -565,7 +565,7 @@ public class CardFactoryCreatures {
|
||||
|
||||
targetables = targetables.getTargetableCards(this).filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.isCreature() && (c.getNetDefense() <= totalPower);
|
||||
}
|
||||
});
|
||||
@@ -587,7 +587,7 @@ public class CardFactoryCreatures {
|
||||
|
||||
wolves = wolves.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.isUntapped() && c.isCreature();
|
||||
}
|
||||
});
|
||||
@@ -624,7 +624,7 @@ public class CardFactoryCreatures {
|
||||
} else { // AI Choose spread Damage
|
||||
final CardList damageableWolves = wolves.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (c.predictDamage(target.getNetAttack(), target, false) > 0);
|
||||
}
|
||||
});
|
||||
@@ -637,7 +637,7 @@ public class CardFactoryCreatures {
|
||||
|
||||
CardList wolvesLeft = damageableWolves.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !c.hasKeyword("Indestructible");
|
||||
}
|
||||
});
|
||||
@@ -645,7 +645,7 @@ public class CardFactoryCreatures {
|
||||
for (int i = 0; i < target.getNetAttack(); i++) {
|
||||
wolvesLeft = wolvesLeft.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (c.getKillDamage() > 0)
|
||||
&& ((c.getKillDamage() <= target.getNetAttack()) || target
|
||||
.hasKeyword("Deathtouch"));
|
||||
@@ -664,7 +664,7 @@ public class CardFactoryCreatures {
|
||||
if (target.hasKeyword("Infect") || target.hasKeyword("Wither")) {
|
||||
final CardList indestructibles = damageableWolves.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.hasKeyword("Indestructible");
|
||||
}
|
||||
});
|
||||
@@ -769,7 +769,7 @@ public class CardFactoryCreatures {
|
||||
CardList list = CardFactoryUtil.getHumanCreatureAI(card.getCounters(Counters.P1P1), this, true);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
final int total = card.getCounters(Counters.P1P1);
|
||||
return (total >= c.getKillDamage());
|
||||
}
|
||||
@@ -825,7 +825,7 @@ public class CardFactoryCreatures {
|
||||
kithkin = kithkin.filter( new Predicate<Card>() {
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (c.isType("Kithkin")) && !c.equals(card);
|
||||
}
|
||||
|
||||
@@ -935,7 +935,7 @@ public class CardFactoryCreatures {
|
||||
CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield, "Dark Depths");
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card crd) {
|
||||
public boolean apply(final Card crd) {
|
||||
return crd.getCounters(Counters.ICE) >= 3;
|
||||
}
|
||||
});
|
||||
@@ -949,7 +949,7 @@ public class CardFactoryCreatures {
|
||||
list = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card crd) {
|
||||
public boolean apply(final Card crd) {
|
||||
return crd.isPlaneswalker() && (crd.getCounters(Counters.LOYALTY) >= 5);
|
||||
}
|
||||
});
|
||||
@@ -993,7 +993,7 @@ public class CardFactoryCreatures {
|
||||
CardList creats = card.getController().getCardsIn(ZoneType.Graveyard);
|
||||
creats = creats.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.isCreature() && !c.equals(card);
|
||||
}
|
||||
});
|
||||
|
||||
@@ -420,7 +420,7 @@ public class CardFactoryInstants {
|
||||
final CardList ens = AllZoneUtil.getCardsIn(ZoneType.Battlefield).filter(Presets.ENCHANTMENTS);
|
||||
final CardList toReturn = ens.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
final Card enchanting = c.getEnchantingCard();
|
||||
|
||||
if (enchanting != null) {
|
||||
|
||||
@@ -140,7 +140,7 @@ class CardFactoryLands {
|
||||
final Predicate<Card> targets = new Predicate<Card>() {
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return AllZoneUtil.isCardInPlay(c) && c.isCreature()
|
||||
&& (c.getTurnInZone() == Singletons.getModel().getGameState().getPhaseHandler().getTurn());
|
||||
}
|
||||
|
||||
@@ -392,7 +392,7 @@ public class CardFactorySorceries {
|
||||
// need to sacrifice the other non-basic land types
|
||||
land = land.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (c.getName().contains("Dryad Arbor")) {
|
||||
return true;
|
||||
} else {
|
||||
@@ -459,7 +459,7 @@ public class CardFactorySorceries {
|
||||
CardList cl = land.getType(humanBasic.get(this.count));
|
||||
cl = cl.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card crd) {
|
||||
public boolean apply(final Card crd) {
|
||||
return !saveList.contains(crd);
|
||||
}
|
||||
});
|
||||
@@ -480,7 +480,7 @@ public class CardFactorySorceries {
|
||||
// need to sacrifice the other non-basic land types
|
||||
land = land.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (c.getName().contains("Dryad Arbor")) {
|
||||
return true;
|
||||
} else {
|
||||
@@ -544,7 +544,7 @@ public class CardFactorySorceries {
|
||||
final int graveCount = graveyard.size();
|
||||
graveyard = graveyard.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.isBasicLand();
|
||||
}
|
||||
});
|
||||
@@ -1407,7 +1407,7 @@ public class CardFactorySorceries {
|
||||
grave = grave.filter(Presets.CREATURES);
|
||||
grave = grave.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getCMC() <= x[0];
|
||||
}
|
||||
});
|
||||
|
||||
@@ -105,7 +105,7 @@ public class CardFactoryUtil {
|
||||
if (targeted) {
|
||||
all = all.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.canBeTargetedBy(spell);
|
||||
}
|
||||
});
|
||||
@@ -164,7 +164,7 @@ public class CardFactoryUtil {
|
||||
public static Card getCheapestCreatureAI(CardList list, final SpellAbility spell, final boolean targeted) {
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.isCreature();
|
||||
}
|
||||
});
|
||||
@@ -189,7 +189,7 @@ public class CardFactoryUtil {
|
||||
if (targeted) {
|
||||
all = all.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.canBeTargetedBy(spell);
|
||||
}
|
||||
});
|
||||
@@ -230,7 +230,7 @@ public class CardFactoryUtil {
|
||||
// prefer to target non basic lands
|
||||
final CardList nbLand = land.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (!c.isBasicLand());
|
||||
}
|
||||
});
|
||||
@@ -296,7 +296,7 @@ public class CardFactoryUtil {
|
||||
all = all.filter(new Predicate<Card>() {
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.canBeTargetedBy(spell);
|
||||
}
|
||||
});
|
||||
@@ -789,7 +789,7 @@ public class CardFactoryUtil {
|
||||
if ((list.getType("Artifact").size() > 0) || (list.getType("Enchantment").size() > 0)) {
|
||||
return CardFactoryUtil.getCheapestPermanentAI(list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.isArtifact() || c.isEnchantment();
|
||||
}
|
||||
}), null, false);
|
||||
@@ -1655,7 +1655,7 @@ public class CardFactoryUtil {
|
||||
CardList creature = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield);
|
||||
creature = creature.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (targeted) {
|
||||
return c.isCreature() && (c.getNetDefense() <= toughness) && c.canBeTargetedBy(spell);
|
||||
} else {
|
||||
@@ -2016,7 +2016,7 @@ public class CardFactoryUtil {
|
||||
CardList list = new CardList(card.getEquippedBy());
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getName().equals(name);
|
||||
}
|
||||
|
||||
@@ -2072,7 +2072,7 @@ public class CardFactoryUtil {
|
||||
if (activator.isPlayer(zone.getPlayer())) {
|
||||
cl = cl.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (zone.is(ZoneType.Graveyard)) {
|
||||
if (c.hasUnearth()) {
|
||||
return true;
|
||||
@@ -2107,7 +2107,7 @@ public class CardFactoryUtil {
|
||||
// the activator is not the owner of the card
|
||||
cl = cl.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
|
||||
if (c.hasStartOfKeyword("May be played by your opponent")
|
||||
|| c.hasKeyword("Your opponent may look at this card.")) {
|
||||
@@ -2777,7 +2777,7 @@ public class CardFactoryUtil {
|
||||
|
||||
cl = cl.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card cdev) {
|
||||
public boolean apply(final Card cdev) {
|
||||
return cdev.isValid(validDevoured.split(","), csource.getController(), csource);
|
||||
}
|
||||
});
|
||||
@@ -3086,7 +3086,7 @@ public class CardFactoryUtil {
|
||||
if (sq[0].contains("Multicolor")) {
|
||||
someCards = someCards.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (CardUtil.getColors(c).size() > 1);
|
||||
}
|
||||
});
|
||||
@@ -3095,7 +3095,7 @@ public class CardFactoryUtil {
|
||||
if (sq[0].contains("Monocolor")) {
|
||||
someCards = someCards.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (CardUtil.getColors(c).size() == 1);
|
||||
}
|
||||
});
|
||||
@@ -3488,7 +3488,7 @@ public class CardFactoryUtil {
|
||||
CardList list = player.getCardsIn(ZoneType.Battlefield);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
for (final AbilityMana am : c.getAIPlayableMana()) {
|
||||
if (am.canPlay()) {
|
||||
return true;
|
||||
@@ -5126,7 +5126,7 @@ public class CardFactoryUtil {
|
||||
CardList choices = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
|
||||
choices = choices.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.isCreature() && c.isArtifact();
|
||||
}
|
||||
});
|
||||
|
||||
@@ -302,7 +302,7 @@ public class TargetSelection {
|
||||
final Card card = targeted.get(0);
|
||||
choices = choices.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !c.sharesCreatureTypeWith(card);
|
||||
}
|
||||
});
|
||||
|
||||
@@ -40,21 +40,21 @@ public class GenerateDeckUtil {
|
||||
|
||||
public static final Predicate<CardRules> AI_CAN_PLAY = new Predicate<CardRules>() {
|
||||
@Override
|
||||
public boolean isTrue(CardRules c) {
|
||||
public boolean apply(CardRules c) {
|
||||
return !c.getRemAIDecks() && !c.getRemRandomDecks();
|
||||
}
|
||||
};
|
||||
|
||||
public static final Predicate<CardRules> HUMAN_CAN_PLAY = new Predicate<CardRules>() {
|
||||
@Override
|
||||
public boolean isTrue(CardRules c) {
|
||||
public boolean apply(CardRules c) {
|
||||
return !c.getRemRandomDecks();
|
||||
}
|
||||
};
|
||||
|
||||
public static final Predicate<CardRules> COLORLESS_CARDS = new Predicate<CardRules>() {
|
||||
@Override
|
||||
public boolean isTrue(CardRules c) {
|
||||
public boolean apply(CardRules c) {
|
||||
CardManaCost mc = c.getManaCost();
|
||||
return mc.getColorProfile() == 0 && !mc.isEmpty();
|
||||
}
|
||||
@@ -67,7 +67,7 @@ public class GenerateDeckUtil {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(CardRules subject) {
|
||||
public boolean apply(CardRules subject) {
|
||||
return allowedColor.containsAllColorsFrom(subject.getManaCost().getColorProfile());
|
||||
}
|
||||
}
|
||||
@@ -81,7 +81,7 @@ public class GenerateDeckUtil {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(CardRules c) {
|
||||
public boolean apply(CardRules c) {
|
||||
CardManaCost mc = c.getManaCost();
|
||||
int cmc = mc.getCMC();
|
||||
return cmc >= min && cmc <= max && !mc.isEmpty();
|
||||
|
||||
@@ -884,7 +884,7 @@ public class CombatUtil {
|
||||
CardList list = AllZoneUtil.getCreaturesInPlay(c.getController().getOpponent());
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card ct) {
|
||||
public boolean apply(final Card ct) {
|
||||
return ((ct.isUntapped() && (ct.getNetAttack() >= powerLimit[0]) && asSeparateWords[14]
|
||||
.contains("greater")) || (ct.isUntapped() && (ct.getNetAttack() <= powerLimit[0]) && asSeparateWords[14]
|
||||
.contains("less")));
|
||||
@@ -928,7 +928,7 @@ public class CombatUtil {
|
||||
} else if (keyword.equals("CARDNAME can't attack unless defending player controls a snow land.")) {
|
||||
temp = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.isLand() && c.isSnow();
|
||||
}
|
||||
});
|
||||
@@ -968,7 +968,7 @@ public class CombatUtil {
|
||||
CardList list = AllZoneUtil.getCreaturesInPlay(player);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return CombatUtil.canBlock(att, c) && (c.hasFirstStrike() || c.hasDoubleStrike());
|
||||
}
|
||||
});
|
||||
@@ -3083,7 +3083,7 @@ public class CombatUtil {
|
||||
CardList enchantments = attacker.getController().getCardsIn(ZoneType.Library);
|
||||
enchantments = enchantments.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (attacker.hasKeyword("Protection from enchantments")
|
||||
|| (attacker.hasKeyword("Protection from everything"))) {
|
||||
return false;
|
||||
|
||||
@@ -232,7 +232,7 @@ public class EndOfTurn extends Phase implements java.io.Serializable {
|
||||
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getName().equals("Lighthouse Chronologist") && (c.getCounters(Counters.LEVEL) >= 7);
|
||||
}
|
||||
});
|
||||
|
||||
@@ -662,7 +662,7 @@ public class PhaseHandler extends MyObservable implements java.io.Serializable {
|
||||
CardList vaults = turn.getCardsIn(ZoneType.Battlefield, "Time Vault");
|
||||
vaults = vaults.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.isTapped();
|
||||
}
|
||||
});
|
||||
|
||||
@@ -372,7 +372,7 @@ public class PhaseUtil {
|
||||
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !c.getDamageHistory().getCreatureBlockedThisCombat();
|
||||
}
|
||||
});
|
||||
|
||||
@@ -118,7 +118,7 @@ public class Untap extends Phase implements java.io.Serializable {
|
||||
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (!Untap.canUntap(c)) {
|
||||
return false;
|
||||
}
|
||||
@@ -197,7 +197,7 @@ public class Untap extends Phase implements java.io.Serializable {
|
||||
CardList landList = AllZoneUtil.getPlayerLandsInPlay(AllZone.getComputerPlayer());
|
||||
landList = landList.filter(Presets.TAPPED).filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return Untap.canUntap(c);
|
||||
}
|
||||
});
|
||||
@@ -230,7 +230,7 @@ public class Untap extends Phase implements java.io.Serializable {
|
||||
CardList landList = AllZoneUtil.getPlayerLandsInPlay(AllZone.getHumanPlayer());
|
||||
landList = landList.filter(Presets.TAPPED).filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return Untap.canUntap(c);
|
||||
}
|
||||
});
|
||||
@@ -245,7 +245,7 @@ public class Untap extends Phase implements java.io.Serializable {
|
||||
artList = artList.filter(Presets.ARTIFACTS);
|
||||
artList = artList.filter(Presets.TAPPED).filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return Untap.canUntap(c);
|
||||
}
|
||||
});
|
||||
@@ -280,7 +280,7 @@ public class Untap extends Phase implements java.io.Serializable {
|
||||
artList = artList.filter(Presets.ARTIFACTS);
|
||||
artList = artList.filter(Presets.TAPPED).filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return Untap.canUntap(c);
|
||||
}
|
||||
});
|
||||
@@ -294,7 +294,7 @@ public class Untap extends Phase implements java.io.Serializable {
|
||||
CardList creatures = AllZoneUtil.getCreaturesInPlay(AllZone.getComputerPlayer());
|
||||
creatures = creatures.filter(Presets.TAPPED).filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return Untap.canUntap(c);
|
||||
}
|
||||
});
|
||||
@@ -328,7 +328,7 @@ public class Untap extends Phase implements java.io.Serializable {
|
||||
CardList creatures = AllZoneUtil.getCreaturesInPlay(AllZone.getHumanPlayer());
|
||||
creatures = creatures.filter(Presets.TAPPED).filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return Untap.canUntap(c);
|
||||
}
|
||||
});
|
||||
@@ -369,7 +369,7 @@ public class Untap extends Phase implements java.io.Serializable {
|
||||
final CardList list = turn.getCardsIncludePhasingIn(ZoneType.Battlefield).filter(new Predicate<Card>() {
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return ((c.isPhasedOut() && c.isDirectlyPhasedOut()) || c.hasKeyword("Phasing"));
|
||||
}
|
||||
});
|
||||
|
||||
@@ -164,7 +164,7 @@ public class Upkeep extends Phase implements java.io.Serializable {
|
||||
CardList list = Singletons.getModel().getGameState().getPhaseHandler().getPlayerTurn().getCardsIn(ZoneType.Battlefield);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.hasStartOfKeyword("(Echo unpaid)");
|
||||
}
|
||||
});
|
||||
@@ -588,7 +588,7 @@ public class Upkeep extends Phase implements java.io.Serializable {
|
||||
final CardList options = this.getLowestPowerList(original);
|
||||
final CardList humanCreatures = options.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.getController().isHuman();
|
||||
}
|
||||
});
|
||||
@@ -1828,7 +1828,7 @@ public class Upkeep extends Phase implements java.io.Serializable {
|
||||
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.hasSuspend();
|
||||
}
|
||||
});
|
||||
@@ -1856,7 +1856,7 @@ public class Upkeep extends Phase implements java.io.Serializable {
|
||||
CardList list = player.getCardsIn(ZoneType.Battlefield);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return CardFactoryUtil.hasKeyword(c, "Vanishing") != -1;
|
||||
}
|
||||
});
|
||||
@@ -1893,7 +1893,7 @@ public class Upkeep extends Phase implements java.io.Serializable {
|
||||
CardList list = player.getCardsIn(ZoneType.Battlefield);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return CardFactoryUtil.hasKeyword(c, "Fading") != -1;
|
||||
}
|
||||
});
|
||||
@@ -2146,7 +2146,7 @@ public class Upkeep extends Phase implements java.io.Serializable {
|
||||
final int num = source.getCounters(Counters.FADE);
|
||||
final CardList list = player.getCardsIn(ZoneType.Battlefield).filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (c.isArtifact() || c.isLand() || c.isCreature()) && c.isUntapped();
|
||||
}
|
||||
});
|
||||
@@ -2157,7 +2157,7 @@ public class Upkeep extends Phase implements java.io.Serializable {
|
||||
// try to find non creature cards without tap abilities
|
||||
CardList betterList = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (c.isCreature()) {
|
||||
return false;
|
||||
}
|
||||
@@ -2232,7 +2232,7 @@ public class Upkeep extends Phase implements java.io.Serializable {
|
||||
CardList blaze = player.getCardsIn(ZoneType.Battlefield);
|
||||
blaze = blaze.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.isLand() && (c.getCounters(Counters.BLAZE) > 0);
|
||||
}
|
||||
});
|
||||
@@ -2276,7 +2276,7 @@ public class Upkeep extends Phase implements java.io.Serializable {
|
||||
final CardList enchantmentsAttached = new CardList(source.getEnchantingPlayer().getEnchantedBy());
|
||||
enchantmentsInLibrary = enchantmentsInLibrary.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.isEnchantment() && c.hasKeyword("Enchant player")
|
||||
&& !source.getEnchantingPlayer().hasProtectionFrom(c)
|
||||
&& !CardPredicates.nameEquals(c.getName()).any(enchantmentsAttached);
|
||||
|
||||
@@ -1001,7 +1001,7 @@ public class ComputerUtil {
|
||||
final CardList list = player.getCardsIn(ZoneType.Battlefield);
|
||||
final CardList manaSources = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (checkPlayable) {
|
||||
for (final AbilityMana am : c.getAIPlayableMana()) {
|
||||
am.setActivatingPlayer(player);
|
||||
@@ -1307,7 +1307,7 @@ public class ComputerUtil {
|
||||
|
||||
landList = landList.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if (c.getSVar("NeedsToPlay").length() > 0) {
|
||||
final String needsToPlay = c.getSVar("NeedsToPlay");
|
||||
CardList list = AllZoneUtil.getCardsIn(ZoneType.Battlefield);
|
||||
@@ -1430,7 +1430,7 @@ public class ComputerUtil {
|
||||
final int priority = 9 - ip;
|
||||
final CardList sacMeList = typeList.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (!c.getSVar("SacMe").equals("") && (Integer.parseInt(c.getSVar("SacMe")) == priority));
|
||||
}
|
||||
});
|
||||
@@ -1448,7 +1448,7 @@ public class ComputerUtil {
|
||||
final int priority = 9 - ip;
|
||||
final CardList sacMeList = typeList.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return (!c.getSVar("DiscardMe").equals("") && (Integer.parseInt(c.getSVar("DiscardMe")) == priority));
|
||||
}
|
||||
});
|
||||
@@ -1826,7 +1826,7 @@ public class ComputerUtil {
|
||||
CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return CombatUtil.canAttack(c);
|
||||
}
|
||||
});
|
||||
|
||||
@@ -166,7 +166,7 @@ public class ComputerUtilAttack {
|
||||
CardList list = new CardList(in);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return CombatUtil.canAttack(c);
|
||||
}
|
||||
});
|
||||
@@ -188,7 +188,7 @@ public class ComputerUtilAttack {
|
||||
CardList possibleBlockers = new CardList(blockers);
|
||||
possibleBlockers = possibleBlockers.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return canBlockAnAttacker(c, attackers);
|
||||
}
|
||||
});
|
||||
@@ -842,7 +842,7 @@ public class ComputerUtilAttack {
|
||||
CardList list = player.getCardsIn(ZoneType.Battlefield);
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return c.hasKeyword("Exalted");
|
||||
}
|
||||
});
|
||||
|
||||
@@ -458,7 +458,7 @@ public class ComputerUtilBlock {
|
||||
// attacker has it
|
||||
usableBlockers = blockers.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
if ((attacker.hasKeyword("First Strike") || attacker.hasKeyword("Double Strike"))
|
||||
&& !(c.hasKeyword("First Strike") || c.hasKeyword("Double Strike"))) {
|
||||
return false;
|
||||
|
||||
@@ -58,7 +58,7 @@ public final class PlayerUtil {
|
||||
list = list.getKeyword("Damage that would reduce your life total to less than 1 reduces it to 1 instead.");
|
||||
list = list.filter(new Predicate<Card>() {
|
||||
@Override
|
||||
public boolean isTrue(final Card c) {
|
||||
public boolean apply(final Card c) {
|
||||
return !c.isFaceDown();
|
||||
}
|
||||
});
|
||||
|
||||
@@ -396,7 +396,7 @@ public final class CardPrinted implements Comparable<CardPrinted>, InventoryItem
|
||||
private final boolean shouldBeEqual;
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final CardPrinted card) {
|
||||
public boolean apply(final CardPrinted card) {
|
||||
return card.rarity.equals(this.operand) == this.shouldBeEqual;
|
||||
}
|
||||
|
||||
@@ -411,7 +411,7 @@ public final class CardPrinted implements Comparable<CardPrinted>, InventoryItem
|
||||
private final boolean mustContain;
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final CardPrinted card) {
|
||||
public boolean apply(final CardPrinted card) {
|
||||
return this.sets.contains(card.edition) == this.mustContain;
|
||||
}
|
||||
|
||||
@@ -425,7 +425,7 @@ public final class CardPrinted implements Comparable<CardPrinted>, InventoryItem
|
||||
private final String operand;
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final CardPrinted card) {
|
||||
public boolean apply(final CardPrinted card) {
|
||||
return this.op(card.getName(), this.operand);
|
||||
}
|
||||
|
||||
@@ -439,7 +439,7 @@ public final class CardPrinted implements Comparable<CardPrinted>, InventoryItem
|
||||
private final String[] operand;
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final CardPrinted card) {
|
||||
public boolean apply(final CardPrinted card) {
|
||||
final String cardName = card.getName();
|
||||
for (final String element : this.operand) {
|
||||
if (this.op(cardName, element)) {
|
||||
|
||||
@@ -63,7 +63,7 @@ public abstract class ItemPredicate {
|
||||
public static class PredicateBoosterPack extends Predicate<InventoryItem> {
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final InventoryItem card) {
|
||||
public boolean apply(final InventoryItem card) {
|
||||
return card.getType() == "Booster Pack";
|
||||
}
|
||||
}
|
||||
@@ -76,7 +76,7 @@ public abstract class ItemPredicate {
|
||||
public static class PredicateFatPack extends Predicate<InventoryItem> {
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final InventoryItem card) {
|
||||
public boolean apply(final InventoryItem card) {
|
||||
return card.getType() == "Fat Pack";
|
||||
}
|
||||
}
|
||||
@@ -89,7 +89,7 @@ public abstract class ItemPredicate {
|
||||
public static class PredicateTournamentPack extends Predicate<InventoryItem> {
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final InventoryItem card) {
|
||||
public boolean apply(final InventoryItem card) {
|
||||
return card.getType() == "Tournament Pack";
|
||||
}
|
||||
}
|
||||
@@ -102,7 +102,7 @@ public abstract class ItemPredicate {
|
||||
public static class PredicateStarterDeck extends Predicate<InventoryItem> {
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final InventoryItem card) {
|
||||
public boolean apply(final InventoryItem card) {
|
||||
return card.getType() == "Starter Deck";
|
||||
}
|
||||
}
|
||||
@@ -115,7 +115,7 @@ public abstract class ItemPredicate {
|
||||
public static class PredicatePrebuiltDeck extends Predicate<InventoryItem> {
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final InventoryItem card) {
|
||||
public boolean apply(final InventoryItem card) {
|
||||
return card.getType() == "Prebuilt Deck";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -37,7 +37,7 @@ import java.util.Map;
|
||||
* @author Max
|
||||
*/
|
||||
|
||||
public abstract class Predicate<T> {
|
||||
public abstract class Predicate<T> implements com.google.common.base.Predicate<T>{
|
||||
|
||||
/**
|
||||
* Possible operators on two predicates.
|
||||
@@ -71,7 +71,7 @@ public abstract class Predicate<T> {
|
||||
* the subject
|
||||
* @return true, if is true
|
||||
*/
|
||||
public abstract boolean isTrue(T subject);
|
||||
public abstract boolean apply(T subject);
|
||||
|
||||
// Overloaded only in LeafConstant
|
||||
/**
|
||||
@@ -111,7 +111,7 @@ public abstract class Predicate<T> {
|
||||
final ArrayList<T> result = new ArrayList<T>();
|
||||
if (source != null) {
|
||||
for (final T c : source) {
|
||||
if (this.isTrue(c)) {
|
||||
if (this.apply(c)) {
|
||||
result.add(c);
|
||||
}
|
||||
}
|
||||
@@ -134,7 +134,7 @@ public abstract class Predicate<T> {
|
||||
final ArrayList<U> result = new ArrayList<U>();
|
||||
if (source != null) {
|
||||
for (final U c : source) {
|
||||
if (this.isTrue(accessor.apply(c))) {
|
||||
if (this.apply(accessor.apply(c))) {
|
||||
result.add(c);
|
||||
}
|
||||
}
|
||||
@@ -153,7 +153,7 @@ public abstract class Predicate<T> {
|
||||
public final boolean any(final Iterable<T> source) {
|
||||
if (source != null) {
|
||||
for (final T c : source) {
|
||||
if (this.isTrue(c)) {
|
||||
if (this.apply(c)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -175,7 +175,7 @@ public abstract class Predicate<T> {
|
||||
public final <U> boolean any(final Iterable<U> source, final Lambda1<T, U> accessor) {
|
||||
if (source != null) {
|
||||
for (final U c : source) {
|
||||
if (this.isTrue(accessor.apply(c))) {
|
||||
if (this.apply(accessor.apply(c))) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -194,7 +194,7 @@ public abstract class Predicate<T> {
|
||||
public final T first(final Iterable<T> source) {
|
||||
if (source != null) {
|
||||
for (final T c : source) {
|
||||
if (this.isTrue(c)) {
|
||||
if (this.apply(c)) {
|
||||
return c;
|
||||
}
|
||||
}
|
||||
@@ -216,7 +216,7 @@ public abstract class Predicate<T> {
|
||||
public final <U> U first(final Iterable<U> source, final Lambda1<T, U> accessor) {
|
||||
if (source != null) {
|
||||
for (final U c : source) {
|
||||
if (this.isTrue(accessor.apply(c))) {
|
||||
if (this.apply(accessor.apply(c))) {
|
||||
return c;
|
||||
}
|
||||
}
|
||||
@@ -243,7 +243,7 @@ public abstract class Predicate<T> {
|
||||
final Lambda1<V, U> transformer) {
|
||||
if (source != null) {
|
||||
for (final U c : source) {
|
||||
if (this.isTrue(cardAccessor.apply(c))) {
|
||||
if (this.apply(cardAccessor.apply(c))) {
|
||||
return transformer.apply(c);
|
||||
}
|
||||
}
|
||||
@@ -267,7 +267,7 @@ public abstract class Predicate<T> {
|
||||
return;
|
||||
}
|
||||
for (final T c : source) {
|
||||
if (this.isTrue(c)) {
|
||||
if (this.apply(c)) {
|
||||
trueList.add(c);
|
||||
} else {
|
||||
falseList.add(c);
|
||||
@@ -295,7 +295,7 @@ public abstract class Predicate<T> {
|
||||
return;
|
||||
}
|
||||
for (final U c : source) {
|
||||
if (this.isTrue(accessor.apply(c))) {
|
||||
if (this.apply(accessor.apply(c))) {
|
||||
trueList.add(c);
|
||||
} else {
|
||||
falseList.add(c);
|
||||
@@ -318,7 +318,7 @@ public abstract class Predicate<T> {
|
||||
public final <K> Iterable<T> uniqueByLast(final Iterable<T> source, final Lambda1<K, T> fnUniqueKey) {
|
||||
final Map<K, T> uniques = new Hashtable<K, T>();
|
||||
for (final T c : source) {
|
||||
if (this.isTrue(c)) {
|
||||
if (this.apply(c)) {
|
||||
uniques.put(fnUniqueKey.apply(c), c);
|
||||
}
|
||||
}
|
||||
@@ -344,7 +344,7 @@ public abstract class Predicate<T> {
|
||||
final Lambda1<T, U> accessor) { // this might be exotic
|
||||
final Map<K, U> uniques = new Hashtable<K, U>();
|
||||
for (final U c : source) {
|
||||
if (this.isTrue(accessor.apply(c))) {
|
||||
if (this.apply(accessor.apply(c))) {
|
||||
uniques.put(fnUniqueKey.apply(c), c);
|
||||
}
|
||||
}
|
||||
@@ -366,7 +366,7 @@ public abstract class Predicate<T> {
|
||||
final Map<K, T> uniques = new Hashtable<K, T>();
|
||||
for (final T c : source) {
|
||||
final K key = fnUniqueKey.apply(c);
|
||||
if (this.isTrue(c) && !uniques.containsKey(key)) {
|
||||
if (this.apply(c) && !uniques.containsKey(key)) {
|
||||
uniques.put(fnUniqueKey.apply(c), c);
|
||||
}
|
||||
}
|
||||
@@ -393,7 +393,7 @@ public abstract class Predicate<T> {
|
||||
final Map<K, U> uniques = new Hashtable<K, U>();
|
||||
for (final U c : source) {
|
||||
final K key = fnUniqueKey.apply(c);
|
||||
if (this.isTrue(accessor.apply(c)) && !uniques.containsKey(key)) {
|
||||
if (this.apply(accessor.apply(c)) && !uniques.containsKey(key)) {
|
||||
uniques.put(fnUniqueKey.apply(c), c);
|
||||
}
|
||||
}
|
||||
@@ -412,7 +412,7 @@ public abstract class Predicate<T> {
|
||||
int result = 0;
|
||||
if (source != null) {
|
||||
for (final T c : source) {
|
||||
if (this.isTrue(c)) {
|
||||
if (this.apply(c)) {
|
||||
result++;
|
||||
}
|
||||
}
|
||||
@@ -435,7 +435,7 @@ public abstract class Predicate<T> {
|
||||
int result = 0;
|
||||
if (source != null) {
|
||||
for (final U c : source) {
|
||||
if (this.isTrue(accessor.apply(c))) {
|
||||
if (this.apply(accessor.apply(c))) {
|
||||
result++;
|
||||
}
|
||||
}
|
||||
@@ -462,7 +462,7 @@ public abstract class Predicate<T> {
|
||||
int result = 0;
|
||||
if (source != null) {
|
||||
for (final U c : source) {
|
||||
if (this.isTrue(accessor.apply(c))) {
|
||||
if (this.apply(accessor.apply(c))) {
|
||||
result += valueAccessor.apply(c);
|
||||
}
|
||||
}
|
||||
@@ -474,7 +474,7 @@ public abstract class Predicate<T> {
|
||||
int result = 0;
|
||||
if (source != null) {
|
||||
for (final T c : source) {
|
||||
if (this.isTrue(c)) {
|
||||
if (this.apply(c)) {
|
||||
result += valueAccessor.apply(c);
|
||||
}
|
||||
}
|
||||
@@ -487,7 +487,7 @@ public abstract class Predicate<T> {
|
||||
if (source == null) { return null; }
|
||||
int max = Integer.MIN_VALUE;
|
||||
for (final T c : source) {
|
||||
if (!this.isTrue(c)) { continue; }
|
||||
if (!this.apply(c)) { continue; }
|
||||
|
||||
int value = valueAccessor.apply(c);
|
||||
if ( value > max ) {
|
||||
@@ -505,7 +505,7 @@ public abstract class Predicate<T> {
|
||||
int max = Integer.MIN_VALUE;
|
||||
|
||||
for (final T c : source) {
|
||||
if (!this.isTrue(c)) { continue; }
|
||||
if (!this.apply(c)) { continue; }
|
||||
|
||||
int value = valueAccessor.apply(c);
|
||||
if ( value > max ) {
|
||||
@@ -529,7 +529,7 @@ public abstract class Predicate<T> {
|
||||
int n = 0;
|
||||
T candidate = null;
|
||||
for (final T item : source) {
|
||||
if (!this.isTrue(item)) {
|
||||
if (!this.apply(item)) {
|
||||
continue;
|
||||
}
|
||||
if ((Math.random() * ++n) < 1) {
|
||||
@@ -554,7 +554,7 @@ public abstract class Predicate<T> {
|
||||
int n = 0;
|
||||
U candidate = null;
|
||||
for (final U item : source) {
|
||||
if (!this.isTrue(accessor.apply(item))) {
|
||||
if (!this.apply(accessor.apply(item))) {
|
||||
continue;
|
||||
}
|
||||
if ((Math.random() * ++n) < 1) {
|
||||
@@ -873,8 +873,8 @@ final class Not<T> extends Predicate<T> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final T card) {
|
||||
return !this.filter.isTrue(card);
|
||||
public boolean apply(final T card) {
|
||||
return !this.filter.apply(card);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -908,8 +908,8 @@ final class Bridge<T, U> extends Predicate<U> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final U card) {
|
||||
return this.filter.isTrue(this.fnBridge.apply(card));
|
||||
public boolean apply(final U card) {
|
||||
return this.filter.apply(this.fnBridge.apply(card));
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -950,8 +950,8 @@ final class BridgeToInstance<T, U> extends Predicate<U> {
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
@Override
|
||||
public boolean isTrue(final U card) {
|
||||
return this.clsBridge.isInstance(card) && this.filter.isTrue((T) card);
|
||||
public boolean apply(final U card) {
|
||||
return this.clsBridge.isInstance(card) && this.filter.apply((T) card);
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -990,24 +990,24 @@ class Node<T> extends Predicate<T> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final T card) {
|
||||
public boolean apply(final T card) {
|
||||
switch (this.operator) {
|
||||
case AND:
|
||||
return this.filter1.isTrue(card) && this.filter2.isTrue(card);
|
||||
return this.filter1.apply(card) && this.filter2.apply(card);
|
||||
case GT:
|
||||
return this.filter1.isTrue(card) && !this.filter2.isTrue(card);
|
||||
return this.filter1.apply(card) && !this.filter2.apply(card);
|
||||
case LT:
|
||||
return !this.filter1.isTrue(card) && this.filter2.isTrue(card);
|
||||
return !this.filter1.apply(card) && this.filter2.apply(card);
|
||||
case NAND:
|
||||
return !(this.filter1.isTrue(card) && this.filter2.isTrue(card));
|
||||
return !(this.filter1.apply(card) && this.filter2.apply(card));
|
||||
case OR:
|
||||
return this.filter1.isTrue(card) || this.filter2.isTrue(card);
|
||||
return this.filter1.apply(card) || this.filter2.apply(card);
|
||||
case NOR:
|
||||
return !(this.filter1.isTrue(card) || this.filter2.isTrue(card));
|
||||
return !(this.filter1.apply(card) || this.filter2.apply(card));
|
||||
case XOR:
|
||||
return this.filter1.isTrue(card) ^ this.filter2.isTrue(card);
|
||||
return this.filter1.apply(card) ^ this.filter2.apply(card);
|
||||
case EQ:
|
||||
return this.filter1.isTrue(card) == this.filter2.isTrue(card);
|
||||
return this.filter1.apply(card) == this.filter2.apply(card);
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
@@ -1035,8 +1035,8 @@ final class NodeOr<T> extends Node<T> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final T card) {
|
||||
return this.filter1.isTrue(card) || this.filter2.isTrue(card);
|
||||
public boolean apply(final T card) {
|
||||
return this.filter1.apply(card) || this.filter2.apply(card);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1059,8 +1059,8 @@ final class NodeAnd<T> extends Node<T> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final T card) {
|
||||
return this.filter1.isTrue(card) && this.filter2.isTrue(card);
|
||||
public boolean apply(final T card) {
|
||||
return this.filter1.apply(card) && this.filter2.apply(card);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1092,8 +1092,8 @@ final class NodeOrBridged<T, U> extends Predicate<T> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final T card) {
|
||||
return this.filter1.isTrue(card) || this.filter2.isTrue(this.bridge.apply(card));
|
||||
public boolean apply(final T card) {
|
||||
return this.filter1.apply(card) || this.filter2.apply(this.bridge.apply(card));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1124,8 +1124,8 @@ final class NodeAndBridged<T, U> extends Predicate<T> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final T card) {
|
||||
return this.filter1.isTrue(card) && this.filter2.isTrue(this.bridge.apply(card));
|
||||
public boolean apply(final T card) {
|
||||
return this.filter1.apply(card) && this.filter2.apply(this.bridge.apply(card));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1178,9 +1178,9 @@ final class MultiNodeAnd<T> extends MultiNode<T> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final T subject) {
|
||||
public boolean apply(final T subject) {
|
||||
for (final Predicate<T> p : this.getOperands()) {
|
||||
if (!p.isTrue(subject)) {
|
||||
if (!p.apply(subject)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -1206,9 +1206,9 @@ final class MultiNodeOr<T> extends MultiNode<T> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final T subject) {
|
||||
public boolean apply(final T subject) {
|
||||
for (final Predicate<T> p : this.getOperands()) {
|
||||
if (p.isTrue(subject)) {
|
||||
if (p.apply(subject)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -1234,9 +1234,9 @@ final class MultiNodeNot<T> extends MultiNode<T> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final T subject) {
|
||||
public boolean apply(final T subject) {
|
||||
for (final Predicate<T> p : this.getOperands()) {
|
||||
if (!p.isTrue(subject)) {
|
||||
if (!p.apply(subject)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -1265,7 +1265,7 @@ class LeafConstant<T> extends Predicate<T> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrue(final T card) {
|
||||
public boolean apply(final T card) {
|
||||
return this.bValue;
|
||||
}
|
||||
|
||||
|
||||
@@ -85,7 +85,7 @@ public abstract class PredicateString<T> extends Predicate<T> {
|
||||
public static PredicateString<String> contains(final String what) {
|
||||
return new PredicateString<String>(StringOp.CONTAINS) {
|
||||
@Override
|
||||
public boolean isTrue(String subject) {
|
||||
public boolean apply(String subject) {
|
||||
return op(subject, what);
|
||||
}
|
||||
};
|
||||
@@ -93,7 +93,7 @@ public abstract class PredicateString<T> extends Predicate<T> {
|
||||
public static PredicateString<String> containsIgnoreCase(final String what) {
|
||||
return new PredicateString<String>(StringOp.CONTAINS_IC) {
|
||||
@Override
|
||||
public boolean isTrue(String subject) {
|
||||
public boolean apply(String subject) {
|
||||
return op(subject, what);
|
||||
}
|
||||
};
|
||||
@@ -101,7 +101,7 @@ public abstract class PredicateString<T> extends Predicate<T> {
|
||||
public static PredicateString<String> equals(final String what) {
|
||||
return new PredicateString<String>(StringOp.EQUALS) {
|
||||
@Override
|
||||
public boolean isTrue(String subject) {
|
||||
public boolean apply(String subject) {
|
||||
return op(subject, what);
|
||||
}
|
||||
};
|
||||
@@ -109,7 +109,7 @@ public abstract class PredicateString<T> extends Predicate<T> {
|
||||
public static PredicateString<String> equalsIgnoreCase(final String what) {
|
||||
return new PredicateString<String>(StringOp.EQUALS_IC) {
|
||||
@Override
|
||||
public boolean isTrue(String subject) {
|
||||
public boolean apply(String subject) {
|
||||
return op(subject, what);
|
||||
}
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user