Trying to use less CardLists and/or hardcoded constants

src/main/java/forge/CardList.java

@@ -118,43 +118,12 @@ public class CardList extends ArrayList<Card> {
         return this.filter(Predicates.not(CardPredicates.isProtectedFrom(source)));
     }
 
-    /**
-     * <p>
-     * getValidCards.
-     * </p>
-     * 
-     * @param restrictions
-     *            a {@link java.lang.String} object.
-     * @param sourceController
-     *            a {@link forge.game.player.Player} object.
-     * @param source
-     *            a {@link forge.Card} object.
-     * @return a {@link forge.CardList} object.
-     */
     public final CardList getValidCards(final String restrictions, final Player sourceController, final Card source) {
-        return this.getValidCards(restrictions.split(","), sourceController, source);
+        return this.filter(CardPredicates.restriction(restrictions.split(","), sourceController, source));
     }
 
-    /**
-     * <p>
-     * getValidCards.
-     * </p>
-     * 
-     * @param restrictions
-     *            a {@link java.lang.String} object.
-     * @param sourceController
-     *            a {@link forge.game.player.Player} object.
-     * @param source
-     *            a {@link forge.Card} object.
-     * @return a {@link forge.CardList} object.
-     */
     public final CardList getValidCards(final String[] restrictions, final Player sourceController, final Card source) {
-        return this.filter(new Predicate<Card>() {
+        return this.filter(CardPredicates.restriction(restrictions, sourceController, source));
-            @Override
-            public boolean apply(final Card c) {
-                return (c != null) && c.isValid(restrictions, sourceController, source);
-            }
-        });
     }
 
 

src/main/java/forge/CardPredicates.java

@@ -21,6 +21,7 @@ import com.google.common.base.Function;
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
 
+import forge.card.cardfactory.CardFactoryUtil;
 import forge.card.spellability.SpellAbility;
 import forge.game.phase.CombatUtil;
 import forge.game.player.Player;
@@ -37,7 +38,7 @@ import forge.util.PredicateString;
  */
 public final class CardPredicates {
     
-    public static Predicate<Card> isController(final Player p) { 
+    public final static Predicate<Card> isController(final Player p) { 
         return new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
@@ -45,7 +46,7 @@ public final class CardPredicates {
             }
         };
     }
-    public static Predicate<Card> isOwner(final Player p) {
+    public final static Predicate<Card> isOwner(final Player p) {
         return new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
@@ -54,7 +55,7 @@ public final class CardPredicates {
         };
     }
     
-    public static Predicate<Card> isType(final String cardType) {
+    public final static Predicate<Card> isType(final String cardType) {
         return new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
@@ -63,7 +64,7 @@ public final class CardPredicates {
         };
     }
     
-    public static Predicate<Card> hasKeyword(final String keyword) {
+    public final static Predicate<Card> hasKeyword(final String keyword) {
         return new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
@@ -72,7 +73,7 @@ public final class CardPredicates {
         };
     }
     
-    public static Predicate<Card> containsKeyword(final String keyword) {
+    public final static Predicate<Card> containsKeyword(final String keyword) {
         return new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
@@ -81,7 +82,7 @@ public final class CardPredicates {
         };
     }
     
-    public static Predicate<Card> isTargetableBy(final SpellAbility source) {
+    public final static Predicate<Card> isTargetableBy(final SpellAbility source) {
         return new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
@@ -90,7 +91,7 @@ public final class CardPredicates {
         };
     }
     
-    public static Predicate<Card> nameEquals(final String name) {
+    public final static Predicate<Card> nameEquals(final String name) {
         return new Predicate<Card>() {
             @Override
             public boolean apply(Card c) {
@@ -100,7 +101,7 @@ public final class CardPredicates {
     }
     
 
-    public static Predicate<Card> possibleBlockers(final Card attacker) {
+    public final static Predicate<Card> possibleBlockers(final Card attacker) {
         return new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
@@ -116,7 +117,7 @@ public final class CardPredicates {
         }
     };
 
-    public static Predicate<Card> isProtectedFrom(final Card source) {
+    public final static Predicate<Card> isProtectedFrom(final Card source) {
         return new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
@@ -126,6 +127,15 @@ public final class CardPredicates {
     }
 
     
+    public final static Predicate<Card> restriction(final String[] restrictions, final Player sourceController, final Card source) {
+        return new Predicate<Card>() {
+            @Override
+            public boolean apply(final Card c) {
+                return (c != null) && c.isValid(restrictions, sourceController, source);
+            }
+        };
+    }    
+
     public static class Presets {
 
         /**
@@ -155,6 +165,15 @@ public final class CardPredicates {
                 return c.isCreature();
             }
         };
+        
+
+        public static final Predicate<Card> CREATURES_CAN_ATTACK = new Predicate<Card>() {
+            @Override
+            public boolean apply(final Card c) {
+                return c.isCreature() && CombatUtil.canAttack(c);
+            }
+        };
+        
         /**
          * a Predicate<Card> to get all enchantments.
          */
@@ -209,15 +228,6 @@ public final class CardPredicates {
                 return c.isToken();
             }
         };
-        /**
-         * a Predicate<Card> to get all nonbasic lands.
-         */
-        public static final Predicate<Card> NON_BASIC_LAND = new Predicate<Card>() {
-            @Override
-            public boolean apply(Card c) {
-                return !c.isBasicLand();
-            }
-        };
         /**
          * a Predicate<Card> to get all basicLands.
          */
@@ -255,15 +265,7 @@ public final class CardPredicates {
                 return c.isLand();
             }
         };
-        /**
+
-         * a Predicate<Card> to get all nonlands.
-         */
-        public static final Predicate<Card> NON_LANDS = new Predicate<Card>() {
-            @Override
-            public boolean apply(Card c) {
-                return !c.isLand();
-            }
-        };
         /**
          * a Predicate<Card> to get all cards that are black.
          */
@@ -323,6 +325,18 @@ public final class CardPredicates {
                 return c.isCreature() && (!c.hasFirstStrike() || c.hasDoubleStrike());
             }
         };
+        public static final Predicate<Card> SNOW_LANDS = new Predicate<Card>() {
+            @Override
+            public boolean apply(final Card c) {
+                return c.isLand() && c.isSnow();
+            }
+        };
+        public static final Predicate<Card> PLANEWALKERS = new Predicate<Card>() {
+            @Override
+            public boolean apply(final Card c) {
+                return c.isPlaneswalker();
+            }
+        };
     }
     
     public static class Accessors {
@@ -333,6 +347,13 @@ public final class CardPredicates {
             }
         };
 
+        public static final Function<Card, Integer> fnGetNetAttack = new Function<Card, Integer>() {
+            @Override
+            public Integer apply(Card a) {
+                return a.getNetAttack();
+            }
+        };        
+        
         public static final Function<Card, Integer> fnGetAttack = new Function<Card, Integer>() {
             @Override
             public Integer apply(Card a) {
@@ -346,5 +367,12 @@ public final class CardPredicates {
                 return a.getCMC();
             }
         };        
+        
+        public static final Function<Card, Integer> fnEvaluateCreature = new Function<Card, Integer>() {
+            @Override
+            public Integer apply(Card a) {
+                return CardFactoryUtil.evaluateCreature(a);
+            }
+        };        
     }
 }

src/main/java/forge/GameAction.java

@@ -1217,7 +1217,7 @@ public class GameAction {
      */
     private void destroyPlaneswalkers() {
         // get all Planeswalkers
-        final CardList list = AllZoneUtil.getCardsIn(ZoneType.Battlefield).getType("Planeswalker");
+        final CardList list = AllZoneUtil.getCardsIn(ZoneType.Battlefield).filter(CardPredicates.Presets.PLANEWALKERS);
 
         Card c;
         for (int i = 0; i < list.size(); i++) {
@@ -1772,7 +1772,7 @@ public class GameAction {
                     manaCost.decreaseColorlessMana(numToExile);
                 }
             } else if (spell.getSourceCard().hasKeyword("Convoke")) {
-                CardList untappedCreats = spell.getActivatingPlayer().getCardsIn(ZoneType.Battlefield).getType("Creature");
+                CardList untappedCreats = spell.getActivatingPlayer().getCardsIn(ZoneType.Battlefield).filter(CardPredicates.Presets.CREATURES);
                 untappedCreats = untappedCreats.filter(new Predicate<Card>() {
                     @Override
                     public boolean apply(final Card c) {

src/main/java/forge/GameActionUtil.java

@@ -19,6 +19,7 @@ package forge;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 
 import javax.swing.JOptionPane;
 
@@ -1229,7 +1230,7 @@ public final class GameActionUtil {
             // add +1/+1 to cards
             list.clear();
             final int num = AllZoneUtil.getCardsIn(ZoneType.Battlefield, "Coat of Arms").size();
-            final CardList creatures = AllZoneUtil.getCardsIn(ZoneType.Battlefield).getType("Creature");
+            final List<Card> creatures = AllZoneUtil.getCardsIn(ZoneType.Battlefield).filter(CardPredicates.Presets.CREATURES);
 
             for (Card c : creatures) {
                 for (Card c2 : creatures) {

src/main/java/forge/card/abilityfactory/AbilityFactoryChangeZone.java

@@ -1232,7 +1232,7 @@ public final class AbilityFactoryChangeZone {
                         System.out.println("Don't need a land or none available; trying for a creature.");
                         fetchList = fetchList.getNotType("Land");
                         // Prefer to pull a creature, generally more useful for AI.
-                        c = chooseCreature(fetchList.getType("Creature"));
+                        c = chooseCreature(fetchList.filter(CardPredicates.Presets.CREATURES));
                     }
                     if (c == null) { // Could not find a creature.
                         if (ai.getLife() <= 5) { // Desperate?
@@ -1699,7 +1699,7 @@ public final class AbilityFactoryChangeZone {
                 }
                 // Save combatants
                 else if (Singletons.getModel().getGameState().getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS_INSTANT_ABILITY)) {
-                    final CardList combatants = aiPermanents.getType("Creature");
+                    final CardList combatants = aiPermanents.filter(CardPredicates.Presets.CREATURES);
                     CardListUtil.sortByEvaluateCreature(combatants);
 
                     for (final Card c : combatants) {
@@ -1808,7 +1808,7 @@ public final class AbilityFactoryChangeZone {
                 } else if (destination.equals(ZoneType.Hand) || destination.equals(ZoneType.Library)) {
                     CardList nonLands = list.getNotType("Land");
                     // Prefer to pull a creature, generally more useful for AI.
-                    choice = chooseCreature(nonLands.getType("Creature"));
+                    choice = chooseCreature(nonLands.filter(CardPredicates.Presets.CREATURES));
                     if (choice == null) { // Could not find a creature.
                         if (AllZone.getComputerPlayer().getLife() <= 5) { // Desperate?
                             // Get something AI can cast soon.
@@ -1921,7 +1921,7 @@ public final class AbilityFactoryChangeZone {
                 } else if (destination.equals(ZoneType.Hand) || destination.equals(ZoneType.Library)) {
                     CardList nonLands = list.getNotType("Land");
                     // Prefer to pull a creature, generally more useful for AI.
-                    choice = chooseCreature(nonLands.getType("Creature"));
+                    choice = chooseCreature(nonLands.filter(CardPredicates.Presets.CREATURES));
                     if (choice == null) { // Could not find a creature.
                         if (AllZone.getComputerPlayer().getLife() <= 5) { // Desperate?
                             // Get something AI can cast soon.

src/main/java/forge/card/abilityfactory/AbilityFactoryChoose.java

@@ -34,6 +34,7 @@ import forge.AllZone;
 import forge.AllZoneUtil;
 import forge.Card;
 import forge.CardList;
+import forge.CardPredicates;
 import forge.CardPredicates.Presets;
 import forge.CardUtil;
 import forge.Constant;
@@ -738,7 +739,7 @@ public final class AbilityFactoryChoose {
                             CardList list = AllZoneUtil.getCreaturesInPlay(AllZone.getHumanPlayer());
                             if (list.isEmpty()) {
                                 list = AllZoneUtil.getCardsInGame().getController(AllZone.getHumanPlayer())
-                                        .getType("Creature");
+                                        .filter(CardPredicates.Presets.CREATURES);
                             }
                             chosen = CardFactoryUtil.getMostProminentColor(list);
                         }

src/main/java/forge/card/abilityfactory/AbilityFactoryCombat.java

@@ -25,6 +25,7 @@ import com.google.common.base.Predicate;
 import forge.AllZone;
 import forge.Card;
 import forge.CardList;
+import forge.CardPredicates;
 import forge.Singletons;
 import forge.card.cardfactory.CardFactoryUtil;
 import forge.card.spellability.AbilityActivated;
@@ -1059,7 +1060,7 @@ public final class AbilityFactoryCombat {
         boolean chance = false;
 
         if (abTgt != null) {
-            CardList list = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield).getType("Creature");
+            CardList list = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield).filter(CardPredicates.Presets.CREATURES);
             list = list.getTargetableCards(sa);
             list = list.getValidCards(abTgt.getValidTgts(), source.getController(), source);
             list = list.filter(new Predicate<Card>() {

src/main/java/forge/card/abilityfactory/AbilityFactoryEffect.java

@@ -27,6 +27,7 @@ import forge.AllZone;
 import forge.AllZoneUtil;
 import forge.Card;
 import forge.CardList;
+import forge.CardPredicates;
 import forge.Command;
 import forge.Singletons;
 import forge.card.cardfactory.CardFactoryUtil;
@@ -297,8 +298,8 @@ public class AbilityFactoryEffect {
             } else if (logic.equals("Always")) {
                 randomReturn = true;
             } else if (logic.equals("Evasion")) {
-                CardList comp = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield).getType("Creature");
+                CardList comp = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield).filter(CardPredicates.Presets.CREATURES);
-                CardList human = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield).getType("Creature");
+                CardList human = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield).filter(CardPredicates.Presets.CREATURES);
 
                 // only count creatures that can attack or block
                 comp = comp.filter(new Predicate<Card>() {

src/main/java/forge/card/abilityfactory/AbilityFactoryPermanentState.java

@@ -23,11 +23,13 @@ import java.util.Iterator;
 import java.util.Random;
 
 import com.google.common.base.Predicate;
+import com.google.common.collect.Iterables;
 
 import forge.AllZone;
 import forge.AllZoneUtil;
 import forge.Card;
 import forge.CardList;
+import forge.CardPredicates;
 import forge.CardPredicates.Presets;
 import forge.Singletons;
 import forge.card.cardfactory.CardFactoryUtil;
@@ -1065,16 +1067,8 @@ public class AbilityFactoryPermanentState {
             } else if (phase.isPlayerTurn(AllZone.getHumanPlayer())
                     && phase.getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)) {
                 // Tap creatures possible blockers before combat during AI's turn.
-                if (!tapList.getType("Creature").isEmpty()) {
+                if (Iterables.any(tapList, CardPredicates.Presets.CREATURES)) {
-                    CardList creatureList = tapList.filter(new Predicate<Card>() {
+                    CardList creatureList = tapList.filter(CardPredicates.Presets.CREATURES_CAN_ATTACK);
-                        @Override
-                        public boolean apply(final Card c) {
-                            if (c.isCreature()) {
-                                return CombatUtil.canAttack(c);
-                            }
-                            return false;
-                        }
-                    });
                     choice = CardFactoryUtil.getBestCreatureAI(creatureList);
                 } else { // no creatures available
                     choice = CardFactoryUtil.getMostExpensivePermanentAI(tapList, sa, false);

src/main/java/forge/card/abilityfactory/AbilityFactoryPreventDamage.java

@@ -25,6 +25,7 @@ import forge.AllZoneUtil;
 import forge.Card;
 import forge.CardList;
 import forge.CardListUtil;
+import forge.CardPredicates;
 import forge.CardUtil;
 import forge.Singletons;
 import forge.card.cardfactory.CardFactoryUtil;
@@ -379,7 +380,7 @@ public class AbilityFactoryPreventDamage {
                 if (targetables.size() == 0) {
                     return false;
                 }
-                final CardList combatants = targetables.getType("Creature");
+                final CardList combatants = targetables.filter(CardPredicates.Presets.CREATURES);
                 CardListUtil.sortByEvaluateCreature(combatants);
 
                 for (final Card c : combatants) {
@@ -469,7 +470,7 @@ public class AbilityFactoryPreventDamage {
         }
 
         if (compTargetables.size() > 0) {
-            final CardList combatants = compTargetables.getType("Creature");
+            final CardList combatants = compTargetables.filter(CardPredicates.Presets.CREATURES);
             CardListUtil.sortByEvaluateCreature(combatants);
             if (Singletons.getModel().getGameState().getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS_INSTANT_ABILITY)) {
                 for (final Card c : combatants) {

src/main/java/forge/card/abilityfactory/AbilityFactoryRegenerate.java

@@ -26,6 +26,7 @@ import forge.AllZoneUtil;
 import forge.Card;
 import forge.CardList;
 import forge.CardListUtil;
+import forge.CardPredicates;
 import forge.Command;
 import forge.Singletons;
 import forge.card.cardfactory.CardFactoryUtil;
@@ -340,7 +341,7 @@ public class AbilityFactoryRegenerate {
                 }
             } else {
                 if (Singletons.getModel().getGameState().getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS_INSTANT_ABILITY)) {
-                    final CardList combatants = targetables.getType("Creature");
+                    final CardList combatants = targetables.filter(CardPredicates.Presets.CREATURES);
                     CardListUtil.sortByEvaluateCreature(combatants);
 
                     for (final Card c : combatants) {
@@ -429,7 +430,7 @@ public class AbilityFactoryRegenerate {
         }
 
         if (compTargetables.size() > 0) {
-            final CardList combatants = compTargetables.getType("Creature");
+            final CardList combatants = compTargetables.filter(CardPredicates.Presets.CREATURES);
             CardListUtil.sortByEvaluateCreature(combatants);
             if (Singletons.getModel().getGameState().getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS_INSTANT_ABILITY)) {
                 for (final Card c : combatants) {
@@ -739,7 +740,7 @@ public class AbilityFactoryRegenerate {
         } else {
 
             if (Singletons.getModel().getGameState().getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS_INSTANT_ABILITY)) {
-                final CardList combatants = list.getType("Creature");
+                final CardList combatants = list.filter(CardPredicates.Presets.CREATURES);
 
                 for (final Card c : combatants) {
                     if ((c.getShield() == 0) && CombatUtil.combatantWouldBeDestroyed(c)) {

src/main/java/forge/card/cardfactory/CardFactoryArtifacts.java

@@ -2,12 +2,11 @@ package forge.card.cardfactory;
 
 import javax.swing.JOptionPane;
 
-import com.google.common.base.Predicate;
-
 import forge.AllZone;
 import forge.AllZoneUtil;
 import forge.Card;
 import forge.CardList;
+import forge.CardPredicates;
 import forge.CardPredicates.Presets;
 import forge.Command;
 import forge.Counters;
@@ -185,12 +184,7 @@ class CardFactoryArtifacts {
                         }
                     } else {
                         CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Hand);
-                        list = list.filter(new Predicate<Card>() {
+                        list = list.filter(CardPredicates.Presets.LANDS);
-                            @Override
-                            public boolean apply(final Card c) {
-                                return (c.isLand());
-                            }
-                        });
                         AllZone.getComputerPlayer().discard(list.get(0), this);
                     } // else
                 } // resolve()
@@ -223,12 +217,7 @@ class CardFactoryArtifacts {
                 public boolean canPlay() {
                     CardList list = card.getController().getCardsIn(ZoneType.Hand);
                     list.remove(card);
-                    list = list.filter(new Predicate<Card>() {
+                    list = list.filter(CardPredicates.Presets.LANDS);
-                        @Override
-                        public boolean apply(final Card c) {
-                            return (c.isLand());
-                        }
-                    });
                     return (list.size() != 0) && super.canPlay();
                 } // canPlay()
             };
@@ -399,7 +388,7 @@ class CardFactoryArtifacts {
 
                 private CardList getComputerLands() {
                     final CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Graveyard);
-                    return list.getType("Basic");
+                    return list.filter(CardPredicates.Presets.BASIC_LANDS);
                 }
             }
             final Cost abCost = new Cost(card, "1 T Sac<1/CARDNAME>", true);

src/main/java/forge/card/cardfactory/CardFactoryCreatures.java

@@ -57,7 +57,7 @@ import forge.game.zone.PlayerZone;
 import forge.game.zone.ZoneType;
 import forge.gui.GuiUtils;
 import forge.gui.match.CMatchUI;
-
+import forge.util.Aggregates;
 import forge.view.ButtonUtil;
 
 /**
@@ -215,7 +215,7 @@ public class CardFactoryCreatures {
 
                 if (card.getController().isHuman()) {
                     final CardList artifacts = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield)
-                            .getType("Artifact");
+                            .filter(CardPredicates.Presets.ARTIFACTS);
 
                     if (artifacts.size() != 0) {
                         final Card c = GuiUtils.chooseOne("Select an artifact put a phylactery counter on", artifacts);
@@ -257,8 +257,8 @@ public class CardFactoryCreatures {
 
             @Override
             public boolean canPlayAI() {
-                return (!AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield).getType("Artifact").isEmpty() && AllZone
+                return Iterables.any(AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.ARTIFACTS)
-                        .getZoneOf(this.getSourceCard()).is(ZoneType.Hand));
+                     && AllZone.getZoneOf(this.getSourceCard()).is(ZoneType.Hand);
             }
         });
         card.addComesIntoPlayCommand(intoPlay);
@@ -541,29 +541,18 @@ public class CardFactoryCreatures {
             }
 
             private static final long serialVersionUID = 35050145102566898L;
+            private final Predicate<Card> untappedCreature = Predicates.and(CardPredicates.Presets.UNTAPPED, CardPredicates.Presets.CREATURES);
 
             @Override
             public boolean canPlayAI() {
-                CardList wolves = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
+                List<Card> wolves = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield).getType("Wolf");
-                wolves = wolves.getType("Wolf");
+                Iterable<Card> untappedWolves = Iterables.filter(wolves, untappedCreature);
                 
-                wolves = wolves.filter(new Predicate<Card>() {
+                final int totalPower = Aggregates.sum(untappedWolves, CardPredicates.Accessors.fnGetNetAttack);
-                    @Override
+                if (totalPower == 0) {
-                    public boolean apply(final Card c) {
-                        return c.isUntapped() && c.isCreature();
-                    }
-                });
-                int power = 0;
-                for (int i = 0; i < wolves.size(); i++) {
-                    power += wolves.get(i).getNetAttack();
-                }
-
-                if (power == 0) {
                     return false;
                 }
 
-                final int totalPower = power;
-
                 CardList targetables = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield);
 
                 targetables = targetables.getTargetableCards(this).filter(new Predicate<Card>() {
@@ -585,15 +574,8 @@ public class CardFactoryCreatures {
 
             @Override
             public void resolve() {
-                CardList wolves = card.getController().getCardsIn(ZoneType.Battlefield);
+                CardList wolves = card.getController().getCardsIn(ZoneType.Battlefield).getType("Wolf");
-                wolves = wolves.getType("Wolf");
+                wolves = wolves.filter(untappedCreature);
-
-                wolves = wolves.filter(new Predicate<Card>() {
-                    @Override
-                    public boolean apply(final Card c) {
-                        return c.isUntapped() && c.isCreature();
-                    }
-                });
 
                 final Card target = this.getTargetCard();
 

src/main/java/forge/card/cardfactory/CardFactoryEnchantments.java

@@ -20,6 +20,7 @@ import forge.game.zone.ZoneType;
 import forge.gui.GuiUtils;
 import forge.gui.match.CMatchUI;
 import forge.view.ButtonUtil;
+import forge.CardPredicates;
 
 /** 
  * TODO: Write javadoc for this type.
@@ -81,8 +82,8 @@ class CardFactoryEnchantments {
                 public void showMessage() {
                     CardList grave = AllZone.getHumanPlayer().getCardsIn(ZoneType.Graveyard);
                     CardList aiGrave = AllZone.getComputerPlayer().getCardsIn(ZoneType.Graveyard);
-                    grave = grave.getType("Creature");
+                    grave = grave.filter(CardPredicates.Presets.CREATURES);
-                    aiGrave = aiGrave.getType("Creature");
+                    aiGrave = aiGrave.filter(CardPredicates.Presets.CREATURES);
 
                     if (this.once || ((grave.size() < 2) && (aiGrave.size() < 2))) {
                         this.once = false;

src/main/java/forge/card/cardfactory/CardFactoryInstants.java

@@ -17,12 +17,16 @@
  */
 package forge.card.cardfactory;
 
+import java.util.List;
+
 import com.google.common.base.Predicate;
+import com.google.common.collect.Iterables;
 
 import forge.AllZone;
 import forge.AllZoneUtil;
 import forge.Card;
 import forge.CardList;
+import forge.CardPredicates;
 import forge.CardPredicates.Presets;
 import forge.Command;
 import forge.Singletons;
@@ -77,9 +81,8 @@ public class CardFactoryInstants {
 
                 @Override
                 public boolean canPlayAI() {
-                    CardList humanArts = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield);
+                    List<Card> humanCards = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield);
-                    humanArts = humanArts.getType("Artifact");
+                    return Iterables.any(humanCards, CardPredicates.Presets.ARTIFACTS);
-                    return humanArts.size() > 0;
                 } //canPlayAI
 
                 @Override
@@ -91,7 +94,7 @@ public class CardFactoryInstants {
                 public void resolve() {
                     Player player = getTargetPlayer();
                     CardList artifacts = AllZoneUtil.getCardsIn(ZoneType.Battlefield);
-                    artifacts = artifacts.getType("Artifact");
+                    artifacts = artifacts.filter(CardPredicates.Presets.ARTIFACTS);
 
                     for (int i = 0; i < artifacts.size(); i++) {
                         Card thisArtifact = artifacts.get(i);
@@ -209,9 +212,8 @@ public class CardFactoryInstants {
 
                 @Override
                 public boolean canPlayAI() {
-                    CardList creature = AllZone.getComputerPlayer().getCardsIn(ZoneType.Library);
+                    Iterable<Card> creature = Iterables.filter(AllZone.getComputerPlayer().getCardsIn(ZoneType.Library), CardPredicates.Presets.CREATURES); 
-                    creature = creature.getType("Creature");
+                    return Iterables.size(creature) >= 3;
-                    return creature.size() >= 3;
                 }
             }; // SpellAbility
 

src/main/java/forge/card/cardfactory/CardFactoryLands.java

@@ -25,6 +25,7 @@ import forge.AllZone;
 import forge.AllZoneUtil;
 import forge.Card;
 import forge.CardList;
+import forge.CardPredicates;
 import forge.CardPredicates.Presets;
 import forge.Command;
 import forge.Counters;
@@ -381,8 +382,7 @@ class CardFactoryLands {
 
                     if (this.player.isComputer()) {
                         if (plains.size() > 1) {
-                            CardList tappedPlains = new CardList(plains);
+                            CardList tappedPlains = plains.filter(CardPredicates.Presets.BASIC_LANDS);
-                            tappedPlains = tappedPlains.getType("Basic");
                             for (final Card c : tappedPlains) {
                                 Singletons.getModel().getGameAction().sacrifice(c, null);
                             }

src/main/java/forge/card/cardfactory/CardFactorySorceries.java

@@ -21,11 +21,14 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map.Entry;
 import java.util.Vector;
+import java.util.List;
 
 import javax.swing.JOptionPane;
 
 import com.esotericsoftware.minlog.Log;
 import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
+import com.google.common.collect.Iterables;
 
 import forge.AllZone;
 import forge.AllZoneUtil;
@@ -36,6 +39,7 @@ import forge.CardPredicates;
 import forge.CardPredicates.Presets;
 import forge.CardUtil;
 import forge.Command;
+import forge.Constant;
 import forge.Singletons;
 import forge.card.cost.Cost;
 import forge.card.spellability.AbilitySub;
@@ -372,9 +376,8 @@ public class CardFactorySorceries {
 
                     // figure out which basic land types the computer has
                     CardList land = AllZoneUtil.getPlayerLandsInPlay(AllZone.getComputerPlayer());
-                    final String[] basic = { "Forest", "Plains", "Mountain", "Island", "Swamp" };
 
-                    for (final String element : basic) {
+                    for (final String element : Constant.Color.BASIC_LANDS) {
                         final CardList cl = land.getType(element);
                         if (!cl.isEmpty()) {
                             // remove one land of this basic type from this list
@@ -505,9 +508,8 @@ public class CardFactorySorceries {
                     // figure out which basic land types the human has
                     // put those in an set to use later
                     final CardList land = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield);
-                    final String[] basic = { "Forest", "Plains", "Mountain", "Island", "Swamp" };
 
-                    for (final String element : basic) {
+                    for (final String element : Constant.Color.BASIC_LANDS) {
                         final CardList c = land.getType(element);
                         if (!c.isEmpty()) {
                             humanBasic.add(element);
@@ -531,6 +533,7 @@ public class CardFactorySorceries {
 
         // *************** START *********** START **************************
         else if (cardName.equals("Haunting Echoes")) {
+            final Predicate<Card> nonBasicLands = Predicates.not(CardPredicates.Presets.BASIC_LANDS);
             final Cost cost = new Cost(card, "3 B B", false);
             final Target tgt = new Target(card, "Select a Player", "Player");
             final SpellAbility spell = new Spell(card, cost, tgt) {
@@ -540,33 +543,21 @@ public class CardFactorySorceries {
                 public boolean canPlayAI() {
                     // Haunting Echoes shouldn't be cast if only basic land in
                     // graveyard or library is empty
-                    CardList graveyard = AllZone.getHumanPlayer().getCardsIn(ZoneType.Graveyard);
+                    final List<Card> graveyard = AllZone.getHumanPlayer().getCardsIn(ZoneType.Graveyard);
-                    final CardList library = AllZone.getHumanPlayer().getCardsIn(ZoneType.Library);
+                    final List<Card> library = AllZone.getHumanPlayer().getCardsIn(ZoneType.Library);
-                    final int graveCount = graveyard.size();
-                    graveyard = graveyard.filter(new Predicate<Card>() {
-                        @Override
-                        public boolean apply(final Card c) {
-                            return c.isBasicLand();
-                        }
-                    });
                     
                     this.setTargetPlayer(AllZone.getHumanPlayer());
 
-                    return (((graveCount - graveyard.size()) > 0) && (library.size() > 0));
+                    return Iterables.any(graveyard, nonBasicLands) && !library.isEmpty();
                 }
 
                 @Override
                 public void resolve() {
                     final Player player = this.getTargetPlayer();
-
-                    CardList grave = player.getCardsIn(ZoneType.Graveyard);
-                    grave = grave.getNotType("Basic");
-
                     final CardList lib = player.getCardsIn(ZoneType.Library);
 
-                    for (final Card c : grave) {
+                    for (final Card c : Iterables.filter(player.getCardsIn(ZoneType.Graveyard), nonBasicLands)) {
-                        final CardList remLib = lib.filter(CardPredicates.nameEquals(c.getName()));
+                        for (final Card rem : Iterables.filter(lib, CardPredicates.nameEquals(c.getName()))) {
-                        for (final Card rem : remLib) {
                             Singletons.getModel().getGameAction().exile(rem);
                             lib.remove(rem);
                         }
@@ -697,7 +688,7 @@ public class CardFactorySorceries {
 
                     final CardList humCreats = AllZoneUtil.getCreaturesInPlay(AllZone.getHumanPlayer());
                     CardList compCreats = AllZoneUtil.getCreaturesInPlay(AllZone.getComputerPlayer());
-                    compCreats = compCreats.getType("Creature");
+                    compCreats = compCreats.filter(CardPredicates.Presets.CREATURES);
                     diff += 1.5 * (humCreats.size() - compCreats.size());
 
                     final CardList humHand = AllZone.getHumanPlayer().getCardsIn(ZoneType.Hand);
@@ -724,10 +715,7 @@ public class CardFactorySorceries {
                     // turn
                     // is structured, it will already have played land to it's
                     // limit
-
+                    return Iterables.any(AllZone.getComputerPlayer().getCardsIn(ZoneType.Hand), CardPredicates.Presets.LANDS);
-                    CardList hand = AllZone.getComputerPlayer().getCardsIn(ZoneType.Hand);
-                    hand = hand.getType("Land");
-                    return hand.size() > 0;
                 }
 
                 @Override
@@ -764,10 +752,7 @@ public class CardFactorySorceries {
                     // turn
                     // is structured, it will already have played its first
                     // land.
-                    CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Hand);
+                    return Iterables.any(AllZone.getComputerPlayer().getCardsIn(ZoneType.Hand), CardPredicates.Presets.LANDS);
-
-                    list = list.getType("Land");
-                    return list.size() > 0;
                 }
 
                 @Override
@@ -1047,8 +1032,7 @@ public class CardFactorySorceries {
 
                     final HashMap<String, Integer> countInGraveyard = new HashMap<String, Integer>();
                     final CardList allGrave = AllZone.getComputerPlayer().getCardsIn(ZoneType.Graveyard);
-                    allGrave.getType("Creature");
+                    for (final Card c : Iterables.filter(allGrave, CardPredicates.Presets.CREATURES)) {
-                    for (final Card c : allGrave) {
                         for (final String type : c.getType()) {
                             if (CardUtil.isACreatureType(type)) {
                                 if (countInGraveyard.containsKey(type)) {

src/main/java/forge/card/cardfactory/CardFactoryUtil.java

@@ -27,6 +27,7 @@ import java.util.TreeMap;
 
 import com.esotericsoftware.minlog.Log;
 import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 
 import forge.AllZone;
@@ -40,6 +41,7 @@ import forge.CardPredicates.Presets;
 import forge.CardUtil;
 import forge.Command;
 import forge.CommandArgs;
+import forge.Constant;
 import forge.Counters;
 import forge.GameActionUtil;
 import forge.Singletons;
@@ -225,40 +227,32 @@ public class CardFactoryUtil {
      * @return a {@link forge.Card} object.
      */
     public static Card getBestLandAI(final CardList list) {
-        final CardList land = list.getType("Land");
+        final CardList land = list.filter(CardPredicates.Presets.LANDS);
         if (!(land.size() > 0)) {
             return null;
         }
 
         // prefer to target non basic lands
-        final CardList nbLand = land.filter(new Predicate<Card>() {
+        final CardList nbLand = land.filter(Predicates.not(CardPredicates.Presets.BASIC_LANDS));
-            @Override
-            public boolean apply(final Card c) {
-                return (!c.isBasicLand());
-            }
-        });
 
         if (nbLand.size() > 0) {
             // TODO - Rank non basics?
-
+            return Aggregates.random(nbLand);
-            final Random r = MyRandom.getRandom();
-            return nbLand.get(r.nextInt(nbLand.size()));
         }
 
         // if no non-basic lands, target the least represented basic land type
-        final String[] names = { "Plains", "Island", "Swamp", "Mountain", "Forest" };
         String sminBL = "";
         int iminBL = 20000; // hopefully no one will ever have more than 20000
                             // lands of one type....
         int n = 0;
-        for (int i = 0; i < 5; i++) {
+        for (String name : Constant.Color.BASIC_LANDS) {
-            n = land.getType(names[i]).size();
+            n = land.getType(name).size();
             if ((n < iminBL) && (n > 0)) {
                 // if two or more are tied, only the
                 // first
                 // one checked will be used
                 iminBL = n;
-                sminBL = names[i];
+                sminBL = name;
             }
         }
         if (iminBL == 20000) {
@@ -266,16 +260,14 @@ public class CardFactoryUtil {
         }
 
         final CardList bLand = land.getType(sminBL);
-        for (int i = 0; i < bLand.size(); i++) {
+        
-            if (!bLand.get(i).isTapped()) {
+        for( Card ut : Iterables.filter(bLand, CardPredicates.Presets.UNTAPPED) )
-                // prefer untapped lands
+        {
-                return bLand.get(i);
+            return ut;
-            }
         }
 
-        final Random r = MyRandom.getRandom();
+
-        return bLand.get(r.nextInt(bLand.size())); // random tapped land of
+        return Aggregates.random(bLand); // random tapped land of least represented type
-                                                   // least represented type
     }
 
     // The AI doesn't really pick the best enchantment, just the most expensive.
@@ -293,8 +285,7 @@ public class CardFactoryUtil {
      * @return a {@link forge.Card} object.
      */
     public static Card getBestEnchantmentAI(final CardList list, final SpellAbility spell, final boolean targeted) {
-        CardList all = list;
+        CardList all = list.filter(CardPredicates.Presets.ENCHANTMENTS);
-        all = all.getType("Enchantment");
         if (targeted) {
             all = all.filter(new Predicate<Card>() {
 
@@ -304,25 +295,9 @@ public class CardFactoryUtil {
                 }
             });
         }
-        if (all.size() == 0) {
-            return null;
-        }
         
         // get biggest Enchantment
-        Card biggest = null;
+        return Aggregates.itemWithMax(all, CardPredicates.Accessors.fnGetCmc);
-        biggest = all.get(0);
-
-        int bigCMC = 0;
-        for (int i = 0; i < all.size(); i++) {
-            final int curCMC = all.get(i).getManaCost().getCMC();
-
-            if (curCMC > bigCMC) {
-                bigCMC = curCMC;
-                biggest = all.get(i);
-            }
-        }
-
-        return biggest;
     }
 
     // The AI doesn't really pick the best artifact, just the most expensive.
@@ -336,27 +311,12 @@ public class CardFactoryUtil {
      * @return a {@link forge.Card} object.
      */
     public static Card getBestArtifactAI(final CardList list) {
-        CardList all = list;
+        CardList all = list.filter(CardPredicates.Presets.ARTIFACTS);
-        all = all.getType("Artifact");
         if (all.size() == 0) {
             return null;
         }
-
         // get biggest Artifact
-        Card biggest = null;
+        return Aggregates.itemWithMax(all, CardPredicates.Accessors.fnGetCmc);
-        biggest = all.get(0);
-
-        int bigCMC = 0;
-        for (int i = 0; i < all.size(); i++) {
-            final int curCMC = all.get(i).getManaCost().getCMC();
-
-            if (curCMC > bigCMC) {
-                bigCMC = curCMC;
-                biggest = all.get(i);
-            }
-        }
-
-        return biggest;
     }
 
     /**
@@ -650,20 +610,8 @@ public class CardFactoryUtil {
      * @return the card
      */
     public static Card getBestCreatureAI(final CardList list) {
-        CardList all = list;
+        CardList all = list.filter(CardPredicates.Presets.CREATURES);
-        all = all.getType("Creature");
+        return Aggregates.itemWithMax(all, CardPredicates.Accessors.fnEvaluateCreature);
-        Card biggest = null;
-
-        if (all.size() != 0) {
-            biggest = all.get(0);
-
-            for (int i = 0; i < all.size(); i++) {
-                if (CardFactoryUtil.evaluateCreature(biggest) < CardFactoryUtil.evaluateCreature(all.get(i))) {
-                    biggest = all.get(i);
-                }
-            }
-        }
-        return biggest;
     }
 
     // This selection rates tokens higher
@@ -678,8 +626,7 @@ public class CardFactoryUtil {
      */
     public static Card getBestCreatureToBounceAI(final CardList list) {
         final int tokenBonus = 40;
-        CardList all = list;
+        CardList all = list.filter(CardPredicates.Presets.CREATURES);
-        all = all.getType("Creature");
         Card biggest = null; // returns null if list.size() == 0
         int biggestvalue = 0;
         int newvalue = 0;
@@ -728,21 +675,9 @@ public class CardFactoryUtil {
      * @return a {@link forge.Card} object.
      */
     public static Card getWorstCreatureAI(final CardList list) {
-        CardList all = list;
+        CardList all = list.filter(CardPredicates.Presets.CREATURES);
-        all = all.getType("Creature");
         // get smallest creature
-        Card smallest = null;
+        return Aggregates.itemWithMin(all, CardPredicates.Accessors.fnEvaluateCreature);
-
-        if (all.size() != 0) {
-            smallest = all.get(0);
-
-            for (int i = 0; i < all.size(); i++) {
-                if (CardFactoryUtil.evaluateCreature(smallest) > CardFactoryUtil.evaluateCreature(all.get(i))) {
-                    smallest = all.get(i);
-                }
-            }
-        }
-        return smallest;
     }
 
     /**
@@ -769,24 +704,25 @@ public class CardFactoryUtil {
         }
         System.out.println("getWorstPermanentAI: " + list);
 
-        if (biasEnch && (list.getType("Enchantment").size() > 0)) {
+        if (biasEnch && Iterables.any(list, CardPredicates.Presets.ENCHANTMENTS)) {
-            return CardFactoryUtil.getCheapestPermanentAI(list.getType("Enchantment"), null, false);
+            return CardFactoryUtil.getCheapestPermanentAI(list.filter(CardPredicates.Presets.ENCHANTMENTS), null, false);
         }
 
-        if (biasArt && (list.getType("Artifact").size() > 0)) {
+        if (biasArt && Iterables.any(list, CardPredicates.Presets.ARTIFACTS)) {
-            return CardFactoryUtil.getCheapestPermanentAI(list.getType("Artifact"), null, false);
+            return CardFactoryUtil.getCheapestPermanentAI(list.filter(CardPredicates.Presets.ARTIFACTS), null, false);
         }
 
-        if (biasLand && (list.getType("Land").size() > 0)) {
+        if (biasLand && Iterables.any(list, CardPredicates.Presets.LANDS)) {
-            return CardFactoryUtil.getWorstLand(list.getType("Land"));
+            return CardFactoryUtil.getWorstLand(list.filter(CardPredicates.Presets.LANDS));
         }
 
-        if (biasCreature && (list.getType("Creature").size() > 0)) {
+        if (biasCreature && Iterables.any(list, CardPredicates.Presets.CREATURES)) {
-            return CardFactoryUtil.getWorstCreatureAI(list.getType("Creature"));
+            return CardFactoryUtil.getWorstCreatureAI(list.filter(CardPredicates.Presets.CREATURES));
         }
 
-        if (list.getType("Land").size() > 6) {
+        CardList lands = list.filter(CardPredicates.Presets.LANDS);
-            return CardFactoryUtil.getWorstLand(list.getType("Land"));
+        if (lands.size() > 6) {
+            return CardFactoryUtil.getWorstLand(lands);
         }
 
         if ((list.getType("Artifact").size() > 0) || (list.getType("Enchantment").size() > 0)) {
@@ -2540,10 +2476,8 @@ public class CardFactoryUtil {
         // Count$Domain
         if (sq[0].contains("Domain")) {
             someCards.addAll(cardController.getCardsIn(ZoneType.Battlefield));
-            final String[] basic = { "Forest", "Plains", "Mountain", "Island", "Swamp" };
+            for (String basic : Constant.Color.BASIC_LANDS) {
-
+                if (!someCards.getType(basic).isEmpty()) {
-            for (int i = 0; i < basic.length; i++) {
-                if (!someCards.getType(basic[i]).isEmpty()) {
                     n++;
                 }
             }
@@ -2553,10 +2487,8 @@ public class CardFactoryUtil {
         // Count$OpponentDom
         if (sq[0].contains("OpponentDom")) {
             someCards.addAll(cardController.getOpponent().getCardsIn(ZoneType.Battlefield));
-            final String[] basic = { "Forest", "Plains", "Mountain", "Island", "Swamp" };
+            for (String basic : Constant.Color.BASIC_LANDS) {
-
+                if (!someCards.getType(basic).isEmpty()) {
-            for (int i = 0; i < basic.length; i++) {
-                if (!someCards.getType(basic[i]).isEmpty()) {
                     n++;
                 }
             }
@@ -3702,38 +3634,14 @@ public class CardFactoryUtil {
      */
     public static Card getWorstLand(final CardList lands) {
         Card worstLand = null;
+        int maxScore = 0;
         // first, check for tapped, basic lands
-        for (int i = 0; i < lands.size(); i++) {
+        for (Card tmp : lands) {
-            final Card tmp = lands.get(i);
+            int score = tmp.isTapped() ? 2 : 0;
-            if (tmp.isTapped() && tmp.isBasicLand()) {
+            score += tmp.isBasicLand() ? 1 : 0;
+            if( score >= maxScore ) {
                 worstLand = tmp;
-            }
+                maxScore = score;
-        }
-        // next, check for tapped, non-basic lands
-        if (worstLand == null) {
-            for (int i = 0; i < lands.size(); i++) {
-                final Card tmp = lands.get(i);
-                if (tmp.isTapped()) {
-                    worstLand = tmp;
-                }
-            }
-        }
-        // next, untapped, basic lands
-        if (worstLand == null) {
-            for (int i = 0; i < lands.size(); i++) {
-                final Card tmp = lands.get(i);
-                if (tmp.isUntapped() && tmp.isBasicLand()) {
-                    worstLand = tmp;
-                }
-            }
-        }
-        // next, untapped, non-basic lands
-        if (worstLand == null) {
-            for (int i = 0; i < lands.size(); i++) {
-                final Card tmp = lands.get(i);
-                if (tmp.isUntapped()) {
-                    worstLand = tmp;
-                }
             }
         }
         return worstLand;

src/main/java/forge/card/mana/Mana.java

@@ -120,17 +120,6 @@ public class Mana {
         return this.pumpCounterMagic;
     }
 
-    /**
-     * <p>
-     * fromBasicLand.
-     * </p>
-     * 
-     * @return a boolean.
-     */
-    public final boolean fromBasicLand() {
-        return this.sourceCard.isBasicLand();
-    } // for Imperiosaur
-
     /**
      * <p>
      * isColor.

src/main/java/forge/card/spellability/SpellPermanent.java

@@ -18,6 +18,7 @@
 package forge.card.spellability;
 
 import java.util.HashMap;
+import java.util.List;
 
 import com.google.common.collect.Iterables;
 
@@ -355,10 +356,11 @@ public class SpellPermanent extends Spell {
         }
         if (card.isPlaneswalker()) {
             CardList list = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
-            list = list.getType("Planeswalker");
+            list = list.filter(CardPredicates.Presets.PLANEWALKERS);
 
             for (int i = 0; i < list.size(); i++) {
-                final String subtype = card.getType().get(card.getType().size() - 1);
+                List<String> type = card.getType();
+                final String subtype = type.get(type.size() - 1);
                 final CardList cl = list.getType(subtype);
 
                 if (cl.size() > 0) {

src/main/java/forge/control/input/InputAttack.java

@@ -17,9 +17,12 @@
  */
 package forge.control.input;
 
+import com.google.common.collect.Iterables;
+
 import forge.AllZone;
 import forge.Card;
 import forge.CardList;
+import forge.CardPredicates;
 import forge.Singletons;
 import forge.game.phase.CombatUtil;
 import forge.game.zone.PlayerZone;
@@ -62,9 +65,7 @@ public class InputAttack extends Input {
         if (AllZone.getCombat().getRemainingDefenders() == 0) {
             // Nothing left to attack, has to attack this defender
             CardList possibleAttackers = AllZone.getHumanPlayer().getCardsIn(ZoneType.Battlefield);
-            possibleAttackers = possibleAttackers.getType("Creature");
+            for (Card c : Iterables.filter(possibleAttackers, CardPredicates.Presets.CREATURES)) {
-            for (int i = 0; i < possibleAttackers.size(); i++) {
-                final Card c = possibleAttackers.get(i);
                 if (c.hasKeyword("CARDNAME attacks each turn if able.") && CombatUtil.canAttack(c, AllZone.getCombat())
                         && !c.isAttacking()) {
                     AllZone.getCombat().addAttacker(c);

src/main/java/forge/game/GameNew.java

@@ -7,10 +7,15 @@ import java.util.Random;
 
 import javax.swing.JOptionPane;
 
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
+import com.google.common.collect.Iterables;
+
 import forge.AllZone;
 import forge.Card;
 import forge.CardList;
 import forge.CardPredicates.Presets;
+import forge.CardPredicates;
 import forge.CardUtil;
 import forge.Constant;
 import forge.GameAction;
@@ -31,6 +36,7 @@ import forge.item.CardPrinted;
 import forge.properties.ForgePreferences.FPref;
 import forge.properties.ForgeProps;
 import forge.properties.NewConstants.Lang.GameAction.GameActionText;
+import forge.util.Aggregates;
 import forge.util.MyRandom;
 
 /** 
@@ -268,16 +274,13 @@ public class GameNew {
             final String nl = System.getProperty("line.separator");
             final StringBuilder msg = new StringBuilder();
             for (final Player p : AllZone.getPlayersInGame()) {
-                final CardList lib = p.getCardsIn(ZoneType.Library);
+                final List<Card> lib = p.getCardsIn(ZoneType.Library);
-                Card ante;
+                Predicate<Card> goodForAnte = Predicates.not(CardPredicates.Presets.BASIC_LANDS);
-                if ((lib.size() > 0) && (lib.getNotType("Basic").size() > 1)) {
+                Card ante = Aggregates.random(Iterables.filter(lib, goodForAnte));
-                    ante = CardUtil.getRandom(lib);
+                if (ante == null ) {
-                    while (ante.isBasicLand()) {
+                    if (!lib.isEmpty()) 
-                        ante = CardUtil.getRandom(lib);
-                    }
-                } else if (lib.size() > 1) {
                         ante = lib.get(0);
-                } else {
+                    else
                         throw new RuntimeException(p + " library is empty.");                        
                 }
                 AllZone.getGameLog().add("Ante", p + " anted " + ante, 0);
@@ -375,10 +378,10 @@ public class GameNew {
         library.shuffle();
 
         // remove all land, keep non-basicland in there, shuffled
-        CardList land = library.getType("Land");
+        CardList land = library.filter(CardPredicates.Presets.LANDS);
-        for (int i = 0; i < land.size(); i++) {
+        for (Card c : land) {
-            if (land.get(i).isLand()) {
+            if (c.isLand()) {
-                library.remove(land.get(i));
+                library.remove(c);
             }
         }
 
@@ -444,10 +447,10 @@ public class GameNew {
      */
     private static void seeWhoPlaysFirst() {
         final GameAction ga = Singletons.getModel().getGameAction();
-        CardList hLibrary = AllZone.getHumanPlayer().getCardsIn(ZoneType.Library);
+        Predicate<Card> nonLand = Predicates.not(Presets.LANDS);
-        hLibrary = hLibrary.filter(Presets.NON_LANDS);
+        Iterable<Card> hLibrary = Iterables.filter(AllZone.getHumanPlayer().getCardsIn(ZoneType.Library), nonLand);
-        CardList cLibrary = AllZone.getComputerPlayer().getCardsIn(ZoneType.Library);
+        Iterable<Card> cLibrary = Iterables.filter(AllZone.getComputerPlayer().getCardsIn(ZoneType.Library), nonLand);
-        cLibrary = cLibrary.filter(Presets.NON_LANDS);
+
 
         final boolean starterDetermined = false;
         int cutCount = 0;
@@ -457,8 +460,9 @@ public class GameNew {
                 break;
             }
 
-            if (hLibrary.size() > 0) {
+            Card hRandom = Aggregates.random(hLibrary);
-                ga.setHumanCut(hLibrary.get(MyRandom.getRandom().nextInt(hLibrary.size())));
+            if ( null != hRandom ) {
+                ga.setHumanCut(hRandom);
             } else {
                 GameNew.computerStartsGame();
                 JOptionPane.showMessageDialog(null, ForgeProps.getLocalized(GameActionText.HUMAN_MANA_COST) + "\r\n"
@@ -466,8 +470,9 @@ public class GameNew {
                 return;
             }
 
-            if (cLibrary.size() > 0) {
+            Card cRandom = Aggregates.random(cLibrary);
-                ga.setComputerCut(cLibrary.get(MyRandom.getRandom().nextInt(cLibrary.size())));
+            if (cRandom != null) {
+                ga.setComputerCut(cRandom);
             } else {
                 JOptionPane.showMessageDialog(null, ForgeProps.getLocalized(GameActionText.COMPUTER_MANA_COST) + "\r\n"
                         + ForgeProps.getLocalized(GameActionText.HUMAN_STARTS), "", JOptionPane.INFORMATION_MESSAGE);

src/main/java/forge/game/phase/Combat.java

@@ -30,6 +30,7 @@ import forge.AllZone;
 import forge.AllZoneUtil;
 import forge.Card;
 import forge.CardList;
+import forge.CardPredicates;
 import forge.GameActionUtil;
 import forge.GameEntity;
 import forge.Singletons;
@@ -111,7 +112,7 @@ public class Combat {
         this.defenders.add((GameEntity) defender);
         this.defenderMap.put((GameEntity) defender, new CardList());
         CardList planeswalkers = defender.getCardsIn(ZoneType.Battlefield);
-        planeswalkers = planeswalkers.getType("Planeswalker");
+        planeswalkers = planeswalkers.filter(CardPredicates.Presets.PLANEWALKERS);
         for (final Card pw : planeswalkers) {
             this.defenders.add((GameEntity) pw);
             this.defenderMap.put((GameEntity) pw, new CardList());

src/main/java/forge/game/phase/CombatUtil.java

@@ -33,6 +33,7 @@ import forge.AllZoneUtil;
 import forge.Card;
 import forge.CardList;
 import forge.CardListUtil;
+import forge.CardPredicates;
 import forge.Command;
 import forge.Constant;
 import forge.Counters;
@@ -400,7 +401,7 @@ public class CombatUtil {
                         boolean must = true;
                         if (attacker.hasKeyword("CARDNAME can't be blocked except by two or more creatures.")) {
                             final CardList possibleBlockers = combat.getDefendingPlayer().getCardsIn(ZoneType.Battlefield)
-                                    .getType("Creature");
+                                    .filter(CardPredicates.Presets.CREATURES);
                             possibleBlockers.remove(blocker);
                             if (!CombatUtil.canBeBlocked(attacker, possibleBlockers)) {
                                 must = false;
@@ -524,7 +525,7 @@ public class CombatUtil {
                 boolean canBe = true;
                 if (attacker.hasKeyword("CARDNAME can't be blocked except by two or more creatures.")) {
                     final CardList blockers = combat.getDefendingPlayer().getCardsIn(ZoneType.Battlefield)
-                            .getType("Creature");
+                            .filter(CardPredicates.Presets.CREATURES);
                     blockers.remove(blocker);
                     if (!CombatUtil.canBeBlocked(attacker, blockers)) {
                         canBe = false;
@@ -542,7 +543,7 @@ public class CombatUtil {
                     boolean canBe = true;
                     if (attacker.hasKeyword("CARDNAME can't be blocked except by two or more creatures.")) {
                         final CardList blockers = combat.getDefendingPlayer().getCardsIn(ZoneType.Battlefield)
-                                .getType("Creature");
+                                .filter(CardPredicates.Presets.CREATURES);
                         blockers.remove(blocker);
                         if (!CombatUtil.canBeBlocked(attacker, blockers)) {
                             canBe = false;
@@ -929,12 +930,7 @@ public class CombatUtil {
                     return false;
                 }
             } else if (keyword.equals("CARDNAME can't attack unless defending player controls a snow land.")) {
-                temp = list.filter(new Predicate<Card>() {
+                temp = list.filter(CardPredicates.Presets.SNOW_LANDS);
-                    @Override
-                    public boolean apply(final Card c) {
-                        return c.isLand() && c.isSnow();
-                    }
-                });
                 if (temp.isEmpty()) {
                     return false;
                 }

src/main/java/forge/game/phase/PhaseHandler.java

@@ -831,7 +831,7 @@ public class PhaseHandler extends MyObservable implements java.io.Serializable {
         // resets the status of attacked/blocked this phase
         CardList list = player.getCardsIn(ZoneType.Battlefield);
 
-        list = list.getType("Creature");
+        list = list.filter(CardPredicates.Presets.CREATURES);
 
         for (int i = 0; i < list.size(); i++) {
             final Card c = list.get(i);

src/main/java/forge/game/phase/Upkeep.java

@@ -1959,9 +1959,8 @@ public class Upkeep extends Phase implements java.io.Serializable {
                                     oathFlag = false;
                                 }
                             } else { // if player == Computer
-                                final CardList creaturesInLibrary = player.getCardsIn(ZoneType.Library).getType("Creature");
+                                final CardList creaturesInLibrary = player.getCardsIn(ZoneType.Library).filter(CardPredicates.Presets.CREATURES);
-                                final CardList creaturesInBattlefield = player.getCardsIn(ZoneType.Battlefield).getType(
+                                final CardList creaturesInBattlefield = player.getCardsIn(ZoneType.Battlefield).filter(CardPredicates.Presets.CREATURES);
-                                        "Creature");
 
                                 // if there are at least 3 creatures in library,
                                 // or none in play with one in library, oath

src/main/java/forge/game/player/AIPlayer.java

@@ -19,6 +19,8 @@ package forge.game.player;
 
 import java.util.Random;
 
+import com.google.common.collect.Iterables;
+
 import forge.AllZone;
 import forge.Card;
 import forge.CardList;
@@ -201,9 +203,9 @@ public class AIPlayer extends Player {
             boolean bottom = false;
             if (topN.get(i).isBasicLand()) {
                 CardList bl = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
-                bl = bl.filter(CardPredicates.Presets.BASIC_LANDS);
+                int nBasicLands = Iterables.size(Iterables.filter(bl, CardPredicates.Presets.BASIC_LANDS));
 
-                bottom = bl.size() > 5; // if control more than 5 Basic land,
+                bottom = nBasicLands > 5; // if control more than 5 Basic land,
                                         // probably don't need more
             } else if (topN.get(i).isCreature()) {
                 CardList cl = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);

src/main/java/forge/game/player/ComputerUtil.java

@@ -21,8 +21,10 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.HashMap;
+import java.util.List;
 
 import com.google.common.base.Predicate;
+import com.google.common.collect.Iterables;
 
 import forge.AllZone;
 import forge.AllZoneUtil;
@@ -32,6 +34,7 @@ import forge.CardListUtil;
 import forge.CardPredicates;
 import forge.CardPredicates.Presets;
 import forge.CardUtil;
+import forge.Constant;
 import forge.GameActionUtil;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
@@ -1386,15 +1389,14 @@ public class ComputerUtil {
 
             Card land = landList.get(ix);
             //play basic lands that are needed the most
-            if (landList.getNotType("Basic").isEmpty()) {
+            if (!Iterables.any(landList, CardPredicates.Presets.BASIC_LANDS)) {
                 final CardList combined = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
 
-                final String[] names = "Plains,Island,Swamp,Mountain,Forest".split(",");
                 final ArrayList<String> basics = new ArrayList<String>();
 
                 // what types can I go get?
-                for (final String name : names) {
+                for (final String name : Constant.CardTypes.BASIC_TYPES) {
-                    if (landList.getType(name).size() != 0) {
+                    if (!landList.getType(name).isEmpty()) {
                         basics.add(name);
                     }
                 }
@@ -1611,8 +1613,9 @@ public class ComputerUtil {
             if (hand.size() <= 0) {
                 continue;
             }
-            final int numLandsInPlay = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield).getType("Land").size();
+            List<Card> aiCards = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield);
-            final CardList landsInHand = hand.getType("Land");
+            final int numLandsInPlay = Iterables.size(Iterables.filter(aiCards, CardPredicates.Presets.LANDS)); 
+            final CardList landsInHand = hand.filter(CardPredicates.Presets.LANDS);
             final int numLandsInHand = landsInHand.size();
 
             // Discard a land
@@ -2257,8 +2260,8 @@ public class ComputerUtil {
         if (!discard.getSVar("DiscardMe").equals("")) {
             return true;
         }
-        final CardList landsInPlay = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield).getType("Land");
+        final CardList landsInPlay = AllZone.getComputerPlayer().getCardsIn(ZoneType.Battlefield).filter(CardPredicates.Presets.LANDS);
-        final CardList landsInHand = AllZone.getComputerPlayer().getCardsIn(ZoneType.Hand).getType("Land");
+        final CardList landsInHand = AllZone.getComputerPlayer().getCardsIn(ZoneType.Hand).filter(CardPredicates.Presets.LANDS);
         final CardList nonLandsInHand = AllZone.getComputerPlayer().getCardsIn(ZoneType.Hand).getNotType("Land");
         final int highestCMC = Math.max(6, Aggregates.max(nonLandsInHand, CardPredicates.Accessors.fnGetCmc));
         final int discardCMC = discard.getCMC();

src/main/java/forge/game/player/ComputerUtilAttack.java

@@ -27,6 +27,7 @@ import forge.AllZoneUtil;
 import forge.Card;
 import forge.CardList;
 import forge.CardListUtil;
+import forge.CardPredicates;
 import forge.Counters;
 import forge.GameEntity;
 import forge.Singletons;
@@ -75,10 +76,10 @@ public class ComputerUtilAttack {
      */
     public ComputerUtilAttack(final CardList possibleAttackers, final CardList possibleBlockers) {
         this.humanList = new CardList(possibleBlockers);
-        this.humanList = this.humanList.getType("Creature");
+        this.humanList = this.humanList.filter(CardPredicates.Presets.CREATURES);
 
         this.computerList = new CardList(possibleAttackers);
-        this.computerList = this.computerList.getType("Creature");
+        this.computerList = this.computerList.filter(CardPredicates.Presets.CREATURES);
 
         this.attackers = this.getPossibleAttackers(possibleAttackers);
         this.blockers = this.getPossibleBlockers(possibleBlockers, this.attackers);

src/main/java/forge/game/player/Player.java

@@ -28,6 +28,8 @@ import java.util.Random;
 
 import javax.swing.JOptionPane;
 
+import com.google.common.collect.Iterables;
+
 import forge.AllZone;
 import forge.AllZoneUtil;
 import forge.Card;
@@ -1886,7 +1888,7 @@ public abstract class Player extends GameEntity  implements Comparable<Player> {
      * @return a {@link forge.Card} object.
      */
     public final Card getPlaneswalker() {
-        final CardList c = this.getCardsIn(ZoneType.Battlefield).getType("Planeswalker");
+        final CardList c = this.getCardsIn(ZoneType.Battlefield).filter(CardPredicates.Presets.PLANEWALKERS);
         if ((null != c) && (c.size() > 0)) {
             return c.get(0);
         } else {
@@ -2284,7 +2286,7 @@ public abstract class Player extends GameEntity  implements Comparable<Player> {
      * @return a boolean.
      */
     public final boolean hasMetalcraft() {
-        final CardList list = this.getCardsIn(ZoneType.Battlefield).getType("Artifact");
+        final CardList list = this.getCardsIn(ZoneType.Battlefield).filter(CardPredicates.Presets.ARTIFACTS);
         return list.size() >= 3;
     }
 
@@ -2318,9 +2320,8 @@ public abstract class Player extends GameEntity  implements Comparable<Player> {
      * @return a boolean.
      */
     public final boolean hasLandfall() {
-        final CardList list = ((DefaultPlayerZone) this.getZone(ZoneType.Battlefield)).getCardsAddedThisTurn(null).getType(
+        final List<Card> list = ((DefaultPlayerZone) this.getZone(ZoneType.Battlefield)).getCardsAddedThisTurn(null);
-                "Land");
+        return Iterables.any(list, CardPredicates.Presets.LANDS);
-        return !list.isEmpty();
     }
 
     /**

src/main/java/forge/util/Aggregates.java

@@ -26,6 +26,20 @@ public class Aggregates {
         return max;
     }
 
+    public final static <T> T itemWithMax(final Iterable<T> source, final Function<T, Integer> valueAccessor) {
+        if (source == null) { return null; }  
+        int max = Integer.MIN_VALUE;
+        T result = null;
+        for (final T c : source) {
+            int value = valueAccessor.apply(c);
+            if ( value > max ) {
+                max = value;
+                result = c;
+            }
+        }
+        return result;
+    }
+    
     public final static <T> int sum(final Iterable<T> source, final Function<T, Integer> valueAccessor) {
         int result = 0;
         if (source != null) {
@@ -58,15 +72,6 @@ public class Aggregates {
 
     // Get several random values
     // should improve to make 1 pass over source and track N candidates at once
-    /**
-     * Random.
-     * 
-     * @param source
-     *            the source
-     * @param count
-     *            the count
-     * @return the list
-     */
     public final static <T> List<T> random(final Iterable<T> source, final int count) {
         final List<T> result = new ArrayList<T>();
         for (int i = 0; i < count; ++i) {
@@ -79,21 +84,6 @@ public class Aggregates {
         return result;
     }
     
-    /**
-     * Unique by last.
-     * 
-     * @param <K>
-     *            the key type
-     * @param <U>
-     *            the generic type
-     * @param source
-     *            the source
-     * @param fnUniqueKey
-     *            the fn unique key
-     * @param accessor
-     *            the accessor
-     * @return the iterable
-     */
     public static final <K, U> Iterable<U> uniqueByLast(final Iterable<U> source, final Function<U, K> fnUniqueKey) { // this might be exotic
         final Map<K, U> uniques = new Hashtable<K, U>();
         for (final U c : source) {
@@ -102,4 +92,19 @@ public class Aggregates {
         return uniques.values();
     }
 
+
+    public static <T> T itemWithMin(final Iterable<T> source, final Function<T, Integer> valueAccessor) {
+        if (source == null) { return null; }  
+        int max = Integer.MAX_VALUE;
+        T result = null;
+        for (final T c : source) {
+            int value = valueAccessor.apply(c);
+            if ( value < max ) {
+                max = value;
+                result = c;
+            }
+        }
+        return result;
+    }    
+
 }