implement and use new PredicateCard

This fixes the THB and ELD draft, possibly others

Signed-off-by: Jamin W. Collins <jamin.collins@gmail.com>

forge-core/src/main/java/forge/item/IPaperCard.java

@@ -6,6 +6,7 @@ import forge.card.CardRarity;
 import forge.card.CardRules;
 import forge.card.CardType.CoreType;
 import forge.card.MagicColor;
+import forge.util.PredicateCard;
 import forge.util.PredicateString;
 import org.apache.commons.lang3.StringUtils;
 
@@ -60,6 +61,8 @@ public interface IPaperCard extends InventoryItem {
             return new PredicateNames(what);
         }
 
+        public static PredicateCards cards(final List<PaperCard> what) { return new PredicateCards(what); }
+
         private static final class PredicateColor implements Predicate<PaperCard> {
 
             private final byte operand;
@@ -161,6 +164,25 @@ public interface IPaperCard extends InventoryItem {
             }
         }
 
+        private static final class PredicateCards extends PredicateCard<PaperCard> {
+            private final List<PaperCard> operand;
+
+            @Override
+            public boolean apply(final PaperCard card) {
+                for (final PaperCard element : this.operand) {
+                    if (this.op(card, element)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            private PredicateCards(final List<PaperCard> operand) {
+                super(StringOp.EQUALS);
+                this.operand = operand;
+            }
+        }
+
         /**
          * Pre-built predicates are stored here to allow their re-usage and
          * easier access from code.

forge-core/src/main/java/forge/item/generation/BoosterGenerator.java

@@ -566,12 +566,8 @@ public class BoosterGenerator {
                 toAdd = IPaperCard.Predicates.printedInSets(sets);
             } else if (operator.startsWith("fromSheet(") && invert) {
                 String sheetName = StringUtils.strip(operator.substring(9), "()\" ");
-                Iterable<PaperCard> src = StaticData.instance().getPrintSheets().get(sheetName).toFlatList();
-                List<String> cardNames = Lists.newArrayList();
-                for (PaperCard card : src) {
-                    cardNames.add(card.getName());
-                }
-                toAdd = IPaperCard.Predicates.names(Lists.newArrayList(cardNames));
+                Iterable<PaperCard> cards = StaticData.instance().getPrintSheets().get(sheetName).toFlatList();
+                toAdd = IPaperCard.Predicates.cards(Lists.newArrayList(cards));
             }
 
             if (toAdd == null) {

forge-core/src/main/java/forge/util/PredicateCard.java

@@ -0,0 +1,83 @@
+/*
+ * Forge: Play Magic: the Gathering.
+ * Copyright (C) 2020 Jamin W. Collins
+ *
+ * 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.util;
+
+import com.google.common.base.Predicate;
+import forge.item.PaperCard;
+
+/**
+ * Special predicate class to perform string operations.
+ * 
+ * @param <T>
+ *            the generic type
+ */
+public abstract class PredicateCard<T> implements Predicate<T> {
+    /** Possible operators for string operands. */
+    public enum StringOp {
+        /** The EQUALS. */
+        EQUALS,
+    }
+
+    /** The operator. */
+    private final StringOp operator;
+
+    /**
+     * Op.
+     *
+     * @param op1
+     *            the op1
+     * @param op2
+     *            the op2
+     * @return true, if successful
+     */
+    protected final boolean op(final PaperCard op1, final PaperCard op2) {
+        switch (this.getOperator()) {
+        case EQUALS:
+            return op1.equals(op2);
+        default:
+            return false;
+        }
+    }
+
+    /**
+     * Instantiates a new predicate string.
+     *
+     * @param operator
+     *            the operator
+     */
+    public PredicateCard(final StringOp operator) {
+        this.operator = operator;
+    }
+
+    /**
+     * @return the operator
+     */
+    public StringOp getOperator() {
+        return operator;
+    }
+
+    public static PredicateCard<PaperCard> equals(final PaperCard what) {
+        return new PredicateCard<PaperCard>(StringOp.EQUALS) {
+            @Override
+            public boolean apply(PaperCard subject) {
+                return op(subject, what);
+            }
+        };
+    }
+
+}