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

CardListFilter replaced with Predicate<Card>

Browse Source
This commit is contained in:
Maxmtg
2012-09-23 08:10:27 +00:00
parent 99a2df6a59
commit 7786ef990d
50 changed files with 718 additions and 740 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitattributes vendored
View File

@@ -11998,9 +11998,9 @@ src/main/java/forge/CardColor.java svneol=native#text/plain
src/main/java/forge/CardDamageHistory.java -text src/main/java/forge/CardDamageHistory.java -text
src/main/java/forge/CardKeywords.java svneol=native#text/plain src/main/java/forge/CardKeywords.java svneol=native#text/plain
src/main/java/forge/CardList.java svneol=native#text/plain src/main/java/forge/CardList.java svneol=native#text/plain
src/main/java/forge/CardListFilter.java svneol=native#text/plain
src/main/java/forge/CardListUtil.java svneol=native#text/plain src/main/java/forge/CardListUtil.java svneol=native#text/plain
src/main/java/forge/CardPowerToughness.java svneol=native#text/plain src/main/java/forge/CardPowerToughness.java svneol=native#text/plain
src/main/java/forge/CardPredicates.java svneol=native#text/plain
src/main/java/forge/CardType.java svneol=native#text/plain src/main/java/forge/CardType.java svneol=native#text/plain
src/main/java/forge/CardUtil.java svneol=native#text/plain src/main/java/forge/CardUtil.java svneol=native#text/plain
src/main/java/forge/Color.java svneol=native#text/plain src/main/java/forge/Color.java svneol=native#text/plain

13
src/main/java/forge/AllZoneUtil.java
View File

@@ -22,6 +22,7 @@ import java.util.List;
import forge.game.player.Player; import forge.game.player.Player;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.closures.Predicate;
/** /**
* AllZoneUtil contains static functions used to get CardLists of various cards * AllZoneUtil contains static functions used to get CardLists of various cards
@@ -98,7 +99,7 @@ public abstract class AllZoneUtil {
*/ */
public static CardList getCreaturesInPlay() { public static CardList getCreaturesInPlay() {
final CardList creats = AllZoneUtil.getCardsIn(ZoneType.Battlefield); final CardList creats = AllZoneUtil.getCardsIn(ZoneType.Battlefield);
return creats.filter(CardListFilter.CREATURES); return creats.filter(CardPredicates.CREATURES);
} }
/** /**
@@ -110,7 +111,7 @@ public abstract class AllZoneUtil {
*/ */
public static CardList getCreaturesInPlay(final Player player) { public static CardList getCreaturesInPlay(final Player player) {
final CardList creats = player.getCardsIn(ZoneType.Battlefield); final CardList creats = player.getCardsIn(ZoneType.Battlefield);
return creats.filter(CardListFilter.CREATURES); return creats.filter(CardPredicates.CREATURES);
} }
// /////////////// Lands // /////////////// Lands
@@ -123,7 +124,7 @@ public abstract class AllZoneUtil {
* @return a CardList containing all lands the given player has in play * @return a CardList containing all lands the given player has in play
*/ */
public static CardList getPlayerLandsInPlay(final Player player) { public static CardList getPlayerLandsInPlay(final Player player) {
return player.getCardsIn(ZoneType.Battlefield).filter(CardListFilter.LANDS); return player.getCardsIn(ZoneType.Battlefield).filter(CardPredicates.LANDS);
} }
/** /**
@@ -132,7 +133,7 @@ public abstract class AllZoneUtil {
* @return a CardList of all lands on the battlefield * @return a CardList of all lands on the battlefield
*/ */
public static CardList getLandsInPlay() { public static CardList getLandsInPlay() {
return AllZoneUtil.getCardsIn(ZoneType.Battlefield).filter(CardListFilter.LANDS); return AllZoneUtil.getCardsIn(ZoneType.Battlefield).filter(CardPredicates.LANDS);
} }
// ============================================================================= // =============================================================================
@@ -231,9 +232,9 @@ public abstract class AllZoneUtil {
*/ */
public static CardList getPlayerColorInPlay(final Player player, final String color) { public static CardList getPlayerColorInPlay(final Player player, final String color) {
CardList cards = player.getCardsIn(ZoneType.Battlefield); CardList cards = player.getCardsIn(ZoneType.Battlefield);
cards = cards.filter(new CardListFilter() { cards = cards.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
final List<String> colorList = CardUtil.getColors(c); final List<String> colorList = CardUtil.getColors(c);
return colorList.contains(color); return colorList.contains(color);
} }

4
src/main/java/forge/Card.java
View File

@@ -8795,10 +8795,6 @@ public class Card extends GameEntity implements Comparable<Card> {
if (source.isGreen() && !source.getName().equals("Green Ward")) { if (source.isGreen() && !source.getName().equals("Green Ward")) {
return true; return true;
} }
} else if (kw.equals("Protection from green")) {
if (source.isGreen() && !source.getName().equals("Green Ward")) {
return true;
}
} else if (kw.equals("Protection from creatures")) { } else if (kw.equals("Protection from creatures")) {
if (source.isCreature()) { if (source.isCreature()) {
return true; return true;

85
src/main/java/forge/CardList.java
View File

@@ -28,6 +28,7 @@ import forge.card.spellability.SpellAbility;
import forge.game.phase.CombatUtil; import forge.game.phase.CombatUtil;
import forge.game.player.Player; import forge.game.player.Player;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -173,9 +174,9 @@ public class CardList implements Iterable<Card> {
final CardList list = new CardList(); final CardList list = new CardList();
list.addAll(this); list.addAll(this);
final CardListFilter clrF = new CardListFilter() { final Predicate<Card> clrF = new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (c.isColorless()) { if (c.isColorless()) {
return true; return true;
} }
@@ -245,9 +246,9 @@ public class CardList implements Iterable<Card> {
* a {@link java.lang.String} object. * a {@link java.lang.String} object.
*/ */
public final void remove(final String cardName) { public final void remove(final String cardName) {
final CardList find = this.filter(new CardListFilter() { final CardList find = this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getName().equals(cardName); return c.getName().equals(cardName);
} }
}); });
@@ -471,9 +472,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getController(final Player player) { public final CardList getController(final Player player) {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getController().isPlayer(player); return c.getController().isPlayer(player);
} }
}); });
@@ -489,9 +490,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getOwner(final Player player) { public final CardList getOwner(final Player player) {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getOwner().isPlayer(player); return c.getOwner().isPlayer(player);
} }
}); });
@@ -509,9 +510,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getType(final String cardType) { public final CardList getType(final String cardType) {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.isType(cardType); return c.isType(cardType);
} }
}); });
@@ -529,9 +530,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getNotType(final String cardType) { public final CardList getNotType(final String cardType) {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !c.isType(cardType); return !c.isType(cardType);
} }
}); });
@@ -545,9 +546,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getPermanents() { public final CardList getPermanents() {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.isPermanent(); return c.isPermanent();
} }
}); });
@@ -563,9 +564,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getKeyword(final String keyword) { public final CardList getKeyword(final String keyword) {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.hasKeyword(keyword); return c.hasKeyword(keyword);
} }
}); });
@@ -581,9 +582,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getNotKeyword(final String keyword) { public final CardList getNotKeyword(final String keyword) {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !c.hasKeyword(keyword); return !c.hasKeyword(keyword);
} }
}); });
@@ -600,9 +601,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getKeywordsContain(final String keyword) { public final CardList getKeywordsContain(final String keyword) {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.keywordsContain(keyword); return c.keywordsContain(keyword);
} }
}); });
@@ -619,9 +620,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getKeywordsDontContain(final String keyword) { public final CardList getKeywordsDontContain(final String keyword) {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !c.keywordsContain(keyword); return !c.keywordsContain(keyword);
} }
}); });
@@ -635,9 +636,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getTokens() { public final CardList getTokens() {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.isToken(); return c.isToken();
} }
}); });
@@ -652,10 +653,10 @@ public class CardList implements Iterable<Card> {
* @return a subset of this CardList whose items meet the filtering * @return a subset of this CardList whose items meet the filtering
* criteria; may be empty, but never null. * criteria; may be empty, but never null.
*/ */
public final CardList filter(final CardListFilter filt) { public final CardList filter(final Predicate<Card> filt) {
final CardList result = new CardList(); final CardList result = new CardList();
for (final Card card : this) { for (final Card card : this) {
if (filt.addCard(card)) { if (filt.isTrue(card)) {
result.add(card); result.add(card);
} }
} }
@@ -789,9 +790,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getTargetableCards(final SpellAbility source) { public final CardList getTargetableCards(final SpellAbility source) {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return source.canTarget(c); return source.canTarget(c);
} }
}); });
@@ -807,9 +808,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getUnprotectedCards(final Card source) { public final CardList getUnprotectedCards(final Card source) {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !c.hasProtectionFrom(source); return !c.hasProtectionFrom(source);
} }
}); });
@@ -846,9 +847,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getValidCards(final String[] restrictions, final Player sourceController, final Card source) { public final CardList getValidCards(final String[] restrictions, final Player sourceController, final Card source) {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (c != null) && c.isValid(restrictions, sourceController, source); return (c != null) && c.isValid(restrictions, sourceController, source);
} }
}); });
@@ -862,9 +863,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getEquipMagnets() { public final CardList getEquipMagnets() {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (c.isCreature() && (c.getSVar("EquipMe").equals("Multiple") || (c.getSVar("EquipMe").equals( return (c.isCreature() && (c.getSVar("EquipMe").equals("Multiple") || (c.getSVar("EquipMe").equals(
"Once") && !c.isEquipped()))); "Once") && !c.isEquipped())));
} }
@@ -879,9 +880,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getEnchantMagnets() { public final CardList getEnchantMagnets() {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (c.isCreature() && (c.getSVar("EnchantMe").equals("Multiple") || (c.getSVar("EnchantMe").equals( return (c.isCreature() && (c.getSVar("EnchantMe").equals("Multiple") || (c.getSVar("EnchantMe").equals(
"Once") && !c.isEnchanted()))); "Once") && !c.isEnchanted())));
} }
@@ -896,9 +897,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getPossibleBlockers(final Card attacker) { public final CardList getPossibleBlockers(final Card attacker) {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (c.isCreature() && CombatUtil.canBlock(attacker, c)); return (c.isCreature() && CombatUtil.canBlock(attacker, c));
} }
}); });
@@ -960,9 +961,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getColored() { public final CardList getColored() {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (!c.isColorless()); return (!c.isColorless());
} }
}); });
@@ -977,9 +978,9 @@ public class CardList implements Iterable<Card> {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public final CardList getMonoColored(final boolean includeColorless) { public final CardList getMonoColored(final boolean includeColorless) {
return this.filter(new CardListFilter() { return this.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (CardUtil.getColors(c).size() == 1 && (includeColorless || !c.isColorless())); return (CardUtil.getColors(c).size() == 1 && (includeColorless || !c.isColorless()));
} }
}); });

241
src/main/java/forge/CardListFilter.java
View File

@@ -1,241 +0,0 @@
/*
* Forge: Play Magic: the Gathering.
* Copyright (C) 2011 Forge Team
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package forge;
/**
* <p>
* CardListFilter interface.
* </p>
*
* @author Forge
* @version $Id$
*/
public interface CardListFilter {
/**
* <p>
* addCard.
* </p>
*
* @param c
* a {@link forge.Card} object.
* @return a boolean.
*/
boolean addCard(Card c);
/**
* a CardListFilter to get all cards that are tapped.
*/
CardListFilter TAPPED = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return c.isTapped();
}
};
/**
* a CardListFilter to get all cards that are untapped.
*/
CardListFilter UNTAPPED = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return c.isUntapped();
}
};
/**
* a CardListFilter to get all creatures.
*/
CardListFilter CREATURES = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return c.isCreature();
}
};
/**
* a CardListFilter to get all enchantments.
*/
CardListFilter ENCHANTMENTS = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return c.isEnchantment();
}
};
/**
* a CardListFilter to get all equipment.
*/
CardListFilter EQUIPMENT = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return c.isEquipment();
}
};
/**
* a CardListFilter to get all unenchanted cards in a list.
*/
CardListFilter UNENCHANTED = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return !c.isEnchanted();
}
};
/**
* a CardListFilter to get all enchanted cards in a list.
*/
CardListFilter ENCHANTED = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return c.isEnchanted();
}
};
/**
* a CardListFilter to get all nontoken cards.
*/
CardListFilter NON_TOKEN = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return !c.isToken();
}
};
/**
* a CardListFilter to get all token cards.
*/
CardListFilter TOKEN = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return c.isToken();
}
};
/**
* a CardListFilter to get all nonbasic lands.
*/
CardListFilter NON_BASIC_LAND = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return !c.isBasicLand();
}
};
/**
* a CardListFilter to get all basicLands.
*/
CardListFilter BASIC_LANDS = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
// the isBasicLand() check here may be sufficient...
return c.isLand() && c.isBasicLand();
}
};
/**
* a CardListFilter to get all artifacts.
*/
CardListFilter ARTIFACTS = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return c.isArtifact();
}
};
/**
* a CardListFilter to get all nonartifacts.
*/
CardListFilter NON_ARTIFACTS = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return !c.isArtifact();
}
};
/**
* a CardListFilter to get all lands.
*/
CardListFilter LANDS = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return c.isLand();
}
};
/**
* a CardListFilter to get all nonlands.
*/
CardListFilter NON_LANDS = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return !c.isLand();
}
};
/**
* a CardListFilter to get all cards that are black.
*/
CardListFilter BLACK = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return c.isBlack();
}
};
/**
* a CardListFilter to get all cards that are blue.
*/
CardListFilter BLUE = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return c.isBlue();
}
};
/**
* a CardListFilter to get all cards that are green.
*/
CardListFilter GREEN = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return c.isGreen();
}
};
/**
* a CardListFilter to get all cards that are red.
*/
CardListFilter RED = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return c.isRed();
}
};
/**
* a CardListFilter to get all cards that are white.
*/
CardListFilter WHITE = new CardListFilter() {
@Override
public boolean addCard(final Card c) {
return c.isWhite();
}
};
}

9
src/main/java/forge/CardListUtil.java
View File

@@ -23,6 +23,7 @@ import java.util.Comparator;
import com.esotericsoftware.minlog.Log; import com.esotericsoftware.minlog.Log;
import forge.card.cardfactory.CardFactoryUtil; import forge.card.cardfactory.CardFactoryUtil;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -441,9 +442,9 @@ public class CardListUtil {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public static CardList getColor(final CardList list, final String color) { public static CardList getColor(final CardList list, final String color) {
return list.filter(new CardListFilter() { return list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return CardUtil.getColors(c).contains(color); return CardUtil.getColors(c).contains(color);
} }
}); });
@@ -459,9 +460,9 @@ public class CardListUtil {
* @return a {@link forge.CardList} object. * @return a {@link forge.CardList} object.
*/ */
public static CardList getGoldCards(final CardList list) { public static CardList getGoldCards(final CardList list) {
return list.filter(new CardListFilter() { return list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return CardUtil.getColors(c).size() >= 2; return CardUtil.getColors(c).size() >= 2;
} }
}); });

232
src/main/java/forge/CardPredicates.java Normal file
View File

@@ -0,0 +1,232 @@
/*
* Forge: Play Magic: the Gathering.
* Copyright (C) 2011 Forge Team
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package forge;
import forge.util.closures.Predicate;
/**
* <p>
* Predicate<Card> interface.
* </p>
*
* @author Forge
* @version $Id$
*/
public final class CardPredicates {
/**
* a Predicate<Card> to get all cards that are tapped.
*/
public static Predicate<Card> TAPPED = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return c.isTapped();
}
};
/**
* a Predicate<Card> to get all cards that are untapped.
*/
public static Predicate<Card> UNTAPPED = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return c.isUntapped();
}
};
/**
* a Predicate<Card> to get all creatures.
*/
public static Predicate<Card> CREATURES = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return c.isCreature();
}
};
/**
* a Predicate<Card> to get all enchantments.
*/
public static Predicate<Card> ENCHANTMENTS = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return c.isEnchantment();
}
};
/**
* a Predicate<Card> to get all equipment.
*/
public static Predicate<Card> EQUIPMENT = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return c.isEquipment();
}
};
/**
* a Predicate<Card> to get all unenchanted cards in a list.
*/
public static Predicate<Card> UNENCHANTED = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return !c.isEnchanted();
}
};
/**
* a Predicate<Card> to get all enchanted cards in a list.
*/
public static Predicate<Card> ENCHANTED = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return c.isEnchanted();
}
};
/**
* a Predicate<Card> to get all nontoken cards.
*/
public static Predicate<Card> NON_TOKEN = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return !c.isToken();
}
};
/**
* a Predicate<Card> to get all token cards.
*/
public static Predicate<Card> TOKEN = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return c.isToken();
}
};
/**
* a Predicate<Card> to get all nonbasic lands.
*/
public static Predicate<Card> NON_BASIC_LAND = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return !c.isBasicLand();
}
};
/**
* a Predicate<Card> to get all basicLands.
*/
public static Predicate<Card> BASIC_LANDS = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
// the isBasicLand() check here may be sufficient...
return c.isLand() && c.isBasicLand();
}
};
/**
* a Predicate<Card> to get all artifacts.
*/
public static Predicate<Card> ARTIFACTS = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return c.isArtifact();
}
};
/**
* a Predicate<Card> to get all nonartifacts.
*/
public static Predicate<Card> NON_ARTIFACTS = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return !c.isArtifact();
}
};
/**
* a Predicate<Card> to get all lands.
*/
public static Predicate<Card> LANDS = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return c.isLand();
}
};
/**
* a Predicate<Card> to get all nonlands.
*/
public static Predicate<Card> NON_LANDS = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return !c.isLand();
}
};
/**
* a Predicate<Card> to get all cards that are black.
*/
public static Predicate<Card> BLACK = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return c.isBlack();
}
};
/**
* a Predicate<Card> to get all cards that are blue.
*/
public static Predicate<Card> BLUE = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return c.isBlue();
}
};
/**
* a Predicate<Card> to get all cards that are green.
*/
public static Predicate<Card> GREEN = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return c.isGreen();
}
};
/**
* a Predicate<Card> to get all cards that are red.
*/
public static Predicate<Card> RED = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return c.isRed();
}
};
/**
* a Predicate<Card> to get all cards that are white.
*/
public static Predicate<Card> WHITE = new Predicate<Card>() {
@Override
public boolean isTrue(Card c) {
return c.isWhite();
}
};
}

21
src/main/java/forge/GameAction.java
View File

@@ -58,6 +58,7 @@ import forge.game.zone.PlayerZoneComesIntoPlay;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.gui.match.ViewWinLose; import forge.gui.match.ViewWinLose;
import forge.util.closures.Predicate;
/** /**
* Methods for common actions performed during a game. * Methods for common actions performed during a game.
@@ -1166,13 +1167,13 @@ public class GameAction {
} // for q=0;q<2 } // for q=0;q<2
/* /*
//Experiment Kraj experiment //Experiment Kraj experiment
CardList krajs = AllZoneUtil.getCardsIn(ZoneType.Battlefield).filter(new CardListFilter() { CardList krajs = AllZoneUtil.getCardsIn(ZoneType.Battlefield).filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(Card c) { public boolean addCard(Card c) {
return c.getName().equals("Experiment Kraj"); return c.getName().equals("Experiment Kraj");
} }
}); });
CardList P1P1s = AllZoneUtil.getCardsIn(ZoneType.Battlefield).filter(new CardListFilter() { CardList P1P1s = AllZoneUtil.getCardsIn(ZoneType.Battlefield).filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(Card c) { public boolean addCard(Card c) {
return c.getCounters(Counters.P1P1) > 0; return c.getCounters(Counters.P1P1) > 0;
@@ -1255,9 +1256,9 @@ public class GameAction {
while (!a.isEmpty()) { while (!a.isEmpty()) {
CardList b = AllZoneUtil.getCardsIn(ZoneType.Battlefield, a.get(0).getName()); CardList b = AllZoneUtil.getCardsIn(ZoneType.Battlefield, a.get(0).getName());
b = b.getType("Legendary"); b = b.getType("Legendary");
b = b.filter(new CardListFilter() { b = b.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !c.isFaceDown(); return !c.isFaceDown();
} }
}); });
@@ -1317,9 +1318,9 @@ public class GameAction {
if (c.isEnchanted()) { if (c.isEnchanted()) {
CardList list = new CardList(c.getEnchantedBy()); CardList list = new CardList(c.getEnchantedBy());
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card crd) { public boolean isTrue(final Card crd) {
return crd.hasKeyword("Totem armor"); return crd.hasKeyword("Totem armor");
} }
}); });
@@ -1500,9 +1501,9 @@ public class GameAction {
if (c.isEnchanted()) { if (c.isEnchanted()) {
CardList list = new CardList(c.getEnchantedBy()); CardList list = new CardList(c.getEnchantedBy());
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card crd) { public boolean isTrue(final Card crd) {
return crd.hasKeyword("Totem armor"); return crd.hasKeyword("Totem armor");
} }
}); });
@@ -1770,9 +1771,9 @@ public class GameAction {
} }
} else if (spell.getSourceCard().hasKeyword("Convoke")) { } else if (spell.getSourceCard().hasKeyword("Convoke")) {
CardList untappedCreats = spell.getActivatingPlayer().getCardsIn(ZoneType.Battlefield).getType("Creature"); CardList untappedCreats = spell.getActivatingPlayer().getCardsIn(ZoneType.Battlefield).getType("Creature");
untappedCreats = untappedCreats.filter(new CardListFilter() { untappedCreats = untappedCreats.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !c.isTapped(); return !c.isTapped();
} }
}); });

21
src/main/java/forge/GameActionUtil.java
View File

@@ -52,6 +52,7 @@ import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.gui.match.CMatchUI; import forge.gui.match.CMatchUI;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -859,7 +860,7 @@ public final class GameActionUtil {
public void resolve() { public void resolve() {
for (int i = 0; i < damage; i++) { for (int i = 0; i < damage; i++) {
CardList nonTokens = player.getCardsIn(ZoneType.Battlefield); CardList nonTokens = player.getCardsIn(ZoneType.Battlefield);
nonTokens = nonTokens.filter(CardListFilter.NON_TOKEN); nonTokens = nonTokens.filter(CardPredicates.NON_TOKEN);
if (nonTokens.size() == 0) { if (nonTokens.size() == 0) {
player.loseConditionMet(GameLossReason.SpellEffect, lich.getName()); player.loseConditionMet(GameLossReason.SpellEffect, lich.getName());
} else { } else {
@@ -1154,7 +1155,7 @@ public final class GameActionUtil {
produces.put("Swamp", "B"); produces.put("Swamp", "B");
CardList lands = AllZoneUtil.getCardsInGame(); CardList lands = AllZoneUtil.getCardsInGame();
lands = lands.filter(CardListFilter.LANDS); lands = lands.filter(CardPredicates.LANDS);
// remove all abilities granted by this Command // remove all abilities granted by this Command
for (final Card land : lands) { for (final Card land : lands) {
@@ -1308,9 +1309,9 @@ public final class GameActionUtil {
public void execute() { public void execute() {
CardList list = AllZoneUtil.getCardsIn(ZoneType.Battlefield); CardList list = AllZoneUtil.getCardsIn(ZoneType.Battlefield);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getName().equals("Avatar") && c.getImageName().equals("W N N Avatar"); return c.getName().equals("Avatar") && c.getImageName().equals("W N N Avatar");
} }
}); });
@@ -1370,9 +1371,9 @@ public final class GameActionUtil {
private boolean getsBonus(final Card c) { private boolean getsBonus(final Card c) {
CardList list = c.getController().getCardsIn(ZoneType.Battlefield); CardList list = c.getController().getCardsIn(ZoneType.Battlefield);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getName().equals("Guan Yu, Sainted Warrior") return c.getName().equals("Guan Yu, Sainted Warrior")
|| c.getName().equals("Zhang Fei, Fierce Warrior"); || c.getName().equals("Zhang Fei, Fierce Warrior");
} }
@@ -1390,9 +1391,9 @@ public final class GameActionUtil {
@Override @Override
public void execute() { public void execute() {
CardList list = AllZoneUtil.getCardsIn(ZoneType.Battlefield); CardList list = AllZoneUtil.getCardsIn(ZoneType.Battlefield);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getName().equals("Wolf") return c.getName().equals("Wolf")
&& c.hasKeyword("This creature gets +1/+1 for each card " && c.hasKeyword("This creature gets +1/+1 for each card "
+ "named Sound the Call in each graveyard."); + "named Sound the Call in each graveyard.");
@@ -1521,9 +1522,9 @@ public final class GameActionUtil {
public static void doPowerSink(final Player p) { public static void doPowerSink(final Player p) {
// get all lands with mana abilities // get all lands with mana abilities
CardList lands = AllZoneUtil.getPlayerLandsInPlay(p); CardList lands = AllZoneUtil.getPlayerLandsInPlay(p);
lands = lands.filter(new CardListFilter() { lands = lands.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getManaAbility().size() > 0; return c.getManaAbility().size() > 0;
} }
}); });

47
src/main/java/forge/card/abilityfactory/AbilityFactoryAttach.java
View File

@@ -27,7 +27,7 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.CardUtil; import forge.CardUtil;
import forge.Command; import forge.Command;
import forge.GameActionUtil; import forge.GameActionUtil;
@@ -49,6 +49,7 @@ import forge.game.player.Player;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
/** /**
* The Class AbilityFactory_Attach. * The Class AbilityFactory_Attach.
@@ -501,9 +502,9 @@ public class AbilityFactoryAttach {
// AI For choosing a Card to Animate. // AI For choosing a Card to Animate.
CardList betterList = list.getNotType("Creature"); CardList betterList = list.getNotType("Creature");
if (sa.getSourceCard().getName().equals("Animate Artifact")) { if (sa.getSourceCard().getName().equals("Animate Artifact")) {
betterList = betterList.filter(new CardListFilter() { betterList = betterList.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getCMC() > 0; return c.getCMC() > 0;
} }
}); });
@@ -589,9 +590,9 @@ public class AbilityFactoryAttach {
// Probably want to "weight" the list by amount of Enchantments and // Probably want to "weight" the list by amount of Enchantments and
// choose the "lightest" // choose the "lightest"
magnetList = magnetList.filter(new CardListFilter() { magnetList = magnetList.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return CombatUtil.canAttack(c); return CombatUtil.canAttack(c);
} }
}); });
@@ -635,9 +636,9 @@ public class AbilityFactoryAttach {
if (totToughness < 0) { if (totToughness < 0) {
// Don't kill my own stuff with Negative toughness Auras // Don't kill my own stuff with Negative toughness Auras
final int tgh = totToughness; final int tgh = totToughness;
prefList = prefList.filter(new CardListFilter() { prefList = prefList.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getLethalDamage() > Math.abs(tgh); return c.getLethalDamage() > Math.abs(tgh);
} }
}); });
@@ -654,11 +655,11 @@ public class AbilityFactoryAttach {
} }
if (!keywords.isEmpty()) { if (!keywords.isEmpty()) {
final ArrayList<String> finalKWs = keywords; final ArrayList<String> finalKWs = keywords;
prefList = prefList.filter(new CardListFilter() { prefList = prefList.filter(new Predicate<Card>() {
// If Aura grants only Keywords, don't Stack unstackable // If Aura grants only Keywords, don't Stack unstackable
// keywords // keywords
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
for (final String kw : finalKWs) { for (final String kw : finalKWs) {
if (c.hasKeyword(kw)) { if (c.hasKeyword(kw)) {
return false; return false;
@@ -671,9 +672,9 @@ public class AbilityFactoryAttach {
} }
// Don't pump cards that will die. // Don't pump cards that will die.
prefList = prefList.filter(new CardListFilter() { prefList = prefList.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !c.getSVar("Targeting").equals("Dies"); return !c.getSVar("Targeting").equals("Dies");
} }
}); });
@@ -681,21 +682,15 @@ public class AbilityFactoryAttach {
if (attachSource.isAura()) { if (attachSource.isAura()) {
// TODO For Auras like Rancor, that aren't as likely to lead to // TODO For Auras like Rancor, that aren't as likely to lead to
// card disadvantage, this check should be skipped // card disadvantage, this check should be skipped
prefList = prefList.filter(new CardListFilter() { prefList = prefList.filter(Predicate.not(CardPredicates.ENCHANTED));
@Override
public boolean addCard(final Card c) {
return !c.isEnchanted();
}
});
} }
if (!grantingAbilities) { if (!grantingAbilities) {
// Probably prefer to Enchant Creatures that Can Attack // Probably prefer to Enchant Creatures that Can Attack
// Filter out creatures that can't Attack or have Defender // Filter out creatures that can't Attack or have Defender
prefList = prefList.filter(new CardListFilter() { prefList = prefList.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !c.isCreature() || CombatUtil.canAttack(c); return !c.isCreature() || CombatUtil.canAttack(c);
} }
}); });
@@ -776,9 +771,9 @@ public class AbilityFactoryAttach {
if (totToughness < 0) { if (totToughness < 0) {
// Kill a creature if we can // Kill a creature if we can
final int tgh = totToughness; final int tgh = totToughness;
prefList = list.filter(new CardListFilter() { prefList = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (!c.hasKeyword("Indestructible") && (c.getLethalDamage() <= Math.abs(tgh))) { if (!c.hasKeyword("Indestructible") && (c.getLethalDamage() <= Math.abs(tgh))) {
return true; return true;
} }
@@ -802,9 +797,9 @@ public class AbilityFactoryAttach {
// things to begin with // things to begin with
if (keywords.contains("CARDNAME can't attack.") || keywords.contains("Defender") if (keywords.contains("CARDNAME can't attack.") || keywords.contains("Defender")
|| keywords.contains("CARDNAME attacks each turn if able.")) { || keywords.contains("CARDNAME attacks each turn if able.")) {
prefList = prefList.filter(new CardListFilter() { prefList = prefList.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !(c.hasKeyword("CARDNAME can't attack.") || c.hasKeyword("Defender")); return !(c.hasKeyword("CARDNAME can't attack.") || c.hasKeyword("Defender"));
} }
}); });
@@ -880,9 +875,9 @@ public class AbilityFactoryAttach {
public static Card attachAIKeepTappedPreference(final SpellAbility sa, final CardList list, public static Card attachAIKeepTappedPreference(final SpellAbility sa, final CardList list,
final boolean mandatory, final Card attachSource) { final boolean mandatory, final Card attachSource) {
// AI For Cards like Paralyzing Grasp and Glimmerdust Nap // AI For Cards like Paralyzing Grasp and Glimmerdust Nap
final CardList prefList = list.filter(new CardListFilter() { final CardList prefList = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
// Don't do Untapped Vigilance cards // Don't do Untapped Vigilance cards
if (c.isCreature() && c.hasKeyword("Vigilance") && c.isUntapped()) { if (c.isCreature() && c.hasKeyword("Vigilance") && c.isUntapped()) {
return false; return false;

27
src/main/java/forge/card/abilityfactory/AbilityFactoryChangeZone.java
View File

@@ -27,7 +27,7 @@ import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardCharacteristicName; import forge.CardCharacteristicName;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.CardListUtil; import forge.CardListUtil;
import forge.CardUtil; import forge.CardUtil;
import forge.GameActionUtil; import forge.GameActionUtil;
@@ -55,6 +55,7 @@ import forge.game.zone.PlayerZone;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -1165,9 +1166,9 @@ public final class AbilityFactoryChangeZone {
// Save a card as a default, in case we can't find anything suitable. // Save a card as a default, in case we can't find anything suitable.
Card first = fetchList.get(0); Card first = fetchList.get(0);
if (ZoneType.Battlefield.equals(destination)) { if (ZoneType.Battlefield.equals(destination)) {
fetchList = fetchList.filter(new CardListFilter() { fetchList = fetchList.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (c.isType("Legendary")) { if (c.isType("Legendary")) {
if (!AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield, c.getName()).isEmpty()) { if (!AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield, c.getName()).isEmpty()) {
return false; return false;
@@ -1177,9 +1178,9 @@ public final class AbilityFactoryChangeZone {
} }
}); });
if (player.isHuman() && params.containsKey("GainControl")) { if (player.isHuman() && params.containsKey("GainControl")) {
fetchList = fetchList.filter(new CardListFilter() { fetchList = fetchList.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (!c.getSVar("RemAIDeck").equals("") || !c.getSVar("RemRandomDeck").equals("")) { if (!c.getSVar("RemAIDeck").equals("") || !c.getSVar("RemRandomDeck").equals("")) {
return false; return false;
} }
@@ -1210,8 +1211,8 @@ public final class AbilityFactoryChangeZone {
Player ai = AllZone.getComputerPlayer(); Player ai = AllZone.getComputerPlayer();
// Does AI need a land? // Does AI need a land?
CardList hand = ai.getCardsIn(ZoneType.Hand); CardList hand = ai.getCardsIn(ZoneType.Hand);
System.out.println("Lands in hand = " + hand.filter(CardListFilter.LANDS).size() + ", on battlefield = " + ai.getCardsIn(ZoneType.Battlefield).filter(CardListFilter.LANDS).size()); System.out.println("Lands in hand = " + hand.filter(CardPredicates.LANDS).size() + ", on battlefield = " + ai.getCardsIn(ZoneType.Battlefield).filter(CardPredicates.LANDS).size());
if (hand.filter(CardListFilter.LANDS).size() == 0 && ai.getCardsIn(ZoneType.Battlefield).filter(CardListFilter.LANDS).size() < 4) { if (hand.filter(CardPredicates.LANDS).size() == 0 && ai.getCardsIn(ZoneType.Battlefield).filter(CardPredicates.LANDS).size() < 4) {
boolean canCastSomething = false; boolean canCastSomething = false;
for (Card cardInHand : hand) { for (Card cardInHand : hand) {
canCastSomething |= ComputerUtil.payManaCost(cardInHand.getFirstSpellAbility(), AllZone.getComputerPlayer(), true, 0, false); canCastSomething |= ComputerUtil.payManaCost(cardInHand.getFirstSpellAbility(), AllZone.getComputerPlayer(), true, 0, false);
@@ -1659,9 +1660,9 @@ public final class AbilityFactoryChangeZone {
CardList aiPermanents = list.getController(AllZone.getComputerPlayer()); CardList aiPermanents = list.getController(AllZone.getComputerPlayer());
// Don't blink cards that will die. // Don't blink cards that will die.
aiPermanents = aiPermanents.filter(new CardListFilter() { aiPermanents = aiPermanents.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !c.getSVar("Targeting").equals("Dies"); return !c.getSVar("Targeting").equals("Dies");
} }
}); });
@@ -1704,9 +1705,9 @@ public final class AbilityFactoryChangeZone {
} }
// Blink permanents with ETB triggers // Blink permanents with ETB triggers
else if (sa.isAbility() && (sa.getPayCosts() != null) && AbilityFactory.playReusable(sa)) { else if (sa.isAbility() && (sa.getPayCosts() != null) && AbilityFactory.playReusable(sa)) {
aiPermanents = aiPermanents.filter(new CardListFilter() { aiPermanents = aiPermanents.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (c.getNumberOfCounters() > 0) { if (c.getNumberOfCounters() > 0) {
return false; // don't blink something with return false; // don't blink something with
} }
@@ -1753,9 +1754,9 @@ public final class AbilityFactoryChangeZone {
return false; return false;
} }
list = list.getController(AllZone.getHumanPlayer()); list = list.getController(AllZone.getHumanPlayer());
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
for (Card aura : c.getEnchantedBy()) { for (Card aura : c.getEnchantedBy()) {
if (c.getOwner().isHuman() && aura.getController().isComputer()) { if (c.getOwner().isHuman() && aura.getController().isComputer()) {
return false; return false;

14
src/main/java/forge/card/abilityfactory/AbilityFactoryChoose.java
View File

@@ -33,7 +33,7 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.CardUtil; import forge.CardUtil;
import forge.Constant; import forge.Constant;
import forge.card.cardfactory.CardFactoryUtil; import forge.card.cardfactory.CardFactoryUtil;
@@ -51,6 +51,7 @@ import forge.gui.ListChooser;
import forge.item.CardDb; import forge.item.CardDb;
import forge.item.CardPrinted; import forge.item.CardPrinted;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -1642,12 +1643,7 @@ public final class AbilityFactoryChoose {
} }
} else { } else {
CardList list = AllZoneUtil.getCardsInGame().getController(AllZone.getHumanPlayer()); CardList list = AllZoneUtil.getCardsInGame().getController(AllZone.getHumanPlayer());
list = list.filter(new CardListFilter() { list = list.filter(Predicate.not(CardPredicates.LANDS));
@Override
public boolean addCard(final Card c) {
return !c.isLand();
}
});
if (!list.isEmpty()) { if (!list.isEmpty()) {
chosen = list.get(0).getName(); chosen = list.get(0).getName();
} }
@@ -1980,8 +1976,8 @@ public final class AbilityFactoryChoose {
} }
} else { // Computer } else { // Computer
if (params.containsKey("AILogic") && params.get("AILogic").equals("BestBlocker")) { if (params.containsKey("AILogic") && params.get("AILogic").equals("BestBlocker")) {
if (choices.filter(CardListFilter.UNTAPPED).isEmpty()) { if (choices.filter(CardPredicates.UNTAPPED).isEmpty()) {
choices = choices.filter(CardListFilter.UNTAPPED); choices = choices.filter(CardPredicates.UNTAPPED);
} }
chosen.add(CardFactoryUtil.getBestCreatureAI(choices)); chosen.add(CardFactoryUtil.getBestCreatureAI(choices));
} else { } else {

6
src/main/java/forge/card/abilityfactory/AbilityFactoryCombat.java
View File

@@ -23,7 +23,6 @@ import java.util.HashMap;
import forge.AllZone; import forge.AllZone;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.Singletons; import forge.Singletons;
import forge.card.cardfactory.CardFactoryUtil; import forge.card.cardfactory.CardFactoryUtil;
import forge.card.spellability.AbilityActivated; import forge.card.spellability.AbilityActivated;
@@ -37,6 +36,7 @@ import forge.game.phase.PhaseType;
import forge.game.player.ComputerUtil; import forge.game.player.ComputerUtil;
import forge.game.player.Player; import forge.game.player.Player;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -1060,9 +1060,9 @@ public final class AbilityFactoryCombat {
CardList list = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield).getType("Creature"); CardList list = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield).getType("Creature");
list = list.getTargetableCards(sa); list = list.getTargetableCards(sa);
list = list.getValidCards(abTgt.getValidTgts(), source.getController(), source); list = list.getValidCards(abTgt.getValidTgts(), source.getController(), source);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
boolean tapped = c.isTapped(); boolean tapped = c.isTapped();
c.setTapped(false); c.setTapped(false);
if (!CombatUtil.canBlock(definedAttacker, c)) { if (!CombatUtil.canBlock(definedAttacker, c)) {

4
src/main/java/forge/card/abilityfactory/AbilityFactoryCopy.java
View File

@@ -28,7 +28,7 @@ import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardCharacteristicName; import forge.CardCharacteristicName;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.Command; import forge.Command;
import forge.Singletons; import forge.Singletons;
import forge.card.cost.Cost; import forge.card.cost.Cost;
@@ -323,7 +323,7 @@ public final class AbilityFactoryCopy {
} }
Card choice; Card choice;
if (list.filter(CardListFilter.CREATURES).size() > 0) { if (list.filter(CardPredicates.CREATURES).size() > 0) {
choice = CardFactoryUtil.getBestCreatureAI(list); choice = CardFactoryUtil.getBestCreatureAI(list);
} else { } else {
choice = CardFactoryUtil.getMostExpensivePermanentAI(list, sa, true); choice = CardFactoryUtil.getMostExpensivePermanentAI(list, sa, true);

38
src/main/java/forge/card/abilityfactory/AbilityFactoryCounters.java
View File

@@ -28,7 +28,6 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.Counters; import forge.Counters;
import forge.Singletons; import forge.Singletons;
import forge.card.cardfactory.CardFactoryUtil; import forge.card.cardfactory.CardFactoryUtil;
@@ -49,6 +48,7 @@ import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.gui.match.CMatchUI; import forge.gui.match.CMatchUI;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
import forge.view.ButtonUtil; import forge.view.ButtonUtil;
/** /**
@@ -310,9 +310,9 @@ public class AbilityFactoryCounters {
final Player player = af.isCurse() ? AllZone.getHumanPlayer() : AllZone.getComputerPlayer(); final Player player = af.isCurse() ? AllZone.getHumanPlayer() : AllZone.getComputerPlayer();
list = player.getCardsIn(ZoneType.Battlefield); list = player.getCardsIn(ZoneType.Battlefield);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.canBeTargetedBy(sa) && !c.hasKeyword("CARDNAME can't have counters placed on it.") 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")); && !(c.hasKeyword("CARDNAME can't have -1/-1 counters placed on it.") && type.equals("M1M1"));
} }
@@ -474,9 +474,9 @@ public class AbilityFactoryCounters {
abTgt.resetTargets(); abTgt.resetTargets();
// target loop // target loop
while (abTgt.getNumTargeted() < abTgt.getMaxTargets(sa.getSourceCard(), sa)) { while (abTgt.getNumTargeted() < abTgt.getMaxTargets(sa.getSourceCard(), sa)) {
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return sa.canTarget(c); return sa.canTarget(c);
} }
}); });
@@ -656,9 +656,9 @@ public class AbilityFactoryCounters {
Card choice; Card choice;
if (type.equals("M1M1")) { if (type.equals("M1M1")) {
// try to kill the best killable creature, or reduce the best one // try to kill the best killable creature, or reduce the best one
final CardList killable = list.filter(new CardListFilter() { final CardList killable = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getNetDefense() <= amount; return c.getNetDefense() <= amount;
} }
}); });
@@ -690,9 +690,9 @@ public class AbilityFactoryCounters {
if (type.equals("P1P1")) { if (type.equals("P1P1")) {
choice = CardFactoryUtil.getBestCreatureAI(list); choice = CardFactoryUtil.getBestCreatureAI(list);
} else if (type.equals("DIVINITY")) { } else if (type.equals("DIVINITY")) {
final CardList boon = list.filter(new CardListFilter() { final CardList boon = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getCounters(Counters.DIVINITY) == 0; return c.getCounters(Counters.DIVINITY) == 0;
} }
}); });
@@ -1445,9 +1445,9 @@ public class AbilityFactoryCounters {
} }
CardList hperms = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield); CardList hperms = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield);
CardList cperms = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield); CardList cperms = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
cperms = cperms.filter(new CardListFilter() { cperms = cperms.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card crd) { public boolean isTrue(final Card crd) {
for (final Counters c1 : Counters.values()) { for (final Counters c1 : Counters.values()) {
if (crd.getCounters(c1) != 0 && !CardFactoryUtil.isNegativeCounter(c1)) { if (crd.getCounters(c1) != 0 && !CardFactoryUtil.isNegativeCounter(c1)) {
return true; return true;
@@ -1457,9 +1457,9 @@ public class AbilityFactoryCounters {
} }
}); });
hperms = hperms.filter(new CardListFilter() { hperms = hperms.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card crd) { public boolean isTrue(final Card crd) {
for (final Counters c1 : Counters.values()) { for (final Counters c1 : Counters.values()) {
if (crd.getCounters(c1) != 0 && CardFactoryUtil.isNegativeCounter(c1)) { if (crd.getCounters(c1) != 0 && CardFactoryUtil.isNegativeCounter(c1)) {
return true; return true;
@@ -1573,9 +1573,9 @@ public class AbilityFactoryCounters {
} }
}); });
} else { // Compy } else { // Compy
cperms = cperms.filter(new CardListFilter() { cperms = cperms.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card crd) { public boolean isTrue(final Card crd) {
for (final Counters c1 : Counters.values()) { for (final Counters c1 : Counters.values()) {
if (crd.getCounters(c1) != 0) { if (crd.getCounters(c1) != 0) {
if (!CardFactoryUtil.isNegativeCounter(c1)) { if (!CardFactoryUtil.isNegativeCounter(c1)) {
@@ -1587,9 +1587,9 @@ public class AbilityFactoryCounters {
} }
}); });
hperms = hperms.filter(new CardListFilter() { hperms = hperms.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card crd) { public boolean isTrue(final Card crd) {
for (final Counters c1 : Counters.values()) { for (final Counters c1 : Counters.values()) {
if (crd.getCounters(c1) != 0) { if (crd.getCounters(c1) != 0) {
if (CardFactoryUtil.isNegativeCounter(c1)) { if (CardFactoryUtil.isNegativeCounter(c1)) {
@@ -1916,9 +1916,9 @@ public class AbilityFactoryCounters {
if (curse) { if (curse) {
if (type.equals("M1M1")) { if (type.equals("M1M1")) {
final CardList killable = hList.filter(new CardListFilter() { final CardList killable = hList.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getNetDefense() <= amount; return c.getNetDefense() <= amount;
} }
}); });

14
src/main/java/forge/card/abilityfactory/AbilityFactoryDealDamage.java
View File

@@ -25,7 +25,6 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.CardUtil; import forge.CardUtil;
import forge.Singletons; import forge.Singletons;
import forge.card.cardfactory.CardFactoryUtil; import forge.card.cardfactory.CardFactoryUtil;
@@ -43,6 +42,7 @@ import forge.game.player.ComputerUtil;
import forge.game.player.Player; import forge.game.player.Player;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -534,9 +534,9 @@ public class AbilityFactoryDealDamage {
} }
hPlay = hPlay.getTargetableCards(saMe); hPlay = hPlay.getTargetableCards(saMe);
final CardList killables = hPlay.filter(new CardListFilter() { final CardList killables = hPlay.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (c.getEnoughDamageToKill(d, source, false, noPrevention) <= d) && !ComputerUtil.canRegenerate(c) return (c.getEnoughDamageToKill(d, source, false, noPrevention) <= d) && !ComputerUtil.canRegenerate(c)
&& !(c.getSVar("SacMe").length() > 0); && !(c.getSVar("SacMe").length() > 0);
} }
@@ -1231,9 +1231,9 @@ public class AbilityFactoryDealDamage {
CardList list = player.getCardsIn(ZoneType.Battlefield); CardList list = player.getCardsIn(ZoneType.Battlefield);
list = list.getValidCards(validC.split(","), source.getController(), source); list = list.getValidCards(validC.split(","), source.getController(), source);
final CardListFilter filterKillable = new CardListFilter() { final Predicate<Card> filterKillable = new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (c.predictDamage(dmg, source, false) >= c.getKillDamage()); return (c.predictDamage(dmg, source, false) >= c.getKillDamage());
} }
}; };
@@ -1863,9 +1863,9 @@ public class AbilityFactoryDealDamage {
CardList aiCreatures = AllZoneUtil.getCreaturesInPlay(AllZone.getComputerPlayer()); CardList aiCreatures = AllZoneUtil.getCreaturesInPlay(AllZone.getComputerPlayer());
aiCreatures = aiCreatures.getTargetableCards(sa); aiCreatures = aiCreatures.getTargetableCards(sa);
aiCreatures = aiCreatures.filter(new CardListFilter() { aiCreatures = aiCreatures.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !c.getSVar("Targeting").equals("Dies"); return !c.getSVar("Targeting").equals("Dies");
} }
}); });

10
src/main/java/forge/card/abilityfactory/AbilityFactoryDebuff.java
View File

@@ -27,7 +27,6 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.Command; import forge.Command;
import forge.Singletons; import forge.Singletons;
import forge.card.cardfactory.CardFactoryUtil; import forge.card.cardfactory.CardFactoryUtil;
@@ -44,6 +43,7 @@ import forge.game.phase.PhaseType;
import forge.game.player.ComputerUtil; import forge.game.player.ComputerUtil;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -448,9 +448,9 @@ public final class AbilityFactoryDebuff {
list = list.getTargetableCards(sa); list = list.getTargetableCards(sa);
if (!list.isEmpty()) { if (!list.isEmpty()) {
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.hasAnyKeyword(kws); // don't add duplicate negative return c.hasAnyKeyword(kws); // don't add duplicate negative
// keywords // keywords
} }
@@ -797,9 +797,9 @@ public final class AbilityFactoryDebuff {
// TODO - add blocking situations here also // TODO - add blocking situations here also
// only count creatures that can attack // only count creatures that can attack
human = human.filter(new CardListFilter() { human = human.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return CombatUtil.canAttack(c); return CombatUtil.canAttack(c);
} }
}); });

30
src/main/java/forge/card/abilityfactory/AbilityFactoryDestroy.java
View File

@@ -26,7 +26,6 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.CardUtil; import forge.CardUtil;
import forge.Counters; import forge.Counters;
import forge.Singletons; import forge.Singletons;
@@ -42,6 +41,7 @@ import forge.game.player.ComputerUtil;
import forge.game.player.Player; import forge.game.player.Player;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -252,9 +252,9 @@ public class AbilityFactoryDestroy {
} }
list = list.getNotKeyword("Indestructible"); list = list.getNotKeyword("Indestructible");
if (!AbilityFactory.playReusable(sa)) { if (!AbilityFactory.playReusable(sa)) {
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (!c.hasKeyword("Undying") || c.getCounters(Counters.P1P1) > 0); return (!c.hasKeyword("Undying") || c.getCounters(Counters.P1P1) > 0);
} }
}); });
@@ -264,9 +264,9 @@ public class AbilityFactoryDestroy {
// regeneration shield // regeneration shield
if (!noRegen) { if (!noRegen) {
// TODO filter out things that might be tougher? // TODO filter out things that might be tougher?
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return ((c.getShield() == 0) && !ComputerUtil.canRegenerate(c)); return ((c.getShield() == 0) && !ComputerUtil.canRegenerate(c));
} }
}); });
@@ -392,9 +392,9 @@ public class AbilityFactoryDestroy {
if (!noRegen) { if (!noRegen) {
// TODO filter out things that could regenerate in response? // TODO filter out things that could regenerate in response?
// might be tougher? // might be tougher?
preferred = preferred.filter(new CardListFilter() { preferred = preferred.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getShield() == 0; return c.getShield() == 0;
} }
}); });
@@ -860,15 +860,15 @@ public class AbilityFactoryDestroy {
} }
humanlist = humanlist.getValidCards(valid.split(","), source.getController(), source); humanlist = humanlist.getValidCards(valid.split(","), source.getController(), source);
computerlist = computerlist.getValidCards(valid.split(","), source.getController(), source); computerlist = computerlist.getValidCards(valid.split(","), source.getController(), source);
humanlist = humanlist.filter(new CardListFilter() { humanlist = humanlist.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !(c.hasKeyword("Indestructible") || c.getSVar("SacMe").length() > 0); return !(c.hasKeyword("Indestructible") || c.getSVar("SacMe").length() > 0);
} }
}); });
computerlist = computerlist.filter(new CardListFilter() { computerlist = computerlist.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !(c.hasKeyword("Indestructible") || c.getSVar("SacMe").length() > 0); return !(c.hasKeyword("Indestructible") || c.getSVar("SacMe").length() > 0);
} }
}); });
@@ -943,15 +943,15 @@ public class AbilityFactoryDestroy {
humanlist = humanlist.getValidCards(valid.split(","), source.getController(), source); humanlist = humanlist.getValidCards(valid.split(","), source.getController(), source);
computerlist = computerlist.getValidCards(valid.split(","), source.getController(), source); computerlist = computerlist.getValidCards(valid.split(","), source.getController(), source);
humanlist = humanlist.filter(new CardListFilter() { humanlist = humanlist.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !(c.hasKeyword("Indestructible") || c.getSVar("SacMe").length() > 0); return !(c.hasKeyword("Indestructible") || c.getSVar("SacMe").length() > 0);
} }
}); });
computerlist = computerlist.filter(new CardListFilter() { computerlist = computerlist.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !(c.hasKeyword("Indestructible") || c.getSVar("SacMe").length() > 0); return !(c.hasKeyword("Indestructible") || c.getSVar("SacMe").length() > 0);
} }
}); });

10
src/main/java/forge/card/abilityfactory/AbilityFactoryEffect.java
View File

@@ -25,7 +25,6 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.Command; import forge.Command;
import forge.Singletons; import forge.Singletons;
import forge.card.cardfactory.CardFactoryUtil; import forge.card.cardfactory.CardFactoryUtil;
@@ -47,6 +46,7 @@ import forge.game.player.ComputerUtil;
import forge.game.player.Player; import forge.game.player.Player;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -299,15 +299,15 @@ public class AbilityFactoryEffect {
CardList human = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield).getType("Creature"); CardList human = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield).getType("Creature");
// only count creatures that can attack or block // only count creatures that can attack or block
comp = comp.filter(new CardListFilter() { comp = comp.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return CombatUtil.canAttack(c); return CombatUtil.canAttack(c);
} }
}); });
human = human.filter(new CardListFilter() { human = human.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return CombatUtil.canBlock(c); return CombatUtil.canBlock(c);
} }
}); });

10
src/main/java/forge/card/abilityfactory/AbilityFactoryGainControl.java
View File

@@ -26,7 +26,6 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.Command; import forge.Command;
import forge.GameEntity; import forge.GameEntity;
import forge.Singletons; import forge.Singletons;
@@ -43,6 +42,7 @@ import forge.game.player.ComputerUtil;
import forge.game.player.Player; import forge.game.player.Player;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
//AB:GainControl|ValidTgts$Creature|TgtPrompt$Select target legendary creature|LoseControl$Untap,LoseControl|SpellDescription$Gain control of target xxxxxxx //AB:GainControl|ValidTgts$Creature|TgtPrompt$Select target legendary creature|LoseControl$Untap,LoseControl|SpellDescription$Gain control of target xxxxxxx
@@ -335,9 +335,9 @@ public class AbilityFactoryGainControl {
list = list.getValidCards(tgt.getValidTgts(), sa.getSourceCard().getController(), sa.getSourceCard()); list = list.getValidCards(tgt.getValidTgts(), sa.getSourceCard().getController(), sa.getSourceCard());
// AI won't try to grab cards that are filtered out of AI decks on // AI won't try to grab cards that are filtered out of AI decks on
// purpose // purpose
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
final Map<String, String> vars = c.getSVars(); final Map<String, String> vars = c.getSVars();
return !vars.containsKey("RemAIDeck") && c.canBeTargetedBy(sa); return !vars.containsKey("RemAIDeck") && c.canBeTargetedBy(sa);
} }
@@ -854,9 +854,9 @@ public class AbilityFactoryGainControl {
list = list.getValidCards(tgt.getValidTgts(), AllZone.getComputerPlayer(), sa.getSourceCard()); list = list.getValidCards(tgt.getValidTgts(), AllZone.getComputerPlayer(), sa.getSourceCard());
// AI won't try to grab cards that are filtered out of AI decks on // AI won't try to grab cards that are filtered out of AI decks on
// purpose // purpose
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
final Map<String, String> vars = c.getSVars(); final Map<String, String> vars = c.getSVars();
return !vars.containsKey("RemAIDeck") && c.canBeTargetedBy(sa); return !vars.containsKey("RemAIDeck") && c.canBeTargetedBy(sa);
} }

45
src/main/java/forge/card/abilityfactory/AbilityFactoryPermanentState.java
View File

@@ -26,7 +26,7 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.Singletons; import forge.Singletons;
import forge.card.cardfactory.CardFactoryUtil; import forge.card.cardfactory.CardFactoryUtil;
import forge.card.cost.Cost; import forge.card.cost.Cost;
@@ -44,6 +44,7 @@ import forge.game.player.Player;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -402,7 +403,7 @@ public class AbilityFactoryPermanentState {
untapList = untapList.getTargetableCards(sa); untapList = untapList.getTargetableCards(sa);
untapList = untapList.getValidCards(tgt.getValidTgts(), source.getController(), source); untapList = untapList.getValidCards(tgt.getValidTgts(), source.getController(), source);
untapList = untapList.filter(CardListFilter.TAPPED); untapList = untapList.filter(CardPredicates.TAPPED);
// filter out enchantments and planeswalkers, their tapped state doesn't // filter out enchantments and planeswalkers, their tapped state doesn't
// matter. // matter.
final String[] tappablePermanents = { "Creature", "Land", "Artifact" }; final String[] tappablePermanents = { "Creature", "Land", "Artifact" };
@@ -485,7 +486,7 @@ public class AbilityFactoryPermanentState {
} }
// try to just tap already tapped things // try to just tap already tapped things
tapList = list.filter(CardListFilter.UNTAPPED); tapList = list.filter(CardPredicates.UNTAPPED);
if (AbilityFactoryPermanentState.untapTargetList(source, tgt, af, sa, mandatory, tapList)) { if (AbilityFactoryPermanentState.untapTargetList(source, tgt, af, sa, mandatory, tapList)) {
return true; return true;
@@ -633,7 +634,7 @@ public class AbilityFactoryPermanentState {
} else { } else {
CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield); CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
list = list.getType(valid); list = list.getType(valid);
list = list.filter(CardListFilter.TAPPED); list = list.filter(CardPredicates.TAPPED);
int count = 0; int count = 0;
while ((list.size() != 0) && (count < num)) { while ((list.size() != 0) && (count < num)) {
@@ -995,7 +996,7 @@ public class AbilityFactoryPermanentState {
private static boolean tapPrefTargeting(final Card source, final Target tgt, final AbilityFactory af, private static boolean tapPrefTargeting(final Card source, final Target tgt, final AbilityFactory af,
final SpellAbility sa, final boolean mandatory) { final SpellAbility sa, final boolean mandatory) {
CardList tapList = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield); CardList tapList = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield);
tapList = tapList.filter(CardListFilter.UNTAPPED); tapList = tapList.filter(CardPredicates.UNTAPPED);
tapList = tapList.getValidCards(tgt.getValidTgts(), source.getController(), source); tapList = tapList.getValidCards(tgt.getValidTgts(), source.getController(), source);
// filter out enchantments and planeswalkers, their tapped state doesn't matter. // filter out enchantments and planeswalkers, their tapped state doesn't matter.
final String[] tappablePermanents = { "Creature", "Land", "Artifact" }; final String[] tappablePermanents = { "Creature", "Land", "Artifact" };
@@ -1031,9 +1032,9 @@ public class AbilityFactoryPermanentState {
if (phase.getPhase().isAfter(PhaseType.COMBAT_DECLARE_ATTACKERS)) { if (phase.getPhase().isAfter(PhaseType.COMBAT_DECLARE_ATTACKERS)) {
//Combat has already started //Combat has already started
final CardList attackers = AllZone.getCombat().getAttackerList(); final CardList attackers = AllZone.getCombat().getAttackerList();
CardList creatureList = tapList.filter(new CardListFilter() { CardList creatureList = tapList.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (c.isCreature()) { if (c.isCreature()) {
return CombatUtil.canBlockAtLeastOne(c, attackers); return CombatUtil.canBlockAtLeastOne(c, attackers);
} }
@@ -1046,9 +1047,9 @@ public class AbilityFactoryPermanentState {
} else { } else {
final CardList attackers = ComputerUtil.getPossibleAttackers(); final CardList attackers = ComputerUtil.getPossibleAttackers();
attackers.remove(sa.getSourceCard()); attackers.remove(sa.getSourceCard());
CardList creatureList = tapList.filter(new CardListFilter() { CardList creatureList = tapList.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (c.isCreature()) { if (c.isCreature()) {
return CombatUtil.canBlockAtLeastOne(c, attackers); return CombatUtil.canBlockAtLeastOne(c, attackers);
} }
@@ -1063,9 +1064,9 @@ public class AbilityFactoryPermanentState {
&& phase.getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)) { && phase.getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)) {
// Tap creatures possible blockers before combat during AI's turn. // Tap creatures possible blockers before combat during AI's turn.
if (!tapList.getType("Creature").isEmpty()) { if (!tapList.getType("Creature").isEmpty()) {
CardList creatureList = tapList.filter(new CardListFilter() { CardList creatureList = tapList.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (c.isCreature()) { if (c.isCreature()) {
return CombatUtil.canAttack(c); return CombatUtil.canAttack(c);
} }
@@ -1132,7 +1133,7 @@ public class AbilityFactoryPermanentState {
} }
// try to just tap already tapped things // try to just tap already tapped things
tapList = list.filter(CardListFilter.TAPPED); tapList = list.filter(CardPredicates.TAPPED);
if (AbilityFactoryPermanentState.tapTargetList(af, sa, tapList, mandatory)) { if (AbilityFactoryPermanentState.tapTargetList(af, sa, tapList, mandatory)) {
return true; return true;
@@ -1751,7 +1752,7 @@ public class AbilityFactoryPermanentState {
} }
validTappables = validTappables.getValidCards(valid, source.getController(), source); validTappables = validTappables.getValidCards(valid, source.getController(), source);
validTappables = validTappables.filter(CardListFilter.UNTAPPED); validTappables = validTappables.filter(CardPredicates.UNTAPPED);
final Random r = MyRandom.getRandom(); final Random r = MyRandom.getRandom();
boolean rr = false; boolean rr = false;
@@ -1760,15 +1761,15 @@ public class AbilityFactoryPermanentState {
} }
if (validTappables.size() > 0) { if (validTappables.size() > 0) {
final CardList human = validTappables.filter(new CardListFilter() { final CardList human = validTappables.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getController().isHuman(); return c.getController().isHuman();
} }
}); });
final CardList compy = validTappables.filter(new CardListFilter() { final CardList compy = validTappables.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getController().isComputer(); return c.getController().isComputer();
} }
}); });
@@ -1793,7 +1794,7 @@ public class AbilityFactoryPermanentState {
private static CardList getTapAllTargets(final String valid, final Card source) { private static CardList getTapAllTargets(final String valid, final Card source) {
CardList tmpList = AllZoneUtil.getCardsIn(ZoneType.Battlefield); CardList tmpList = AllZoneUtil.getCardsIn(ZoneType.Battlefield);
tmpList = tmpList.getValidCards(valid, source.getController(), source); tmpList = tmpList.getValidCards(valid, source.getController(), source);
tmpList = tmpList.filter(CardListFilter.UNTAPPED); tmpList = tmpList.filter(CardPredicates.UNTAPPED);
return tmpList; return tmpList;
} }
@@ -1875,15 +1876,15 @@ public class AbilityFactoryPermanentState {
} }
if (validTappables.size() > 0) { if (validTappables.size() > 0) {
final CardList human = validTappables.filter(new CardListFilter() { final CardList human = validTappables.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getController().isHuman(); return c.getController().isHuman();
} }
}); });
final CardList compy = validTappables.filter(new CardListFilter() { final CardList compy = validTappables.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getController().isComputer(); return c.getController().isComputer();
} }
}); });

6
src/main/java/forge/card/abilityfactory/AbilityFactoryPlay.java
View File

@@ -27,7 +27,6 @@ import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardCharacteristicName; import forge.CardCharacteristicName;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.GameActionUtil; import forge.GameActionUtil;
import forge.Singletons; import forge.Singletons;
import forge.card.cardfactory.CardFactoryUtil; import forge.card.cardfactory.CardFactoryUtil;
@@ -46,6 +45,7 @@ import forge.game.player.Player;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
* AbilityFactory_Copy class. * AbilityFactory_Copy class.
@@ -393,9 +393,9 @@ public final class AbilityFactoryPlay {
tgtCard = GuiUtils.chooseOne("Select a card to play", tgtCards); tgtCard = GuiUtils.chooseOne("Select a card to play", tgtCards);
} else { } else {
// AI // AI
tgtCards = tgtCards.filter(new CardListFilter() { tgtCards = tgtCards.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
ArrayList<SpellAbility> spellAbilities = c.getBasicSpells(); ArrayList<SpellAbility> spellAbilities = c.getBasicSpells();
ArrayList<SpellAbility> sas = new ArrayList<SpellAbility>(); ArrayList<SpellAbility> sas = new ArrayList<SpellAbility>();
for (SpellAbility s : spellAbilities) { for (SpellAbility s : spellAbilities) {

18
src/main/java/forge/card/abilityfactory/AbilityFactoryProtection.java
View File

@@ -28,7 +28,6 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.CardUtil; import forge.CardUtil;
import forge.Command; import forge.Command;
import forge.Constant; import forge.Constant;
@@ -47,6 +46,7 @@ import forge.game.player.ComputerUtil;
import forge.game.player.Player; import forge.game.player.Player;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -246,9 +246,9 @@ public final class AbilityFactoryProtection {
final ArrayList<String> gains = AbilityFactoryProtection.getProtectionList(hostCard, af.getMapParams()); final ArrayList<String> gains = AbilityFactoryProtection.getProtectionList(hostCard, af.getMapParams());
CardList list = AllZoneUtil.getCreaturesInPlay(AllZone.getComputerPlayer()); CardList list = AllZoneUtil.getCreaturesInPlay(AllZone.getComputerPlayer());
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (!c.canBeTargetedBy(sa)) { if (!c.canBeTargetedBy(sa)) {
return false; return false;
} }
@@ -414,9 +414,9 @@ public final class AbilityFactoryProtection {
} }
// Don't target cards that will die. // Don't target cards that will die.
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
System.out.println("Not Protecting"); System.out.println("Not Protecting");
return !c.getSVar("Targeting").equals("Dies"); return !c.getSVar("Targeting").equals("Dies");
} }
@@ -481,17 +481,17 @@ public final class AbilityFactoryProtection {
} }
CardList pref = list.getController(AllZone.getComputerPlayer()); CardList pref = list.getController(AllZone.getComputerPlayer());
pref = pref.filter(new CardListFilter() { pref = pref.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !AbilityFactoryProtection.hasProtectionFromAll(c, return !AbilityFactoryProtection.hasProtectionFromAll(c,
AbilityFactoryProtection.getProtectionList(host, params)); AbilityFactoryProtection.getProtectionList(host, params));
} }
}); });
final CardList pref2 = list.getController(AllZone.getComputerPlayer()); final CardList pref2 = list.getController(AllZone.getComputerPlayer());
pref = pref.filter(new CardListFilter() { pref = pref.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !AbilityFactoryProtection.hasProtectionFromAny(c, return !AbilityFactoryProtection.hasProtectionFromAny(c,
AbilityFactoryProtection.getProtectionList(host, params)); AbilityFactoryProtection.getProtectionList(host, params));
} }

34
src/main/java/forge/card/abilityfactory/AbilityFactoryPump.java
View File

@@ -26,7 +26,6 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.CardListUtil; import forge.CardListUtil;
import forge.CardUtil; import forge.CardUtil;
import forge.Command; import forge.Command;
@@ -51,6 +50,7 @@ import forge.game.player.ComputerUtil;
import forge.game.player.Player; import forge.game.player.Player;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -670,9 +670,9 @@ public class AbilityFactoryPump {
private CardList getPumpCreatures(final SpellAbility sa) { private CardList getPumpCreatures(final SpellAbility sa) {
CardList list = AllZoneUtil.getCreaturesInPlay(AllZone.getComputerPlayer()); CardList list = AllZoneUtil.getCreaturesInPlay(AllZone.getComputerPlayer());
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return shouldPumpCard(sa, c); return shouldPumpCard(sa, c);
} }
}); });
@@ -698,9 +698,9 @@ public class AbilityFactoryPump {
if ((defense < 0) && !list.isEmpty()) { // with spells that give -X/-X, if ((defense < 0) && !list.isEmpty()) { // with spells that give -X/-X,
// compi will try to destroy a // compi will try to destroy a
// creature // creature
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (c.getNetDefense() <= -defense) { if (c.getNetDefense() <= -defense) {
return true; // can kill indestructible creatures return true; // can kill indestructible creatures
} }
@@ -722,9 +722,9 @@ public class AbilityFactoryPump {
} else { } else {
// Human active, only curse attacking creatures // Human active, only curse attacking creatures
if (Singletons.getModel().getGameState().getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS)) { if (Singletons.getModel().getGameState().getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (!c.isAttacking()) { if (!c.isAttacking()) {
return false; return false;
} }
@@ -749,9 +749,9 @@ public class AbilityFactoryPump {
final boolean addsKeywords = this.keywords.size() > 0; final boolean addsKeywords = this.keywords.size() > 0;
if (addsKeywords) { if (addsKeywords) {
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return containsUsefulKeyword(keywords, c, sa); return containsUsefulKeyword(keywords, c, sa);
} }
}); });
@@ -997,9 +997,9 @@ public class AbilityFactoryPump {
if (!this.abilityFactory.isCurse()) { if (!this.abilityFactory.isCurse()) {
// Don't target cards that will die. // Don't target cards that will die.
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !c.getSVar("Targeting").equals("Dies"); return !c.getSVar("Targeting").equals("Dies");
} }
}); });
@@ -1704,18 +1704,18 @@ public class AbilityFactoryPump {
if (this.abilityFactory.isCurse()) { if (this.abilityFactory.isCurse()) {
if (defense < 0) { // try to destroy creatures if (defense < 0) { // try to destroy creatures
comp = comp.filter(new CardListFilter() { comp = comp.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (c.getNetDefense() <= -defense) { if (c.getNetDefense() <= -defense) {
return true; // can kill indestructible creatures return true; // can kill indestructible creatures
} }
return ((c.getKillDamage() <= -defense) && !c.hasKeyword("Indestructible")); return ((c.getKillDamage() <= -defense) && !c.hasKeyword("Indestructible"));
} }
}); // leaves all creatures that will be destroyed }); // leaves all creatures that will be destroyed
human = human.filter(new CardListFilter() { human = human.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (c.getNetDefense() <= -defense) { if (c.getNetDefense() <= -defense) {
return true; // can kill indestructible creatures return true; // can kill indestructible creatures
} }
@@ -1738,9 +1738,9 @@ public class AbilityFactoryPump {
} }
// only count creatures that can attack // only count creatures that can attack
comp = comp.filter(new CardListFilter() { comp = comp.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (power <= 0 && !containsUsefulKeyword(keywords, c, sa)) { if (power <= 0 && !containsUsefulKeyword(keywords, c, sa)) {
return false; return false;
} }

13
src/main/java/forge/card/cardfactory/CardFactoryArtifacts.java
View File

@@ -6,7 +6,7 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.Command; import forge.Command;
import forge.Counters; import forge.Counters;
import forge.Singletons; import forge.Singletons;
@@ -22,6 +22,7 @@ import forge.game.zone.PlayerZone;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.gui.match.CMatchUI; import forge.gui.match.CMatchUI;
import forge.util.closures.Predicate;
import forge.view.ButtonUtil; import forge.view.ButtonUtil;
/** /**
@@ -182,9 +183,9 @@ class CardFactoryArtifacts {
} }
} else { } else {
CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Hand); CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Hand);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (c.isLand()); return (c.isLand());
} }
}); });
@@ -220,9 +221,9 @@ class CardFactoryArtifacts {
public boolean canPlay() { public boolean canPlay() {
CardList list = card.getController().getCardsIn(ZoneType.Hand); CardList list = card.getController().getCardsIn(ZoneType.Hand);
list.remove(card); list.remove(card);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (c.isLand()); return (c.isLand());
} }
}); });
@@ -351,7 +352,7 @@ class CardFactoryArtifacts {
final Player player = this.getTargetPlayer(); final Player player = this.getTargetPlayer();
CardList lands = player.getCardsIn(ZoneType.Graveyard); CardList lands = player.getCardsIn(ZoneType.Graveyard);
lands = lands.filter(CardListFilter.BASIC_LANDS); lands = lands.filter(CardPredicates.BASIC_LANDS);
if (card.getController().isHuman()) { if (card.getController().isHuman()) {
// now, select up to four lands // now, select up to four lands
int end = -1; int end = -1;

9
src/main/java/forge/card/cardfactory/CardFactoryAuras.java
View File

@@ -26,7 +26,7 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.CardListUtil; import forge.CardListUtil;
import forge.CardUtil; import forge.CardUtil;
import forge.Command; import forge.Command;
@@ -41,6 +41,7 @@ import forge.control.input.Input;
import forge.game.zone.PlayerZone; import forge.game.zone.PlayerZone;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -268,9 +269,9 @@ class CardFactoryAuras {
return false; return false;
} }
final CardListFilter f = new CardListFilter() { final Predicate<Card> f = new Predicate<Card>() {
@Override @Override
public final boolean addCard(final Card c) { public final boolean isTrue(final Card c) {
return (c.getNetDefense() - c.getDamage()) <= 2; return (c.getNetDefense() - c.getDamage()) <= 2;
} }
}; };
@@ -421,7 +422,7 @@ class CardFactoryAuras {
// This includes creatures Animate Dead can't enchant once // This includes creatures Animate Dead can't enchant once
// in play. // in play.
// The human may try to Animate them, the AI will not. // The human may try to Animate them, the AI will not.
return AllZoneUtil.getCardsIn(ZoneType.Graveyard).filter(CardListFilter.CREATURES); return AllZoneUtil.getCardsIn(ZoneType.Graveyard).filter(CardPredicates.CREATURES);
} }
@Override @Override

82
src/main/java/forge/card/cardfactory/CardFactoryCreatures.java
View File

@@ -29,7 +29,7 @@ import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardCharacteristicName; import forge.CardCharacteristicName;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.CardUtil; import forge.CardUtil;
import forge.Command; import forge.Command;
import forge.Constant; import forge.Constant;
@@ -53,6 +53,7 @@ import forge.game.zone.PlayerZone;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.gui.match.CMatchUI; import forge.gui.match.CMatchUI;
import forge.util.closures.Predicate;
import forge.view.ButtonUtil; import forge.view.ButtonUtil;
/** /**
@@ -116,9 +117,9 @@ public class CardFactoryCreatures {
@Override @Override
public void chooseTargetAI() { public void chooseTargetAI() {
CardList perms = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield); CardList perms = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
perms = perms.getTargetableCards(this).filter(new CardListFilter() { perms = perms.getTargetableCards(this).filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (c.sumAllCounters() > 0); return (c.sumAllCounters() > 0);
} }
}); });
@@ -129,9 +130,9 @@ public class CardFactoryCreatures {
@Override @Override
public boolean canPlayAI() { public boolean canPlayAI() {
CardList perms = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield); CardList perms = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
perms = perms.getTargetableCards(this).filter(new CardListFilter() { perms = perms.getTargetableCards(this).filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (c.sumAllCounters() > 0); return (c.sumAllCounters() > 0);
} }
}); });
@@ -222,17 +223,12 @@ public class CardFactoryCreatures {
} else { // computer } else { // computer
CardList art = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield); CardList art = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
art = art.filter(new CardListFilter() { art = art.filter(CardPredicates.ARTIFACTS);
@Override
public boolean addCard(final Card c) {
return c.isArtifact();
}
});
CardList list = new CardList(art); CardList list = new CardList(art);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getIntrinsicKeyword().contains("Indestructible"); return c.getIntrinsicKeyword().contains("Indestructible");
} }
}); });
@@ -424,7 +420,7 @@ public class CardFactoryCreatures {
@Override @Override
public void resolve() { public void resolve() {
CardList allTokens = AllZoneUtil.getCreaturesInPlay(card.getController()); CardList allTokens = AllZoneUtil.getCreaturesInPlay(card.getController());
allTokens = allTokens.filter(CardListFilter.TOKEN); allTokens = allTokens.filter(CardPredicates.TOKEN);
CardFactoryUtil.copyTokens(allTokens); CardFactoryUtil.copyTokens(allTokens);
} }
@@ -432,7 +428,7 @@ public class CardFactoryCreatures {
@Override @Override
public boolean canPlayAI() { public boolean canPlayAI() {
CardList allTokens = AllZoneUtil.getCreaturesInPlay(AllZone.getComputerPlayer()); CardList allTokens = AllZoneUtil.getCreaturesInPlay(AllZone.getComputerPlayer());
allTokens = allTokens.filter(CardListFilter.TOKEN); allTokens = allTokens.filter(CardPredicates.TOKEN);
return allTokens.size() >= 2; return allTokens.size() >= 2;
} }
@@ -547,9 +543,9 @@ public class CardFactoryCreatures {
CardList wolves = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield); CardList wolves = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
wolves = wolves.getType("Wolf"); wolves = wolves.getType("Wolf");
wolves = wolves.filter(new CardListFilter() { wolves = wolves.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.isUntapped() && c.isCreature(); return c.isUntapped() && c.isCreature();
} }
}); });
@@ -566,9 +562,9 @@ public class CardFactoryCreatures {
CardList targetables = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield); CardList targetables = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield);
targetables = targetables.getTargetableCards(this).filter(new CardListFilter() { targetables = targetables.getTargetableCards(this).filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.isCreature() && (c.getNetDefense() <= totalPower); return c.isCreature() && (c.getNetDefense() <= totalPower);
} }
}); });
@@ -588,9 +584,9 @@ public class CardFactoryCreatures {
CardList wolves = card.getController().getCardsIn(ZoneType.Battlefield); CardList wolves = card.getController().getCardsIn(ZoneType.Battlefield);
wolves = wolves.getType("Wolf"); wolves = wolves.getType("Wolf");
wolves = wolves.filter(new CardListFilter() { wolves = wolves.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.isUntapped() && c.isCreature(); return c.isUntapped() && c.isCreature();
} }
}); });
@@ -625,9 +621,9 @@ public class CardFactoryCreatures {
})); }));
} }
} else { // AI Choose spread Damage } else { // AI Choose spread Damage
final CardList damageableWolves = wolves.filter(new CardListFilter() { final CardList damageableWolves = wolves.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (c.predictDamage(target.getNetAttack(), target, false) > 0); return (c.predictDamage(target.getNetAttack(), target, false) > 0);
} }
}); });
@@ -638,17 +634,17 @@ public class CardFactoryCreatures {
return; return;
} }
CardList wolvesLeft = damageableWolves.filter(new CardListFilter() { CardList wolvesLeft = damageableWolves.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !c.hasKeyword("Indestructible"); return !c.hasKeyword("Indestructible");
} }
}); });
for (int i = 0; i < target.getNetAttack(); i++) { for (int i = 0; i < target.getNetAttack(); i++) {
wolvesLeft = wolvesLeft.filter(new CardListFilter() { wolvesLeft = wolvesLeft.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (c.getKillDamage() > 0) return (c.getKillDamage() > 0)
&& ((c.getKillDamage() <= target.getNetAttack()) || target && ((c.getKillDamage() <= target.getNetAttack()) || target
.hasKeyword("Deathtouch")); .hasKeyword("Deathtouch"));
@@ -665,9 +661,9 @@ public class CardFactoryCreatures {
} else { } else {
// Add -1/-1s to Random Indestructibles // Add -1/-1s to Random Indestructibles
if (target.hasKeyword("Infect") || target.hasKeyword("Wither")) { if (target.hasKeyword("Infect") || target.hasKeyword("Wither")) {
final CardList indestructibles = damageableWolves.filter(new CardListFilter() { final CardList indestructibles = damageableWolves.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.hasKeyword("Indestructible"); return c.hasKeyword("Indestructible");
} }
}); });
@@ -770,9 +766,9 @@ public class CardFactoryCreatures {
// toughness of 1 // toughness of 1
CardList list = CardFactoryUtil.getHumanCreatureAI(card.getCounters(Counters.P1P1), this, true); CardList list = CardFactoryUtil.getHumanCreatureAI(card.getCounters(Counters.P1P1), this, true);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
final int total = card.getCounters(Counters.P1P1); final int total = card.getCounters(Counters.P1P1);
return (total >= c.getKillDamage()); return (total >= c.getKillDamage());
} }
@@ -825,10 +821,10 @@ public class CardFactoryCreatures {
public int countKithkin() { public int countKithkin() {
CardList kithkin = card.getController().getCardsIn(ZoneType.Battlefield); CardList kithkin = card.getController().getCardsIn(ZoneType.Battlefield);
kithkin = kithkin.filter(new CardListFilter() { kithkin = kithkin.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (c.isType("Kithkin")) && !c.equals(card); return (c.isType("Kithkin")) && !c.equals(card);
} }
@@ -936,9 +932,9 @@ public class CardFactoryCreatures {
// Dark Depths: // Dark Depths:
CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield, "Dark Depths"); CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield, "Dark Depths");
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card crd) { public boolean isTrue(final Card crd) {
return crd.getCounters(Counters.ICE) >= 3; return crd.getCounters(Counters.ICE) >= 3;
} }
}); });
@@ -950,9 +946,9 @@ public class CardFactoryCreatures {
// Get rid of Planeswalkers: // Get rid of Planeswalkers:
list = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield); list = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card crd) { public boolean isTrue(final Card crd) {
return crd.isPlaneswalker() && (crd.getCounters(Counters.LOYALTY) >= 5); return crd.isPlaneswalker() && (crd.getCounters(Counters.LOYALTY) >= 5);
} }
}); });
@@ -994,9 +990,9 @@ public class CardFactoryCreatures {
int intermSumToughness = 0; int intermSumToughness = 0;
// intermSumPower = intermSumToughness = 0; // intermSumPower = intermSumToughness = 0;
CardList creats = card.getController().getCardsIn(ZoneType.Graveyard); CardList creats = card.getController().getCardsIn(ZoneType.Graveyard);
creats = creats.filter(new CardListFilter() { creats = creats.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.isCreature() && !c.equals(card); return c.isCreature() && !c.equals(card);
} }
}); });
@@ -1047,7 +1043,7 @@ public class CardFactoryCreatures {
public boolean canPlayAI() { public boolean canPlayAI() {
// get all creatures // get all creatures
CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Graveyard); CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Graveyard);
list = list.filter(CardListFilter.CREATURES); list = list.filter(CardPredicates.CREATURES);
return 0 < list.size(); return 0 < list.size();
} }
}); });
@@ -1069,12 +1065,12 @@ public class CardFactoryCreatures {
final Player opp = player.getOpponent(); final Player opp = player.getOpponent();
int max = 0; int max = 0;
CardList play = opp.getCardsIn(ZoneType.Battlefield); CardList play = opp.getCardsIn(ZoneType.Battlefield);
play = play.filter(CardListFilter.NON_TOKEN); play = play.filter(CardPredicates.NON_TOKEN);
play = play.filter(CardListFilter.WHITE); play = play.filter(CardPredicates.WHITE);
max += play.size(); max += play.size();
CardList grave = opp.getCardsIn(ZoneType.Graveyard); CardList grave = opp.getCardsIn(ZoneType.Graveyard);
grave = grave.filter(CardListFilter.WHITE); grave = grave.filter(CardPredicates.WHITE);
max += grave.size(); max += grave.size();
final String[] life = new String[max + 1]; final String[] life = new String[max + 1];

9
src/main/java/forge/card/cardfactory/CardFactoryInstants.java
View File

@@ -21,7 +21,7 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.Command; import forge.Command;
import forge.Singletons; import forge.Singletons;
import forge.card.cost.Cost; import forge.card.cost.Cost;
@@ -37,6 +37,7 @@ import forge.game.zone.PlayerZone;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -416,10 +417,10 @@ public class CardFactoryInstants {
@Override @Override
public void resolve() { public void resolve() {
final Player you = card.getController(); final Player you = card.getController();
final CardList ens = AllZoneUtil.getCardsIn(ZoneType.Battlefield).filter(CardListFilter.ENCHANTMENTS); final CardList ens = AllZoneUtil.getCardsIn(ZoneType.Battlefield).filter(CardPredicates.ENCHANTMENTS);
final CardList toReturn = ens.filter(new CardListFilter() { final CardList toReturn = ens.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
final Card enchanting = c.getEnchantingCard(); final Card enchanting = c.getEnchantingCard();
if (enchanting != null) { if (enchanting != null) {

15
src/main/java/forge/card/cardfactory/CardFactoryLands.java
View File

@@ -23,7 +23,7 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.Command; import forge.Command;
import forge.Counters; import forge.Counters;
import forge.GameActionUtil; import forge.GameActionUtil;
@@ -40,6 +40,7 @@ import forge.game.zone.PlayerZone;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.gui.match.CMatchUI; import forge.gui.match.CMatchUI;
import forge.util.closures.Predicate;
import forge.view.ButtonUtil; import forge.view.ButtonUtil;
/** /**
@@ -136,10 +137,10 @@ class CardFactoryLands {
else if (cardName.equals("Novijen, Heart of Progress")) { else if (cardName.equals("Novijen, Heart of Progress")) {
card.clearSpellKeepManaAbility(); card.clearSpellKeepManaAbility();
final CardListFilter targets = new CardListFilter() { final Predicate<Card> targets = new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return AllZoneUtil.isCardInPlay(c) && c.isCreature() return AllZoneUtil.isCardInPlay(c) && c.isCreature()
&& (c.getTurnInZone() == Singletons.getModel().getGameState().getPhaseHandler().getTurn()); && (c.getTurnInZone() == Singletons.getModel().getGameState().getPhaseHandler().getTurn());
} }
@@ -249,7 +250,7 @@ class CardFactoryLands {
} }
} // selectCard() } // selectCard()
}; // Input }; // Input
if ((AllZoneUtil.getPlayerLandsInPlay(AllZone.getHumanPlayer()).filter(CardListFilter.UNTAPPED) if ((AllZoneUtil.getPlayerLandsInPlay(AllZone.getHumanPlayer()).filter(CardPredicates.UNTAPPED)
.size() < 2)) { .size() < 2)) {
Singletons.getModel().getGameAction().sacrifice(card, null); Singletons.getModel().getGameAction().sacrifice(card, null);
return; return;
@@ -296,7 +297,7 @@ class CardFactoryLands {
if (this.player.isComputer()) { if (this.player.isComputer()) {
if (land.size() > 0) { if (land.size() > 0) {
CardList tappedLand = new CardList(land); CardList tappedLand = new CardList(land);
tappedLand = tappedLand.filter(CardListFilter.TAPPED); tappedLand = tappedLand.filter(CardPredicates.TAPPED);
// if any are tapped, sacrifice it // if any are tapped, sacrifice it
// else sacrifice random // else sacrifice random
if (tappedLand.size() > 0) { if (tappedLand.size() > 0) {
@@ -377,7 +378,7 @@ class CardFactoryLands {
@Override @Override
public void execute() { public void execute() {
CardList plains = AllZoneUtil.getPlayerLandsInPlay(card.getController()); CardList plains = AllZoneUtil.getPlayerLandsInPlay(card.getController());
plains = plains.filter(CardListFilter.UNTAPPED); plains = plains.filter(CardPredicates.UNTAPPED);
if (this.player.isComputer()) { if (this.player.isComputer()) {
if (plains.size() > 1) { if (plains.size() > 1) {
@@ -396,7 +397,7 @@ class CardFactoryLands {
} }
} else { // this is the human resolution } else { // this is the human resolution
final int[] paid = { 0 }; final int[] paid = { 0 };
if ((AllZoneUtil.getPlayerLandsInPlay(AllZone.getHumanPlayer()).filter(CardListFilter.UNTAPPED) if ((AllZoneUtil.getPlayerLandsInPlay(AllZone.getHumanPlayer()).filter(CardPredicates.UNTAPPED)
.size() < 2)) { .size() < 2)) {
Singletons.getModel().getGameAction().sacrifice(card, null); Singletons.getModel().getGameAction().sacrifice(card, null);
return; return;

37
src/main/java/forge/card/cardfactory/CardFactorySorceries.java
View File

@@ -30,7 +30,7 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.CardListUtil; import forge.CardListUtil;
import forge.CardUtil; import forge.CardUtil;
import forge.Command; import forge.Command;
@@ -50,6 +50,7 @@ import forge.game.zone.PlayerZone;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.gui.match.CMatchUI; import forge.gui.match.CMatchUI;
import forge.util.closures.Predicate;
import forge.view.ButtonUtil; import forge.view.ButtonUtil;
/** /**
@@ -309,10 +310,10 @@ public class CardFactorySorceries {
@Override @Override
public boolean canPlayAI() { public boolean canPlayAI() {
CardList humTokenCreats = AllZoneUtil.getCreaturesInPlay(AllZone.getHumanPlayer()); CardList humTokenCreats = AllZoneUtil.getCreaturesInPlay(AllZone.getHumanPlayer());
humTokenCreats = humTokenCreats.filter(CardListFilter.TOKEN); humTokenCreats = humTokenCreats.filter(CardPredicates.TOKEN);
CardList compTokenCreats = AllZoneUtil.getCreaturesInPlay(AllZone.getComputerPlayer()); CardList compTokenCreats = AllZoneUtil.getCreaturesInPlay(AllZone.getComputerPlayer());
compTokenCreats = compTokenCreats.filter(CardListFilter.TOKEN); compTokenCreats = compTokenCreats.filter(CardPredicates.TOKEN);
return compTokenCreats.size() > humTokenCreats.size(); return compTokenCreats.size() > humTokenCreats.size();
} // canPlayAI() } // canPlayAI()
@@ -320,7 +321,7 @@ public class CardFactorySorceries {
@Override @Override
public void resolve() { public void resolve() {
CardList tokens = AllZoneUtil.getCreaturesInPlay(); CardList tokens = AllZoneUtil.getCreaturesInPlay();
tokens = tokens.filter(CardListFilter.TOKEN); tokens = tokens.filter(CardPredicates.TOKEN);
CardFactoryUtil.copyTokens(tokens); CardFactoryUtil.copyTokens(tokens);
@@ -389,9 +390,9 @@ public class CardFactorySorceries {
} }
// need to sacrifice the other non-basic land types // need to sacrifice the other non-basic land types
land = land.filter(new CardListFilter() { land = land.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (c.getName().contains("Dryad Arbor")) { if (c.getName().contains("Dryad Arbor")) {
return true; return true;
} else { } else {
@@ -456,9 +457,9 @@ public class CardFactorySorceries {
// controls and add them to target // controls and add them to target
CardList land = AllZoneUtil.getPlayerLandsInPlay(AllZone.getHumanPlayer()); CardList land = AllZoneUtil.getPlayerLandsInPlay(AllZone.getHumanPlayer());
CardList cl = land.getType(humanBasic.get(this.count)); CardList cl = land.getType(humanBasic.get(this.count));
cl = cl.filter(new CardListFilter() { cl = cl.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card crd) { public boolean isTrue(final Card crd) {
return !saveList.contains(crd); return !saveList.contains(crd);
} }
}); });
@@ -477,9 +478,9 @@ public class CardFactorySorceries {
} }
// need to sacrifice the other non-basic land types // need to sacrifice the other non-basic land types
land = land.filter(new CardListFilter() { land = land.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (c.getName().contains("Dryad Arbor")) { if (c.getName().contains("Dryad Arbor")) {
return true; return true;
} else { } else {
@@ -541,9 +542,9 @@ public class CardFactorySorceries {
CardList graveyard = AllZone.getHumanPlayer().getCardsIn(ZoneType.Graveyard); CardList graveyard = AllZone.getHumanPlayer().getCardsIn(ZoneType.Graveyard);
final CardList library = AllZone.getHumanPlayer().getCardsIn(ZoneType.Library); final CardList library = AllZone.getHumanPlayer().getCardsIn(ZoneType.Library);
final int graveCount = graveyard.size(); final int graveCount = graveyard.size();
graveyard = graveyard.filter(new CardListFilter() { graveyard = graveyard.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.isBasicLand(); return c.isBasicLand();
} }
}); });
@@ -1403,10 +1404,10 @@ public class CardFactorySorceries {
@Override @Override
public void showMessage() { public void showMessage() {
CardList grave = card.getController().getCardsIn(ZoneType.Graveyard); CardList grave = card.getController().getCardsIn(ZoneType.Graveyard);
grave = grave.filter(CardListFilter.CREATURES); grave = grave.filter(CardPredicates.CREATURES);
grave = grave.filter(new CardListFilter() { grave = grave.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getCMC() <= x[0]; return c.getCMC() <= x[0];
} }
}); });
@@ -1553,7 +1554,7 @@ public class CardFactorySorceries {
// get all // get all
final CardList creatures = AllZoneUtil.getCreaturesInPlay(); final CardList creatures = AllZoneUtil.getCreaturesInPlay();
CardList grave = card.getController().getCardsIn(ZoneType.Graveyard); CardList grave = card.getController().getCardsIn(ZoneType.Graveyard);
grave = grave.filter(CardListFilter.CREATURES); grave = grave.filter(CardPredicates.CREATURES);
if (AllZone.getHumanPlayer().canBeTargetedBy(spell) if (AllZone.getHumanPlayer().canBeTargetedBy(spell)
|| AllZone.getComputerPlayer().canBeTargetedBy(spell)) { || AllZone.getComputerPlayer().canBeTargetedBy(spell)) {
@@ -1634,7 +1635,7 @@ public class CardFactorySorceries {
// Sacrifice an artifact // Sacrifice an artifact
CardList arts = p.getCardsIn(ZoneType.Battlefield); CardList arts = p.getCardsIn(ZoneType.Battlefield);
arts = arts.filter(CardListFilter.ARTIFACTS); arts = arts.filter(CardPredicates.ARTIFACTS);
final Object toSac = GuiUtils.chooseOneOrNone("Sacrifice an artifact", arts.toArray()); final Object toSac = GuiUtils.chooseOneOrNone("Sacrifice an artifact", arts.toArray());
if (toSac != null) { if (toSac != null) {
final Card c = (Card) toSac; final Card c = (Card) toSac;
@@ -1647,7 +1648,7 @@ public class CardFactorySorceries {
// Search your library for an artifact // Search your library for an artifact
final CardList lib = p.getCardsIn(ZoneType.Library); final CardList lib = p.getCardsIn(ZoneType.Library);
GuiUtils.chooseOneOrNone("Looking at Library", lib.toArray()); GuiUtils.chooseOneOrNone("Looking at Library", lib.toArray());
final CardList libArts = lib.filter(CardListFilter.ARTIFACTS); final CardList libArts = lib.filter(CardPredicates.ARTIFACTS);
final Object o = GuiUtils.chooseOneOrNone("Search for artifact", libArts.toArray()); final Object o = GuiUtils.chooseOneOrNone("Search for artifact", libArts.toArray());
if (o != null) { if (o != null) {
newArtifact[0] = (Card) o; newArtifact[0] = (Card) o;

92
src/main/java/forge/card/cardfactory/CardFactoryUtil.java
View File

@@ -32,7 +32,7 @@ import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardCharacteristicName; import forge.CardCharacteristicName;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.CardListUtil; import forge.CardListUtil;
import forge.CardUtil; import forge.CardUtil;
import forge.Command; import forge.Command;
@@ -72,6 +72,7 @@ import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.gui.match.CMatchUI; import forge.gui.match.CMatchUI;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
import forge.view.ButtonUtil; import forge.view.ButtonUtil;
/** /**
@@ -101,9 +102,9 @@ public class CardFactoryUtil {
public static Card getMostExpensivePermanentAI(final CardList list, final SpellAbility spell, final boolean targeted) { public static Card getMostExpensivePermanentAI(final CardList list, final SpellAbility spell, final boolean targeted) {
CardList all = list; CardList all = list;
if (targeted) { if (targeted) {
all = all.filter(new CardListFilter() { all = all.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.canBeTargetedBy(spell); return c.canBeTargetedBy(spell);
} }
}); });
@@ -160,9 +161,9 @@ public class CardFactoryUtil {
* @return a {@link forge.Card} object. * @return a {@link forge.Card} object.
*/ */
public static Card getCheapestCreatureAI(CardList list, final SpellAbility spell, final boolean targeted) { public static Card getCheapestCreatureAI(CardList list, final SpellAbility spell, final boolean targeted) {
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.isCreature(); return c.isCreature();
} }
}); });
@@ -185,9 +186,9 @@ public class CardFactoryUtil {
public static Card getCheapestPermanentAI(final CardList list, final SpellAbility spell, final boolean targeted) { public static Card getCheapestPermanentAI(final CardList list, final SpellAbility spell, final boolean targeted) {
CardList all = list; CardList all = list;
if (targeted) { if (targeted) {
all = all.filter(new CardListFilter() { all = all.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.canBeTargetedBy(spell); return c.canBeTargetedBy(spell);
} }
}); });
@@ -226,9 +227,9 @@ public class CardFactoryUtil {
} }
// prefer to target non basic lands // prefer to target non basic lands
final CardList nbLand = land.filter(new CardListFilter() { final CardList nbLand = land.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (!c.isBasicLand()); return (!c.isBasicLand());
} }
}); });
@@ -291,10 +292,10 @@ public class CardFactoryUtil {
CardList all = list; CardList all = list;
all = all.getType("Enchantment"); all = all.getType("Enchantment");
if (targeted) { if (targeted) {
all = all.filter(new CardListFilter() { all = all.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.canBeTargetedBy(spell); return c.canBeTargetedBy(spell);
} }
}); });
@@ -799,9 +800,9 @@ public class CardFactoryUtil {
} }
if ((list.getType("Artifact").size() > 0) || (list.getType("Enchantment").size() > 0)) { if ((list.getType("Artifact").size() > 0) || (list.getType("Enchantment").size() > 0)) {
return CardFactoryUtil.getCheapestPermanentAI(list.filter(new CardListFilter() { return CardFactoryUtil.getCheapestPermanentAI(list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.isArtifact() || c.isEnchantment(); return c.isArtifact() || c.isEnchantment();
} }
}), null, false); }), null, false);
@@ -1665,9 +1666,9 @@ public class CardFactoryUtil {
*/ */
public static CardList getHumanCreatureAI(final int toughness, final SpellAbility spell, final boolean targeted) { public static CardList getHumanCreatureAI(final int toughness, final SpellAbility spell, final boolean targeted) {
CardList creature = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield); CardList creature = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield);
creature = creature.filter(new CardListFilter() { creature = creature.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (targeted) { if (targeted) {
return c.isCreature() && (c.getNetDefense() <= toughness) && c.canBeTargetedBy(spell); return c.isCreature() && (c.getNetDefense() <= toughness) && c.canBeTargetedBy(spell);
} else { } else {
@@ -2026,9 +2027,9 @@ public class CardFactoryUtil {
} }
CardList list = new CardList(card.getEquippedBy()); CardList list = new CardList(card.getEquippedBy());
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getName().equals(name); return c.getName().equals(name);
} }
@@ -2082,9 +2083,9 @@ public class CardFactoryUtil {
} }
if (activator.isPlayer(zone.getPlayer())) { if (activator.isPlayer(zone.getPlayer())) {
cl = cl.filter(new CardListFilter() { cl = cl.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (zone.is(ZoneType.Graveyard)) { if (zone.is(ZoneType.Graveyard)) {
if (c.hasUnearth()) { if (c.hasUnearth()) {
return true; return true;
@@ -2117,9 +2118,9 @@ public class CardFactoryUtil {
}); });
} else { } else {
// the activator is not the owner of the card // the activator is not the owner of the card
cl = cl.filter(new CardListFilter() { cl = cl.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (c.hasStartOfKeyword("May be played by your opponent") if (c.hasStartOfKeyword("May be played by your opponent")
|| c.hasKeyword("Your opponent may look at this card.")) { || c.hasKeyword("Your opponent may look at this card.")) {
@@ -2575,7 +2576,7 @@ public class CardFactoryUtil {
// Count$ColoredCreatures *a DOMAIN for creatures* // Count$ColoredCreatures *a DOMAIN for creatures*
if (sq[0].contains("ColoredCreatures")) { if (sq[0].contains("ColoredCreatures")) {
someCards.addAll(cardController.getCardsIn(ZoneType.Battlefield)); someCards.addAll(cardController.getCardsIn(ZoneType.Battlefield));
someCards = someCards.filter(CardListFilter.CREATURES); someCards = someCards.filter(CardPredicates.CREATURES);
final String[] colors = { "green", "white", "red", "blue", "black" }; final String[] colors = { "green", "white", "red", "blue", "black" };
@@ -2787,9 +2788,9 @@ public class CardFactoryUtil {
final Card csource = c; final Card csource = c;
CardList cl = c.getDevoured(); CardList cl = c.getDevoured();
cl = cl.filter(new CardListFilter() { cl = cl.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card cdev) { public boolean isTrue(final Card cdev) {
return cdev.isValid(validDevoured.split(","), csource.getController(), csource); return cdev.isValid(validDevoured.split(","), csource.getController(), csource);
} }
}); });
@@ -3046,9 +3047,9 @@ public class CardFactoryUtil {
// "Clerics you control" - Count$TypeYouCtrl.Cleric // "Clerics you control" - Count$TypeYouCtrl.Cleric
if (sq[0].contains("Type")) { if (sq[0].contains("Type")) {
someCards = someCards.filter(new CardListFilter() { someCards = someCards.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (c.isType(sq[1])) { if (c.isType(sq[1])) {
return true; return true;
} }
@@ -3065,9 +3066,9 @@ public class CardFactoryUtil {
sq[1] = c.getName(); sq[1] = c.getName();
} }
someCards = someCards.filter(new CardListFilter() { someCards = someCards.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (c.getName().equals(sq[1])) { if (c.getName().equals(sq[1])) {
return true; return true;
} }
@@ -3081,47 +3082,52 @@ public class CardFactoryUtil {
// "Untapped Lands" - Count$UntappedTypeYouCtrl.Land // "Untapped Lands" - Count$UntappedTypeYouCtrl.Land
if (sq[0].contains("Untapped")) { if (sq[0].contains("Untapped")) {
someCards = someCards.filter(CardListFilter.UNTAPPED); someCards = someCards.filter(CardPredicates.UNTAPPED);
} }
if (sq[0].contains("Tapped")) { if (sq[0].contains("Tapped")) {
someCards = someCards.filter(CardListFilter.TAPPED); someCards = someCards.filter(CardPredicates.TAPPED);
} }
// String sq0 = sq[0].toLowerCase();
// for(String color : Constant.Color.ONLY_COLORS) {
// if( sq0.contains(color) )
// someCards = someCards.filter(CardListFilter.WHITE);
// }
// "White Creatures" - Count$WhiteTypeYouCtrl.Creature // "White Creatures" - Count$WhiteTypeYouCtrl.Creature
if (sq[0].contains("White")) { if (sq[0].contains("White")) {
someCards = someCards.filter(CardListFilter.WHITE); someCards = someCards.filter(CardPredicates.WHITE);
} }
if (sq[0].contains("Blue")) { if (sq[0].contains("Blue")) {
someCards = someCards.filter(CardListFilter.BLUE); someCards = someCards.filter(CardPredicates.BLUE);
} }
if (sq[0].contains("Black")) { if (sq[0].contains("Black")) {
someCards = someCards.filter(CardListFilter.BLACK); someCards = someCards.filter(CardPredicates.BLACK);
} }
if (sq[0].contains("Red")) { if (sq[0].contains("Red")) {
someCards = someCards.filter(CardListFilter.RED); someCards = someCards.filter(CardPredicates.RED);
} }
if (sq[0].contains("Green")) { if (sq[0].contains("Green")) {
someCards = someCards.filter(CardListFilter.GREEN); someCards = someCards.filter(CardPredicates.GREEN);
} }
if (sq[0].contains("Multicolor")) { if (sq[0].contains("Multicolor")) {
someCards = someCards.filter(new CardListFilter() { someCards = someCards.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (CardUtil.getColors(c).size() > 1); return (CardUtil.getColors(c).size() > 1);
} }
}); });
} }
if (sq[0].contains("Monocolor")) { if (sq[0].contains("Monocolor")) {
someCards = someCards.filter(new CardListFilter() { someCards = someCards.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (CardUtil.getColors(c).size() == 1); return (CardUtil.getColors(c).size() == 1);
} }
}); });
@@ -3512,9 +3518,9 @@ public class CardFactoryUtil {
*/ */
public static int getUsableManaSources(final Player player) { public static int getUsableManaSources(final Player player) {
CardList list = player.getCardsIn(ZoneType.Battlefield); CardList list = player.getCardsIn(ZoneType.Battlefield);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
for (final AbilityMana am : c.getAIPlayableMana()) { for (final AbilityMana am : c.getAIPlayableMana()) {
if (am.canPlay()) { if (am.canPlay()) {
return true; return true;
@@ -5151,9 +5157,9 @@ public class CardFactoryUtil {
// Target as Modular is Destroyed // Target as Modular is Destroyed
if (card.getController().isComputer()) { if (card.getController().isComputer()) {
CardList choices = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield); CardList choices = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
choices = choices.filter(new CardListFilter() { choices = choices.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.isCreature() && c.isArtifact(); return c.isCreature() && c.isArtifact();
} }
}); });

8
src/main/java/forge/card/cost/CostTapType.java
View File

@@ -19,7 +19,7 @@ package forge.card.cost;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.card.abilityfactory.AbilityFactory; import forge.card.abilityfactory.AbilityFactory;
import forge.card.spellability.SpellAbility; import forge.card.spellability.SpellAbility;
import forge.control.input.Input; import forge.control.input.Input;
@@ -119,7 +119,7 @@ public class CostTapType extends CostPartWithList {
if (cost.getTap()) { if (cost.getTap()) {
typeList.remove(source); typeList.remove(source);
} }
typeList = typeList.filter(CardListFilter.UNTAPPED); typeList = typeList.filter(CardPredicates.UNTAPPED);
final Integer amount = this.convertAmount(); final Integer amount = this.convertAmount();
if ((typeList.size() == 0) || ((amount != null) && (typeList.size() < amount))) { if ((typeList.size() == 0) || ((amount != null) && (typeList.size() < amount))) {
@@ -154,7 +154,7 @@ public class CostTapType extends CostPartWithList {
CardList typeList = ability.getActivatingPlayer().getCardsIn(ZoneType.Battlefield); CardList typeList = ability.getActivatingPlayer().getCardsIn(ZoneType.Battlefield);
typeList = typeList.getValidCards(this.getType().split(";"), ability.getActivatingPlayer(), typeList = typeList.getValidCards(this.getType().split(";"), ability.getActivatingPlayer(),
ability.getSourceCard()); ability.getSourceCard());
typeList = typeList.filter(CardListFilter.UNTAPPED); typeList = typeList.filter(CardPredicates.UNTAPPED);
final String amount = this.getAmount(); final String amount = this.getAmount();
Integer c = this.convertAmount(); Integer c = this.convertAmount();
if (c == null) { if (c == null) {
@@ -189,7 +189,7 @@ public class CostTapType extends CostPartWithList {
CardList typeList = ability.getActivatingPlayer().getCardsIn(ZoneType.Battlefield); CardList typeList = ability.getActivatingPlayer().getCardsIn(ZoneType.Battlefield);
typeList = typeList.getValidCards(this.getType().split(";"), ability.getActivatingPlayer(), typeList = typeList.getValidCards(this.getType().split(";"), ability.getActivatingPlayer(),
ability.getSourceCard()); ability.getSourceCard());
typeList = typeList.filter(CardListFilter.UNTAPPED); typeList = typeList.filter(CardPredicates.UNTAPPED);
c = typeList.size(); c = typeList.size();
source.setSVar("ChosenX", "Number$" + Integer.toString(c)); source.setSVar("ChosenX", "Number$" + Integer.toString(c));
} }

8
src/main/java/forge/card/cost/CostUntapType.java
View File

@@ -20,7 +20,7 @@ package forge.card.cost;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.card.abilityfactory.AbilityFactory; import forge.card.abilityfactory.AbilityFactory;
import forge.card.spellability.SpellAbility; import forge.card.spellability.SpellAbility;
import forge.control.input.Input; import forge.control.input.Input;
@@ -124,7 +124,7 @@ public class CostUntapType extends CostPartWithList {
if (cost.getUntap()) { if (cost.getUntap()) {
typeList.remove(source); typeList.remove(source);
} }
typeList = typeList.filter(CardListFilter.TAPPED); typeList = typeList.filter(CardPredicates.TAPPED);
final Integer amount = this.convertAmount(); final Integer amount = this.convertAmount();
if ((typeList.size() == 0) || ((amount != null) && (typeList.size() < amount))) { if ((typeList.size() == 0) || ((amount != null) && (typeList.size() < amount))) {
@@ -160,7 +160,7 @@ public class CostUntapType extends CostPartWithList {
CardList typeList = AllZoneUtil.getCardsIn(ZoneType.Battlefield); CardList typeList = AllZoneUtil.getCardsIn(ZoneType.Battlefield);
typeList = typeList.getValidCards(this.getType().split(";"), ability.getActivatingPlayer(), typeList = typeList.getValidCards(this.getType().split(";"), ability.getActivatingPlayer(),
ability.getSourceCard()); ability.getSourceCard());
typeList = typeList.filter(CardListFilter.TAPPED); typeList = typeList.filter(CardPredicates.TAPPED);
if (untap) { if (untap) {
typeList.remove(source); typeList.remove(source);
} }
@@ -201,7 +201,7 @@ public class CostUntapType extends CostPartWithList {
if (untap) { if (untap) {
typeList.remove(source); typeList.remove(source);
} }
typeList = typeList.filter(CardListFilter.TAPPED); typeList = typeList.filter(CardPredicates.TAPPED);
c = typeList.size(); c = typeList.size();
source.setSVar("ChosenX", "Number$" + Integer.toString(c)); source.setSVar("ChosenX", "Number$" + Integer.toString(c));
} }

6
src/main/java/forge/card/spellability/TargetSelection.java
View File

@@ -25,7 +25,6 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.card.abilityfactory.AbilityFactory; import forge.card.abilityfactory.AbilityFactory;
import forge.control.input.Input; import forge.control.input.Input;
import forge.game.player.Player; import forge.game.player.Player;
@@ -33,6 +32,7 @@ import forge.game.zone.PlayerZone;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.gui.match.CMatchUI; import forge.gui.match.CMatchUI;
import forge.util.closures.Predicate;
import forge.view.ButtonUtil; import forge.view.ButtonUtil;
/** /**
@@ -320,9 +320,9 @@ public class TargetSelection {
// If the cards can't share a creature type // If the cards can't share a creature type
if (tgt.isWithoutSameCreatureType() && !targeted.isEmpty()) { if (tgt.isWithoutSameCreatureType() && !targeted.isEmpty()) {
final Card card = targeted.get(0); final Card card = targeted.get(0);
choices = choices.filter(new CardListFilter() { choices = choices.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !c.sharesCreatureTypeWith(card); return !c.sharesCreatureTypeWith(card);
} }
}); });

6
src/main/java/forge/game/GameNew.java
View File

@@ -11,7 +11,7 @@ import javax.swing.JOptionPane;
import forge.AllZone; import forge.AllZone;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.CardUtil; import forge.CardUtil;
import forge.Constant; import forge.Constant;
import forge.GameAction; import forge.GameAction;
@@ -446,9 +446,9 @@ public class GameNew {
private static void seeWhoPlaysFirst() { private static void seeWhoPlaysFirst() {
final GameAction ga = Singletons.getModel().getGameAction(); final GameAction ga = Singletons.getModel().getGameAction();
CardList hLibrary = AllZone.getHumanPlayer().getCardsIn(ZoneType.Library); CardList hLibrary = AllZone.getHumanPlayer().getCardsIn(ZoneType.Library);
hLibrary = hLibrary.filter(CardListFilter.NON_LANDS); hLibrary = hLibrary.filter(CardPredicates.NON_LANDS);
CardList cLibrary = AllZone.getComputerPlayer().getCardsIn(ZoneType.Library); CardList cLibrary = AllZone.getComputerPlayer().getCardsIn(ZoneType.Library);
cLibrary = cLibrary.filter(CardListFilter.NON_LANDS); cLibrary = cLibrary.filter(CardPredicates.NON_LANDS);
final boolean starterDetermined = false; final boolean starterDetermined = false;
int cutCount = 0; int cutCount = 0;

18
src/main/java/forge/game/phase/CombatUtil.java
View File

@@ -31,7 +31,6 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.CardListUtil; import forge.CardListUtil;
import forge.Command; import forge.Command;
import forge.Constant; import forge.Constant;
@@ -61,6 +60,7 @@ import forge.gui.GuiUtils;
import forge.gui.framework.EDocID; import forge.gui.framework.EDocID;
import forge.gui.framework.SDisplayUtil; import forge.gui.framework.SDisplayUtil;
import forge.gui.match.views.VCombat; import forge.gui.match.views.VCombat;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -882,9 +882,9 @@ public class CombatUtil {
powerLimit[0] = Integer.parseInt((asSeparateWords[12]).trim()); powerLimit[0] = Integer.parseInt((asSeparateWords[12]).trim());
CardList list = AllZoneUtil.getCreaturesInPlay(c.getController().getOpponent()); CardList list = AllZoneUtil.getCreaturesInPlay(c.getController().getOpponent());
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card ct) { public boolean isTrue(final Card ct) {
return ((ct.isUntapped() && (ct.getNetAttack() >= powerLimit[0]) && asSeparateWords[14] return ((ct.isUntapped() && (ct.getNetAttack() >= powerLimit[0]) && asSeparateWords[14]
.contains("greater")) || (ct.isUntapped() && (ct.getNetAttack() <= powerLimit[0]) && asSeparateWords[14] .contains("greater")) || (ct.isUntapped() && (ct.getNetAttack() <= powerLimit[0]) && asSeparateWords[14]
.contains("less"))); .contains("less")));
@@ -926,9 +926,9 @@ public class CombatUtil {
return false; return false;
} }
} else if (keyword.equals("CARDNAME can't attack unless defending player controls a snow land.")) { } else if (keyword.equals("CARDNAME can't attack unless defending player controls a snow land.")) {
temp = list.filter(new CardListFilter() { temp = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.isLand() && c.isSnow(); return c.isLand() && c.isSnow();
} }
}); });
@@ -966,9 +966,9 @@ public class CombatUtil {
final Card att = attacker; final Card att = attacker;
CardList list = AllZoneUtil.getCreaturesInPlay(player); CardList list = AllZoneUtil.getCreaturesInPlay(player);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return CombatUtil.canBlock(att, c) && (c.hasFirstStrike() || c.hasDoubleStrike()); return CombatUtil.canBlock(att, c) && (c.hasFirstStrike() || c.hasDoubleStrike());
} }
}); });
@@ -3081,9 +3081,9 @@ public class CombatUtil {
@Override @Override
public void resolve() { public void resolve() {
CardList enchantments = attacker.getController().getCardsIn(ZoneType.Library); CardList enchantments = attacker.getController().getCardsIn(ZoneType.Library);
enchantments = enchantments.filter(new CardListFilter() { enchantments = enchantments.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (attacker.hasKeyword("Protection from enchantments") if (attacker.hasKeyword("Protection from enchantments")
|| (attacker.hasKeyword("Protection from everything"))) { || (attacker.hasKeyword("Protection from everything"))) {
return false; return false;

6
src/main/java/forge/game/phase/EndOfTurn.java
View File

@@ -21,7 +21,6 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.Counters; import forge.Counters;
import forge.Singletons; import forge.Singletons;
import forge.card.spellability.Ability; import forge.card.spellability.Ability;
@@ -29,6 +28,7 @@ import forge.card.spellability.SpellAbility;
import forge.game.GameLossReason; import forge.game.GameLossReason;
import forge.game.player.Player; import forge.game.player.Player;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -230,9 +230,9 @@ public class EndOfTurn extends Phase implements java.io.Serializable {
final Player opponent = player.getOpponent(); final Player opponent = player.getOpponent();
CardList list = opponent.getCardsIn(ZoneType.Battlefield); CardList list = opponent.getCardsIn(ZoneType.Battlefield);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getName().equals("Lighthouse Chronologist") && (c.getCounters(Counters.LEVEL) >= 7); return c.getName().equals("Lighthouse Chronologist") && (c.getCounters(Counters.LEVEL) >= 7);
} }
}); });

6
src/main/java/forge/game/phase/PhaseHandler.java
View File

@@ -27,7 +27,6 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.GameActionUtil; import forge.GameActionUtil;
import forge.Singletons; import forge.Singletons;
import forge.card.spellability.SpellAbility; import forge.card.spellability.SpellAbility;
@@ -36,6 +35,7 @@ import forge.game.player.Player;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.properties.ForgePreferences.FPref; import forge.properties.ForgePreferences.FPref;
import forge.util.MyObservable; import forge.util.MyObservable;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -660,9 +660,9 @@ public class PhaseHandler extends MyObservable implements java.io.Serializable {
private boolean skipTurnTimeVault(Player turn) { private boolean skipTurnTimeVault(Player turn) {
// time vault: // time vault:
CardList vaults = turn.getCardsIn(ZoneType.Battlefield, "Time Vault"); CardList vaults = turn.getCardsIn(ZoneType.Battlefield, "Time Vault");
vaults = vaults.filter(new CardListFilter() { vaults = vaults.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.isTapped(); return c.isTapped();
} }
}); });

9
src/main/java/forge/game/phase/PhaseUtil.java
View File

@@ -23,7 +23,7 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.Singletons; import forge.Singletons;
import forge.card.trigger.TriggerType; import forge.card.trigger.TriggerType;
import forge.game.player.Player; import forge.game.player.Player;
@@ -31,6 +31,7 @@ import forge.game.zone.ZoneType;
import forge.gui.match.CMatchUI; import forge.gui.match.CMatchUI;
import forge.gui.match.controllers.CMessage; import forge.gui.match.controllers.CMessage;
import forge.gui.match.nonsingleton.VField.PhaseLabel; import forge.gui.match.nonsingleton.VField.PhaseLabel;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -100,7 +101,7 @@ public class PhaseUtil {
Singletons.getModel().getGameAction().resetActivationsPerTurn(); Singletons.getModel().getGameAction().resetActivationsPerTurn();
final CardList lands = AllZoneUtil.getPlayerLandsInPlay(turn).filter(CardListFilter.UNTAPPED); final CardList lands = AllZoneUtil.getPlayerLandsInPlay(turn).filter(CardPredicates.UNTAPPED);
turn.setNumPowerSurgeLands(lands.size()); turn.setNumPowerSurgeLands(lands.size());
// anything before this point happens regardless of whether the Untap // anything before this point happens regardless of whether the Untap
@@ -369,9 +370,9 @@ public class PhaseUtil {
CardList list = new CardList(); CardList list = new CardList();
list.addAll(AllZone.getCombat().getAllBlockers()); list.addAll(AllZone.getCombat().getAllBlockers());
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !c.getDamageHistory().getCreatureBlockedThisCombat(); return !c.getDamageHistory().getCreatureBlockedThisCombat();
} }
}); });

39
src/main/java/forge/game/phase/Untap.java
View File

@@ -23,7 +23,7 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.Counters; import forge.Counters;
import forge.GameActionUtil; import forge.GameActionUtil;
import forge.GameEntity; import forge.GameEntity;
@@ -34,6 +34,7 @@ import forge.game.player.Player;
import forge.game.zone.PlayerZone; import forge.game.zone.PlayerZone;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.match.CMatchUI; import forge.gui.match.CMatchUI;
import forge.util.closures.Predicate;
import forge.view.ButtonUtil; import forge.view.ButtonUtil;
/** /**
@@ -115,9 +116,9 @@ public class Untap extends Phase implements java.io.Serializable {
} }
} }
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (!Untap.canUntap(c)) { if (!Untap.canUntap(c)) {
return false; return false;
} }
@@ -194,9 +195,9 @@ public class Untap extends Phase implements java.io.Serializable {
if (Singletons.getModel().getGameState().getPhaseHandler().getPlayerTurn().isComputer()) { if (Singletons.getModel().getGameState().getPhaseHandler().getPlayerTurn().isComputer()) {
// search for lands the computer has and only untap 1 // search for lands the computer has and only untap 1
CardList landList = AllZoneUtil.getPlayerLandsInPlay(AllZone.getComputerPlayer()); CardList landList = AllZoneUtil.getPlayerLandsInPlay(AllZone.getComputerPlayer());
landList = landList.filter(CardListFilter.TAPPED).filter(new CardListFilter() { landList = landList.filter(CardPredicates.TAPPED).filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return Untap.canUntap(c); return Untap.canUntap(c);
} }
}); });
@@ -227,9 +228,9 @@ public class Untap extends Phase implements java.io.Serializable {
} // selectCard() } // selectCard()
}; // Input }; // Input
CardList landList = AllZoneUtil.getPlayerLandsInPlay(AllZone.getHumanPlayer()); CardList landList = AllZoneUtil.getPlayerLandsInPlay(AllZone.getHumanPlayer());
landList = landList.filter(CardListFilter.TAPPED).filter(new CardListFilter() { landList = landList.filter(CardPredicates.TAPPED).filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return Untap.canUntap(c); return Untap.canUntap(c);
} }
}); });
@@ -241,10 +242,10 @@ public class Untap extends Phase implements java.io.Serializable {
if (AllZoneUtil.isCardInPlay("Damping Field") || AllZoneUtil.isCardInPlay("Imi Statue")) { if (AllZoneUtil.isCardInPlay("Damping Field") || AllZoneUtil.isCardInPlay("Imi Statue")) {
if (Singletons.getModel().getGameState().getPhaseHandler().getPlayerTurn().isComputer()) { if (Singletons.getModel().getGameState().getPhaseHandler().getPlayerTurn().isComputer()) {
CardList artList = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield); CardList artList = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
artList = artList.filter(CardListFilter.ARTIFACTS); artList = artList.filter(CardPredicates.ARTIFACTS);
artList = artList.filter(CardListFilter.TAPPED).filter(new CardListFilter() { artList = artList.filter(CardPredicates.TAPPED).filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return Untap.canUntap(c); return Untap.canUntap(c);
} }
}); });
@@ -276,10 +277,10 @@ public class Untap extends Phase implements java.io.Serializable {
} // selectCard() } // selectCard()
}; // Input }; // Input
CardList artList = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield); CardList artList = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield);
artList = artList.filter(CardListFilter.ARTIFACTS); artList = artList.filter(CardPredicates.ARTIFACTS);
artList = artList.filter(CardListFilter.TAPPED).filter(new CardListFilter() { artList = artList.filter(CardPredicates.TAPPED).filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return Untap.canUntap(c); return Untap.canUntap(c);
} }
}); });
@@ -291,9 +292,9 @@ public class Untap extends Phase implements java.io.Serializable {
if ((AllZoneUtil.isCardInPlay("Smoke") || AllZoneUtil.isCardInPlay("Stoic Angel"))) { if ((AllZoneUtil.isCardInPlay("Smoke") || AllZoneUtil.isCardInPlay("Stoic Angel"))) {
if (Singletons.getModel().getGameState().getPhaseHandler().getPlayerTurn().isComputer()) { if (Singletons.getModel().getGameState().getPhaseHandler().getPlayerTurn().isComputer()) {
CardList creatures = AllZoneUtil.getCreaturesInPlay(AllZone.getComputerPlayer()); CardList creatures = AllZoneUtil.getCreaturesInPlay(AllZone.getComputerPlayer());
creatures = creatures.filter(CardListFilter.TAPPED).filter(new CardListFilter() { creatures = creatures.filter(CardPredicates.TAPPED).filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return Untap.canUntap(c); return Untap.canUntap(c);
} }
}); });
@@ -325,9 +326,9 @@ public class Untap extends Phase implements java.io.Serializable {
} // selectCard() } // selectCard()
}; // Input }; // Input
CardList creatures = AllZoneUtil.getCreaturesInPlay(AllZone.getHumanPlayer()); CardList creatures = AllZoneUtil.getCreaturesInPlay(AllZone.getHumanPlayer());
creatures = creatures.filter(CardListFilter.TAPPED).filter(new CardListFilter() { creatures = creatures.filter(CardPredicates.TAPPED).filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return Untap.canUntap(c); return Untap.canUntap(c);
} }
}); });
@@ -365,10 +366,10 @@ public class Untap extends Phase implements java.io.Serializable {
private static void doPhasing(final Player turn) { private static void doPhasing(final Player turn) {
// Needs to include phased out cards // Needs to include phased out cards
final CardList list = turn.getCardsIncludePhasingIn(ZoneType.Battlefield).filter(new CardListFilter() { final CardList list = turn.getCardsIncludePhasingIn(ZoneType.Battlefield).filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return ((c.isPhasedOut() && c.isDirectlyPhasedOut()) || c.hasKeyword("Phasing")); return ((c.isPhasedOut() && c.isDirectlyPhasedOut()) || c.hasKeyword("Phasing"));
} }
}); });

41
src/main/java/forge/game/phase/Upkeep.java
View File

@@ -23,7 +23,7 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.CardListUtil; import forge.CardListUtil;
import forge.Command; import forge.Command;
import forge.Counters; import forge.Counters;
@@ -44,6 +44,7 @@ import forge.game.zone.PlayerZone;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.gui.match.CMatchUI; import forge.gui.match.CMatchUI;
import forge.util.closures.Predicate;
import forge.view.ButtonUtil; import forge.view.ButtonUtil;
/** /**
@@ -160,9 +161,9 @@ public class Upkeep extends Phase implements java.io.Serializable {
*/ */
private static void upkeepEcho() { private static void upkeepEcho() {
CardList list = Singletons.getModel().getGameState().getPhaseHandler().getPlayerTurn().getCardsIn(ZoneType.Battlefield); CardList list = Singletons.getModel().getGameState().getPhaseHandler().getPlayerTurn().getCardsIn(ZoneType.Battlefield);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.hasStartOfKeyword("(Echo unpaid)"); return c.hasStartOfKeyword("(Echo unpaid)");
} }
}); });
@@ -480,7 +481,7 @@ public class Upkeep extends Phase implements java.io.Serializable {
final Card abyss = c; final Card abyss = c;
final CardList abyssGetTargets = AllZoneUtil.getCreaturesInPlay(player) final CardList abyssGetTargets = AllZoneUtil.getCreaturesInPlay(player)
.filter(CardListFilter.NON_ARTIFACTS); .filter(CardPredicates.NON_ARTIFACTS);
final Ability sacrificeCreature = new Ability(abyss, "") { final Ability sacrificeCreature = new Ability(abyss, "") {
@Override @Override
@@ -584,9 +585,9 @@ public class Upkeep extends Phase implements java.io.Serializable {
private Card getCompyCardToDestroy(final CardList original) { private Card getCompyCardToDestroy(final CardList original) {
final CardList options = this.getLowestPowerList(original); final CardList options = this.getLowestPowerList(original);
final CardList humanCreatures = options.filter(new CardListFilter() { final CardList humanCreatures = options.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getController().isHuman(); return c.getController().isHuman();
} }
}); });
@@ -1824,9 +1825,9 @@ public class Upkeep extends Phase implements java.io.Serializable {
CardList list = player.getCardsIn(ZoneType.Exile); CardList list = player.getCardsIn(ZoneType.Exile);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.hasSuspend(); return c.hasSuspend();
} }
}); });
@@ -1852,9 +1853,9 @@ public class Upkeep extends Phase implements java.io.Serializable {
final Player player = Singletons.getModel().getGameState().getPhaseHandler().getPlayerTurn(); final Player player = Singletons.getModel().getGameState().getPhaseHandler().getPlayerTurn();
CardList list = player.getCardsIn(ZoneType.Battlefield); CardList list = player.getCardsIn(ZoneType.Battlefield);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return CardFactoryUtil.hasKeyword(c, "Vanishing") != -1; return CardFactoryUtil.hasKeyword(c, "Vanishing") != -1;
} }
}); });
@@ -1889,9 +1890,9 @@ public class Upkeep extends Phase implements java.io.Serializable {
final Player player = Singletons.getModel().getGameState().getPhaseHandler().getPlayerTurn(); final Player player = Singletons.getModel().getGameState().getPhaseHandler().getPlayerTurn();
CardList list = player.getCardsIn(ZoneType.Battlefield); CardList list = player.getCardsIn(ZoneType.Battlefield);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return CardFactoryUtil.hasKeyword(c, "Fading") != -1; return CardFactoryUtil.hasKeyword(c, "Fading") != -1;
} }
}); });
@@ -2143,9 +2144,9 @@ public class Upkeep extends Phase implements java.io.Serializable {
@Override @Override
public void resolve() { public void resolve() {
final int num = source.getCounters(Counters.FADE); final int num = source.getCounters(Counters.FADE);
final CardList list = player.getCardsIn(ZoneType.Battlefield).filter(new CardListFilter() { final CardList list = player.getCardsIn(ZoneType.Battlefield).filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (c.isArtifact() || c.isLand() || c.isCreature()) && c.isUntapped(); return (c.isArtifact() || c.isLand() || c.isCreature()) && c.isUntapped();
} }
}); });
@@ -2154,9 +2155,9 @@ public class Upkeep extends Phase implements java.io.Serializable {
if (player.isComputer()) { if (player.isComputer()) {
Card toTap = CardFactoryUtil.getWorstPermanentAI(list, false, false, false, false); Card toTap = CardFactoryUtil.getWorstPermanentAI(list, false, false, false, false);
// try to find non creature cards without tap abilities // try to find non creature cards without tap abilities
CardList betterList = list.filter(new CardListFilter() { CardList betterList = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (c.isCreature()) { if (c.isCreature()) {
return false; return false;
} }
@@ -2229,9 +2230,9 @@ public class Upkeep extends Phase implements java.io.Serializable {
final Player player = Singletons.getModel().getGameState().getPhaseHandler().getPlayerTurn(); final Player player = Singletons.getModel().getGameState().getPhaseHandler().getPlayerTurn();
CardList blaze = player.getCardsIn(ZoneType.Battlefield); CardList blaze = player.getCardsIn(ZoneType.Battlefield);
blaze = blaze.filter(new CardListFilter() { blaze = blaze.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.isLand() && (c.getCounters(Counters.BLAZE) > 0); return c.isLand() && (c.getCounters(Counters.BLAZE) > 0);
} }
}); });
@@ -2273,9 +2274,9 @@ public class Upkeep extends Phase implements java.io.Serializable {
public void resolve() { public void resolve() {
CardList enchantmentsInLibrary = source.getController().getCardsIn(ZoneType.Library); CardList enchantmentsInLibrary = source.getController().getCardsIn(ZoneType.Library);
final CardList enchantmentsAttached = new CardList(source.getEnchantingPlayer().getEnchantedBy()); final CardList enchantmentsAttached = new CardList(source.getEnchantingPlayer().getEnchantedBy());
enchantmentsInLibrary = enchantmentsInLibrary.filter(new CardListFilter() { enchantmentsInLibrary = enchantmentsInLibrary.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (c.isEnchantment() && c.hasKeyword("Enchant player") return (c.isEnchantment() && c.hasKeyword("Enchant player")
&& !source.getEnchantingPlayer().hasProtectionFrom(c) && !source.getEnchantingPlayer().hasProtectionFrom(c)
&& !enchantmentsAttached.containsName(c)); && !enchantmentsAttached.containsName(c));

25
src/main/java/forge/game/player/AIPlayer.java
View File

@@ -22,7 +22,7 @@ import java.util.Random;
import forge.AllZone; import forge.AllZone;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.CardListUtil; import forge.CardListUtil;
import forge.Singletons; import forge.Singletons;
import forge.card.cardfactory.CardFactoryUtil; import forge.card.cardfactory.CardFactoryUtil;
@@ -201,32 +201,13 @@ public class AIPlayer extends Player {
boolean bottom = false; boolean bottom = false;
if (topN.get(i).isBasicLand()) { if (topN.get(i).isBasicLand()) {
CardList bl = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield); CardList bl = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
bl = bl.filter(new CardListFilter() { bl = bl.filter(CardPredicates.BASIC_LANDS);
@Override
public boolean addCard(final Card c) {
if (c.isBasicLand()) {
return true;
}
return false;
}
});
bottom = bl.size() > 5; // if control more than 5 Basic land, bottom = bl.size() > 5; // if control more than 5 Basic land,
// probably don't need more // probably don't need more
} else if (topN.get(i).isCreature()) { } else if (topN.get(i).isCreature()) {
CardList cl = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield); CardList cl = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
cl = cl.filter(new CardListFilter() { cl = cl.filter(CardPredicates.CREATURES);
@Override
public boolean addCard(final Card c) {
if (c.isCreature()) {
return true;
}
return false;
}
});
bottom = cl.size() > 5; // if control more than 5 Creatures, bottom = cl.size() > 5; // if control more than 5 Creatures,
// probably don't need more // probably don't need more
} }

29
src/main/java/forge/game/player/ComputerUtil.java
View File

@@ -26,7 +26,7 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.CardListUtil; import forge.CardListUtil;
import forge.CardUtil; import forge.CardUtil;
import forge.GameActionUtil; import forge.GameActionUtil;
@@ -52,6 +52,7 @@ import forge.game.phase.CombatUtil;
import forge.game.phase.PhaseType; import forge.game.phase.PhaseType;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.GuiUtils; import forge.gui.GuiUtils;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -991,9 +992,9 @@ public class ComputerUtil {
*/ */
public static CardList getAvailableMana(final Player player, final boolean checkPlayable) { public static CardList getAvailableMana(final Player player, final boolean checkPlayable) {
final CardList list = player.getCardsIn(ZoneType.Battlefield); final CardList list = player.getCardsIn(ZoneType.Battlefield);
final CardList manaSources = list.filter(new CardListFilter() { final CardList manaSources = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (checkPlayable) { if (checkPlayable) {
for (final AbilityMana am : c.getAIPlayableMana()) { for (final AbilityMana am : c.getAIPlayableMana()) {
am.setActivatingPlayer(player); am.setActivatingPlayer(player);
@@ -1212,7 +1213,7 @@ public class ComputerUtil {
return false; return false;
} }
CardList landList = computer.getCardsIn(ZoneType.Hand); CardList landList = computer.getCardsIn(ZoneType.Hand);
landList = landList.filter(CardListFilter.LANDS); landList = landList.filter(CardPredicates.LANDS);
final CardList lands = computer.getCardsIn(ZoneType.Graveyard); final CardList lands = computer.getCardsIn(ZoneType.Graveyard);
for (final Card crd : lands) { for (final Card crd : lands) {
@@ -1221,9 +1222,9 @@ public class ComputerUtil {
} }
} }
landList = landList.filter(new CardListFilter() { landList = landList.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if (c.getSVar("NeedsToPlay").length() > 0) { if (c.getSVar("NeedsToPlay").length() > 0) {
final String needsToPlay = c.getSVar("NeedsToPlay"); final String needsToPlay = c.getSVar("NeedsToPlay");
CardList list = AllZoneUtil.getCardsIn(ZoneType.Battlefield); CardList list = AllZoneUtil.getCardsIn(ZoneType.Battlefield);
@@ -1343,9 +1344,9 @@ public class ComputerUtil {
for (int ip = 0; ip < 9; ip++) { // priority 0 is the lowest, for (int ip = 0; ip < 9; ip++) { // priority 0 is the lowest,
// priority 5 the highest // priority 5 the highest
final int priority = 9 - ip; final int priority = 9 - ip;
final CardList sacMeList = typeList.filter(new CardListFilter() { final CardList sacMeList = typeList.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (!c.getSVar("SacMe").equals("") && (Integer.parseInt(c.getSVar("SacMe")) == priority)); return (!c.getSVar("SacMe").equals("") && (Integer.parseInt(c.getSVar("SacMe")) == priority));
} }
}); });
@@ -1361,9 +1362,9 @@ public class ComputerUtil {
for (int ip = 0; ip < 9; ip++) { // priority 0 is the lowest, for (int ip = 0; ip < 9; ip++) { // priority 0 is the lowest,
// priority 5 the highest // priority 5 the highest
final int priority = 9 - ip; final int priority = 9 - ip;
final CardList sacMeList = typeList.filter(new CardListFilter() { final CardList sacMeList = typeList.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return (!c.getSVar("DiscardMe").equals("") && (Integer.parseInt(c.getSVar("DiscardMe")) == priority)); return (!c.getSVar("DiscardMe").equals("") && (Integer.parseInt(c.getSVar("DiscardMe")) == priority));
} }
}); });
@@ -1630,7 +1631,7 @@ public class ComputerUtil {
typeList = typeList.getValidCards(type.split(","), activate.getController(), activate); typeList = typeList.getValidCards(type.split(","), activate.getController(), activate);
// is this needed? // is this needed?
typeList = typeList.filter(CardListFilter.UNTAPPED); typeList = typeList.filter(CardPredicates.UNTAPPED);
if (tap) { if (tap) {
typeList.remove(activate); typeList.remove(activate);
@@ -1670,7 +1671,7 @@ public class ComputerUtil {
typeList = typeList.getValidCards(type.split(","), activate.getController(), activate); typeList = typeList.getValidCards(type.split(","), activate.getController(), activate);
// is this needed? // is this needed?
typeList = typeList.filter(CardListFilter.TAPPED); typeList = typeList.filter(CardPredicates.TAPPED);
if (untap) { if (untap) {
typeList.remove(activate); typeList.remove(activate);
@@ -1739,9 +1740,9 @@ public class ComputerUtil {
*/ */
public static CardList getPossibleAttackers() { public static CardList getPossibleAttackers() {
CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield); CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return CombatUtil.canAttack(c); return CombatUtil.canAttack(c);
} }
}); });

14
src/main/java/forge/game/player/ComputerUtilAttack.java
View File

@@ -24,7 +24,6 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.CardListUtil; import forge.CardListUtil;
import forge.Counters; import forge.Counters;
import forge.GameEntity; import forge.GameEntity;
@@ -36,6 +35,7 @@ import forge.game.phase.Combat;
import forge.game.phase.CombatUtil; import forge.game.phase.CombatUtil;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.util.MyRandom; import forge.util.MyRandom;
import forge.util.closures.Predicate;
//doesHumanAttackAndWin() uses the global variable AllZone.getComputerPlayer() //doesHumanAttackAndWin() uses the global variable AllZone.getComputerPlayer()
/** /**
@@ -164,9 +164,9 @@ public class ComputerUtilAttack {
*/ */
public final CardList getPossibleAttackers(final CardList in) { public final CardList getPossibleAttackers(final CardList in) {
CardList list = new CardList(in); CardList list = new CardList(in);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return CombatUtil.canAttack(c); return CombatUtil.canAttack(c);
} }
}); });
@@ -186,9 +186,9 @@ public class ComputerUtilAttack {
*/ */
public final CardList getPossibleBlockers(final CardList blockers, final CardList attackers) { public final CardList getPossibleBlockers(final CardList blockers, final CardList attackers) {
CardList possibleBlockers = new CardList(blockers); CardList possibleBlockers = new CardList(blockers);
possibleBlockers = possibleBlockers.filter(new CardListFilter() { possibleBlockers = possibleBlockers.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return canBlockAnAttacker(c, attackers); return canBlockAnAttacker(c, attackers);
} }
}); });
@@ -841,9 +841,9 @@ public class ComputerUtilAttack {
*/ */
public final int countExaltedBonus(final Player player) { public final int countExaltedBonus(final Player player) {
CardList list = player.getCardsIn(ZoneType.Battlefield); CardList list = player.getCardsIn(ZoneType.Battlefield);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.hasKeyword("Exalted"); return c.hasKeyword("Exalted");
} }
}); });

6
src/main/java/forge/game/player/ComputerUtilBlock.java
View File

@@ -22,13 +22,13 @@ import java.util.List;
import forge.AllZone; import forge.AllZone;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.CardListUtil; import forge.CardListUtil;
import forge.Counters; import forge.Counters;
import forge.GameEntity; import forge.GameEntity;
import forge.card.cardfactory.CardFactoryUtil; import forge.card.cardfactory.CardFactoryUtil;
import forge.game.phase.Combat; import forge.game.phase.Combat;
import forge.game.phase.CombatUtil; import forge.game.phase.CombatUtil;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -455,9 +455,9 @@ public class ComputerUtilBlock {
// than the attacker // than the attacker
// Don't use blockers without First Strike or Double Strike if // Don't use blockers without First Strike or Double Strike if
// attacker has it // attacker has it
usableBlockers = blockers.filter(new CardListFilter() { usableBlockers = blockers.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
if ((attacker.hasKeyword("First Strike") || attacker.hasKeyword("Double Strike")) if ((attacker.hasKeyword("First Strike") || attacker.hasKeyword("Double Strike"))
&& !(c.hasKeyword("First Strike") || c.hasKeyword("Double Strike"))) { && !(c.hasKeyword("First Strike") || c.hasKeyword("Double Strike"))) {
return false; return false;

6
src/main/java/forge/game/player/PlayerUtil.java
View File

@@ -20,13 +20,13 @@ package forge.game.player;
import forge.AllZone; import forge.AllZone;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter;
import forge.Singletons; import forge.Singletons;
import forge.card.spellability.SpellAbility; import forge.card.spellability.SpellAbility;
import forge.control.input.Input; import forge.control.input.Input;
import forge.game.zone.PlayerZone; import forge.game.zone.PlayerZone;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
import forge.gui.match.CMatchUI; import forge.gui.match.CMatchUI;
import forge.util.closures.Predicate;
import forge.view.ButtonUtil; import forge.view.ButtonUtil;
/** /**
@@ -56,9 +56,9 @@ public final class PlayerUtil {
// Instead of hardcoded Ali from Cairo like cards, it is now a Keyword // Instead of hardcoded Ali from Cairo like cards, it is now a Keyword
CardList list = player.getCardsIn(ZoneType.Battlefield); CardList list = player.getCardsIn(ZoneType.Battlefield);
list = list.getKeyword("Damage that would reduce your life total to less than 1 reduces it to 1 instead."); list = list.getKeyword("Damage that would reduce your life total to less than 1 reduces it to 1 instead.");
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return !c.isFaceDown(); return !c.isFaceDown();
} }
}); });

4
src/main/java/forge/game/zone/MagicStack.java
View File

@@ -28,7 +28,7 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.Command; import forge.Command;
import forge.GameActionUtil; import forge.GameActionUtil;
import forge.Singletons; import forge.Singletons;
@@ -762,7 +762,7 @@ public class MagicStack extends MyObservable {
if (sp.isSpell() && AllZoneUtil.isCardInPlay("Bazaar of Wonders")) { if (sp.isSpell() && AllZoneUtil.isCardInPlay("Bazaar of Wonders")) {
boolean found = false; boolean found = false;
CardList all = AllZoneUtil.getCardsIn(ZoneType.Battlefield); CardList all = AllZoneUtil.getCardsIn(ZoneType.Battlefield);
all = all.filter(CardListFilter.NON_TOKEN); all = all.filter(CardPredicates.NON_TOKEN);
final CardList graves = AllZoneUtil.getCardsIn(ZoneType.Graveyard); final CardList graves = AllZoneUtil.getCardsIn(ZoneType.Graveyard);
all.addAll(graves); all.addAll(graves);

9
src/main/java/forge/game/zone/PlayerZoneComesIntoPlay.java
View File

@@ -24,13 +24,14 @@ import forge.AllZone;
import forge.AllZoneUtil; import forge.AllZoneUtil;
import forge.Card; import forge.Card;
import forge.CardList; import forge.CardList;
import forge.CardListFilter; import forge.CardPredicates;
import forge.Command; import forge.Command;
import forge.GameActionUtil; import forge.GameActionUtil;
import forge.card.spellability.Ability; import forge.card.spellability.Ability;
import forge.card.spellability.SpellAbility; import forge.card.spellability.SpellAbility;
import forge.card.staticability.StaticAbility; import forge.card.staticability.StaticAbility;
import forge.game.player.Player; import forge.game.player.Player;
import forge.util.closures.Predicate;
/** /**
* <p> * <p>
@@ -142,9 +143,9 @@ public class PlayerZoneComesIntoPlay extends DefaultPlayerZone {
if (c.isLand()) { if (c.isLand()) {
CardList list = player.getCardsIn(ZoneType.Battlefield); CardList list = player.getCardsIn(ZoneType.Battlefield);
list = list.filter(new CardListFilter() { list = list.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.hasKeyword("Landfall"); return c.hasKeyword("Landfall");
} }
}); });
@@ -162,7 +163,7 @@ public class PlayerZoneComesIntoPlay extends DefaultPlayerZone {
@Override @Override
public void resolve() { public void resolve() {
CardList lands = tisLand.getController().getCardsIn(ZoneType.Battlefield); CardList lands = tisLand.getController().getCardsIn(ZoneType.Battlefield);
lands = lands.filter(CardListFilter.LANDS); lands = lands.filter(CardPredicates.LANDS);
for (final Card land : lands) { for (final Card land : lands) {
land.tap(); land.tap();
} }

4
src/main/java/forge/gui/match/controllers/CDock.java
View File

@@ -33,7 +33,7 @@ import javax.swing.SwingWorker;
import forge.AllZone; import forge.AllZone;
import forge.Card; import forge.Card;
import forge.CardListFilter; import forge.CardPredicates;
import forge.Command; import forge.Command;
import forge.Constant; import forge.Constant;
import forge.Singletons; import forge.Singletons;
@@ -149,7 +149,7 @@ public enum CDock implements ICDoc {
Player human = AllZone.getHumanPlayer(); Player human = AllZone.getHumanPlayer();
if (ph.is(PhaseType.COMBAT_DECLARE_ATTACKERS, human)) { if (ph.is(PhaseType.COMBAT_DECLARE_ATTACKERS, human)) {
for(Card c : human.getCardsIn(ZoneType.Battlefield).filter(CardListFilter.CREATURES)) { for(Card c : human.getCardsIn(ZoneType.Battlefield).filter(CardPredicates.CREATURES)) {
if (!c.isAttacking() && CombatUtil.canAttack(c, AllZone.getCombat())) { if (!c.isAttacking() && CombatUtil.canAttack(c, AllZone.getCombat())) {
AllZone.getCombat().addAttacker(c); AllZone.getCombat().addAttacker(c);
} }

12
src/test/java/forge/RunTest.java
View File

@@ -280,27 +280,27 @@ public class RunTest {
c1.add(cf1.getCard("Royal Assassin", null)); c1.add(cf1.getCard("Royal Assassin", null));
c1.add(cf1.getCard("Hymn to Tourach", null)); c1.add(cf1.getCard("Hymn to Tourach", null));
CardList c3 = c1.filter(new CardListFilter() { CardList c3 = c1.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.isCreature(); return c.isCreature();
} }
}); });
this.check("119", c3.containsName("Royal Assassin")); this.check("119", c3.containsName("Royal Assassin"));
this.check("119", c3.size() == 1); this.check("119", c3.size() == 1);
c3 = c1.filter(new CardListFilter() { c3 = c1.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.isInstant(); return c.isInstant();
} }
}); });
this.check("120", c3.containsName("Shock")); this.check("120", c3.containsName("Shock"));
this.check("121", c3.size() == 1); this.check("121", c3.size() == 1);
c3 = c1.filter(new CardListFilter() { c3 = c1.filter(new Predicate<Card>() {
@Override @Override
public boolean addCard(final Card c) { public boolean isTrue(final Card c) {
return c.getName().equals("Hymn to Tourach"); return c.getName().equals("Hymn to Tourach");
} }
}); });