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

CardUtil.getColor(card) returns colorSet instead of strings collection

Browse Source
This commit is contained in:
Maxmtg
2013-05-07 17:32:31 +00:00
parent 8c56989816
commit 9893cfd143
17 changed files with 150 additions and 406 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -43,6 +43,8 @@ import forge.CardPredicates.Presets;
import forge.card.CardCharacteristics;
import forge.card.CardRarity;
import forge.card.CardRules;
import forge.card.ColorSet;
import forge.card.MagicColor;
import forge.card.ability.AbilityUtils;
import forge.card.ability.ApiType;
import forge.card.cardfactory.CardFactoryUtil;
@@ -5211,59 +5213,34 @@ public class Card extends GameEntity implements Comparable<Card> {
}
// ... Card colors
else if (property.contains("White") || property.contains("Blue") || property.contains("Black")
|| property.contains("Red") || property.contains("Green") || property.contains("Colorless")) {
if (property.startsWith("non")) {
if (CardUtil.getColors(this).contains(property.substring(3).toLowerCase())) {
|| property.contains("Red") || property.contains("Green") ) {
boolean mustHave = !property.startsWith("non");
int desiredColor = MagicColor.fromName(mustHave ? property : property.substring(3));
boolean hasColor = CardUtil.getColors(this).hasAnyColor(desiredColor);
if( mustHave != hasColor )
return false;
}
} else if (!CardUtil.getColors(this).contains(property.toLowerCase())) {
return false;
}
} else if (property.contains("MultiColor")) // ... Card is multicolored
{
if (property.startsWith("non") && (CardUtil.getColors(this).size() > 1)) {
return false;
}
if (!property.startsWith("non") && (CardUtil.getColors(this).size() <= 1)) {
return false;
}
} else if (property.contains("MonoColor")) {
// ... Card is monocolored
if (property.startsWith("non") && ((CardUtil.getColors(this).size() == 1) && !this.isColorless())) {
return false;
}
if (!property.startsWith("non") && ((CardUtil.getColors(this).size() > 1) || this.isColorless())) {
return false;
}
} else if (property.contains("Colorless")) { // ... Card is colorless
if( property.startsWith("non") == CardUtil.getColors(this).isColorless() ) return false;
} else if (property.contains("MultiColor")) { // ... Card is multicolored
if( property.startsWith("non") == CardUtil.getColors(this).isMulticolor() ) return false;
} else if (property.contains("MonoColor")) { // ... Card is monocolored
if( property.startsWith("non") == CardUtil.getColors(this).isMonoColor() ) return false;
} else if (property.equals("ChosenColor")) {
if (source.getChosenColor().size() == 0) {
if (source.getChosenColor().isEmpty() || !CardUtil.getColors(this).hasAnyColor(MagicColor.fromName(source.getChosenColor().get(0))))
return false;
}
if (!CardUtil.getColors(this).contains(source.getChosenColor().get(0))) {
return false;
}
} else if (property.equals("AllChosenColors")) {
if (source.getChosenColor().size() == 0) {
if ( source.getChosenColor().isEmpty() || !CardUtil.getColors(this).hasAllColors(ColorSet.fromNames(source.getChosenColor()).getColor()) )
return false;
}
for (String col : source.getChosenColor()) {
if (!CardUtil.getColors(this).contains(col)) {
return false;
}
}
} else if (property.equals("AnyChosenColor")) {
if (source.getChosenColor().size() == 0) {
if ( source.getChosenColor().isEmpty() || !CardUtil.getColors(this).hasAnyColor(ColorSet.fromNames(source.getChosenColor()).getColor()) )
return false;
}
int matched = 0;
for (String col : source.getChosenColor()) {
if (CardUtil.getColors(this).contains(col)) {
matched++;
}
}
if (matched == 0) {
return false;
}
} else if (property.equals("DoubleFaced")) {
if (!this.isDoubleFaced()) {
return false;
@@ -5670,11 +5647,8 @@ public class Card extends GameEntity implements Comparable<Card> {
return false;
}
} else if (restriction.equals("MostProminentColor")) {
for (final String color : CardUtil.getColors(this)) {
if (CardFactoryUtil.isMostProminentColor(getGame().getCardsIn(ZoneType.Battlefield), color)) {
return true;
}
}
byte mask = CardFactoryUtil.getMostProminentColors(getGame().getCardsIn(ZoneType.Battlefield));
if( !CardUtil.getColors(this).hasAnyColor(mask))
return false;
} else {
for (final Card card : sourceController.getCardsIn(ZoneType.Battlefield)) {
@@ -5695,7 +5669,8 @@ public class Card extends GameEntity implements Comparable<Card> {
}
String color = props[1];
return CardFactoryUtil.isMostProminentColor(getGame().getCardsIn(ZoneType.Battlefield), color);
byte mostProm = CardFactoryUtil.getMostProminentColors(getGame().getCardsIn(ZoneType.Battlefield));
return ColorSet.fromMask(mostProm).hasAnyColor(MagicColor.fromName(color));
} else if (property.startsWith("notSharesColorWith")) {
if (property.equals("notSharesColorWith")) {
if (this.sharesColorWith(source)) {
@@ -6524,84 +6499,13 @@ public class Card extends GameEntity implements Comparable<Card> {
* part of the Card class, so calling out is not necessary
*/
/**
* <p>
* isColor.
* </p>
*
* @param col
* a {@link java.lang.String} object.
* @return a boolean.
*/
public final boolean isColor(final String col) {
return CardUtil.getColors(this).contains(col);
}
/**
* <p>
* isBlack.
* </p>
*
* @return a boolean.
*/
public final boolean isBlack() {
return CardUtil.getColors(this).contains(Constant.Color.BLACK);
}
/**
* <p>
* isBlue.
* </p>
*
* @return a boolean.
*/
public final boolean isBlue() {
return CardUtil.getColors(this).contains(Constant.Color.BLUE);
}
/**
* <p>
* isRed.
* </p>
*
* @return a boolean.
*/
public final boolean isRed() {
return CardUtil.getColors(this).contains(Constant.Color.RED);
}
/**
* <p>
* isGreen.
* </p>
*
* @return a boolean.
*/
public final boolean isGreen() {
return CardUtil.getColors(this).contains(Constant.Color.GREEN);
}
/**
* <p>
* isWhite.
* </p>
*
* @return a boolean.
*/
public final boolean isWhite() {
return CardUtil.getColors(this).contains(Constant.Color.WHITE);
}
/**
* <p>
* isColorless.
* </p>
*
* @return a boolean.
*/
public final boolean isColorless() {
return CardUtil.getColors(this).contains(Constant.Color.COLORLESS);
}
public final boolean isOfColor(final String col) { return CardUtil.getColors(this).hasAnyColor(MagicColor.fromName(col)); }
public final boolean isBlack() { return CardUtil.getColors(this).hasBlack(); }
public final boolean isBlue() { return CardUtil.getColors(this).hasBlue(); }
public final boolean isRed() { return CardUtil.getColors(this).hasRed(); }
public final boolean isGreen() { return CardUtil.getColors(this).hasGreen(); }
public final boolean isWhite() { return CardUtil.getColors(this).hasWhite(); }
public final boolean isColorless() { return CardUtil.getColors(this).isColorless(); }
/**
* <p>

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

@@ -22,6 +22,7 @@ import java.util.EnumSet;
import java.util.Iterator;
import java.util.List;
import forge.card.ColorSet;
import forge.card.mana.ManaCostBeingPaid;
/**
@@ -208,6 +209,14 @@ public class CardColor implements Iterable<Color> {
return list;
}
public final ColorSet toColorSet() {
int mask = 0;
for (final Color c : this.col) {
mask |= c.getMagicColor();
}
return ColorSet.fromMask(mask);
}
public final List<String> toStringList() {
final List<String> list = new ArrayList<String>(this.col.size());
for (final Color c : this.col) {

22
src/main/java/forge/CardLists.java
View File

@@ -144,28 +144,6 @@ public class CardLists {
} // sortAttack()
/**
* <p>
* getColor.
* </p>
*
* @param list
* a {@link forge.CardList} object.
* @param color
* a {@link java.lang.String} object.
* @return a {@link forge.CardList} object.
*/
public static List<Card> getColor(final List<Card> list, final String color) {
return CardLists.filter(list, new Predicate<Card>() {
@Override
public boolean apply(final Card c) {
return CardUtil.getColors(c).contains(color);
}
});
} // getColor()
/**
*
* Given a List<Card> c, return a List<Card> that contains a random amount of cards from c.

56
src/main/java/forge/CardPredicates.java
View File

@@ -154,6 +154,15 @@ public final class CardPredicates {
};
};
public static final Predicate<Card> isColor(final byte color) {
return new Predicate<Card>() {
@Override
public boolean apply(final Card c) {
return CardUtil.getColors(c).hasAnyColor(color);
}
};
} // getColor()
public static class Presets {
@@ -285,53 +294,6 @@ public final class CardPredicates {
}
};
/**
* a Predicate<Card> to get all cards that are black.
*/
public static final Predicate<Card> BLACK = new Predicate<Card>() {
@Override
public boolean apply(Card c) {
return c.isBlack();
}
};
/**
* a Predicate<Card> to get all cards that are blue.
*/
public static final Predicate<Card> BLUE = new Predicate<Card>() {
@Override
public boolean apply(Card c) {
return c.isBlue();
}
};
/**
* a Predicate<Card> to get all cards that are green.
*/
public static final Predicate<Card> GREEN = new Predicate<Card>() {
@Override
public boolean apply(Card c) {
return c.isGreen();
}
};
/**
* a Predicate<Card> to get all cards that are red.
*/
public static final Predicate<Card> RED = new Predicate<Card>() {
@Override
public boolean apply(Card c) {
return c.isRed();
}
};
/**
* a Predicate<Card> to get all cards that are white.
*/
public static final Predicate<Card> WHITE = new Predicate<Card>() {
@Override
public boolean apply(Card c) {
return c.isWhite();
}
};
public static final Predicate<Card> hasFirstStrike = new Predicate<Card>() {
@Override
public boolean apply(Card c) {

31
src/main/java/forge/CardUtil.java
View File

@@ -18,12 +18,11 @@
package forge;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import forge.card.CardCharacteristics;
import forge.card.ColorSet;
import forge.card.MagicColor;
import forge.card.ability.AbilityUtils;
import forge.card.ability.ApiType;
@@ -39,28 +38,8 @@ public final class CardUtil {
// disable instantiation
private CardUtil() { }
static final Map<String, String> colorMap;
static {
colorMap = new HashMap<String, String>();
colorMap.put(Constant.Color.BLACK.toString(), "B");
colorMap.put(Constant.Color.BLUE.toString(), "U");
colorMap.put(Constant.Color.GREEN.toString(), "G");
colorMap.put(Constant.Color.RED.toString(), "R");
colorMap.put(Constant.Color.WHITE.toString(), "W");
colorMap.put(Constant.Color.COLORLESS.toString(), "C");
}
// returns "G", longColor is Constant.Color.Green and the like
public static String getShortColor(final String longColor) {
String color = longColor.toLowerCase();
if (!colorMap.containsKey(color)) {
throw new RuntimeException("CardUtil : getShortColor() invalid argument - " + longColor);
}
return colorMap.get(color);
}
public static List<String> getColors(final Card c) {
return c.determineColor().toStringList();
public static ColorSet getColors(final Card c) {
return c.determineColor().toColorSet();
}
public static boolean isStackingKeyword(final String keyword) {
@@ -75,7 +54,7 @@ public final class CardUtil {
public static String getShortColorsString(final Iterable<String> colors) {
StringBuilder colorDesc = new StringBuilder();
for (final String col : colors) {
colorDesc.append(getShortColor(col) + " ");
colorDesc.append(MagicColor.toShortString(col) + " ");
}
return colorDesc.toString();
}
@@ -269,7 +248,7 @@ public final class CardUtil {
for (final Card card1 : cards) {
// For each card, go through all the colors and if the card is that color, add
for (final String col : Constant.Color.ONLY_COLORS) {
if (card1.isColor(col)) {
if (card1.isOfColor(col)) {
colors.add(col);
if (colors.size() == maxChoices) {
break;

36
src/main/java/forge/Color.java
View File

@@ -36,35 +36,25 @@ import forge.card.mana.ManaCostBeingPaid;
public enum Color {
/** The Colorless. */
Colorless(0),
Colorless((byte)0),
/** The White. */
White(1),
White(MagicColor.WHITE),
/** The Green. */
Green(2),
Green(MagicColor.GREEN),
/** The Red. */
Red(4),
Red(MagicColor.RED),
/** The Black. */
Black(8),
Black(MagicColor.BLACK),
/** The Blue. */
Blue(16);
Blue(MagicColor.BLUE);
private final byte magicColor;
private Color(final byte c) {
this.magicColor = c;
}
public static final ImmutableList<Color> WUBRG = ImmutableList.of( White, Blue, Black, Red, Green );
@SuppressWarnings("unused")
private int flag = 0;
/**
* <p>
* Constructor for Color.
* </p>
*
* @param c
* a int.
*/
Color(final int c) {
this.flag = c;
}
/**
* <p>
* Colorless.
@@ -77,6 +67,10 @@ public enum Color {
return colors;
}
public byte getMagicColor() {
return magicColor;
}
/**
* <p>
* ConvertStringsToColor.

53
src/main/java/forge/card/ColorSet.java
View File

@@ -74,6 +74,14 @@ public final class ColorSet implements Comparable<ColorSet> {
return fromMask(mask);
}
public static ColorSet fromNames(Iterable<String> colors) {
byte mask = 0;
for (String s : colors) {
mask |= MagicColor.fromName(s);
}
return fromMask(mask);
}
public static ColorSet fromManaCost(final ManaCost mana) {
return fromMask(mana.getColorProfile());
}
@@ -224,51 +232,6 @@ public final class ColorSet implements Comparable<ColorSet> {
return this.hasAnyColor(MagicColor.GREEN);
}
/**
* Checks if is white.
*
* @return true, if is white
*/
public boolean isWhite() {
return this.isEqual(MagicColor.WHITE);
}
/**
* Checks if is blue.
*
* @return true, if is blue
*/
public boolean isBlue() {
return this.isEqual(MagicColor.BLUE);
}
/**
* Checks if is black.
*
* @return true, if is black
*/
public boolean isBlack() {
return this.isEqual(MagicColor.BLACK);
}
/**
* Checks if is red.
*
* @return true, if is red
*/
public boolean isRed() {
return this.isEqual(MagicColor.RED);
}
/**
* Checks if is green.
*
* @return true, if is green
*/
public boolean isGreen() {
return this.isEqual(MagicColor.GREEN);
}
public ColorSet inverse() {
byte mask = this.myColor;
mask ^= (MagicColor.WHITE | MagicColor.BLUE | MagicColor.BLACK | MagicColor.GREEN | MagicColor.RED);

8
src/main/java/forge/card/ability/effects/ProtectAllEffect.java
View File

@@ -7,6 +7,8 @@ import forge.Card;
import forge.CardLists;
import forge.CardUtil;
import forge.Command;
import forge.card.ColorSet;
import forge.card.MagicColor;
import forge.card.ability.AbilityUtils;
import forge.card.ability.SpellAbilityEffect;
import forge.card.spellability.SpellAbility;
@@ -63,8 +65,10 @@ public class ProtectAllEffect extends SpellAbilityEffect {
}
} else if (sa.getParam("Gains").equals("TargetedCardColor")) {
for (final Card c : sa.getSATargetingCard().getTarget().getTargetCards()) {
for(final String color : CardUtil.getColors(c)) {
gains.add(color.toLowerCase());
ColorSet cs = CardUtil.getColors(c);
for(byte col : MagicColor.WUBRG) {
if (cs.hasAnyColor(col))
gains.add(MagicColor.toLongString(col).toLowerCase());
}
}
} else {

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

@@ -21,7 +21,6 @@ import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;
import org.apache.commons.lang.StringUtils;
@@ -41,6 +40,8 @@ import forge.Constant;
import forge.CounterType;
import forge.FThreads;
import forge.GameEntity;
import forge.card.ColorSet;
import forge.card.MagicColor;
import forge.card.ability.AbilityFactory;
import forge.card.ability.AbilityUtils;
import forge.card.ability.ApiType;
@@ -1427,7 +1428,7 @@ public class CardFactoryUtil {
return Aggregates.sum(filteredCards, CardPredicates.Accessors.fnGetCmc);
}
if (sq[0].contains("CardNumColors")) return doXMath(CardUtil.getColors(c).size(), m, c);
if (sq[0].contains("CardNumColors")) return doXMath(CardUtil.getColors(c).countColors(), m, c);
if (sq[0].contains("ChosenNumber")) return doXMath(c.getChosenNumber(), m, c);
if (sq[0].contains("CardCounters")) {
// CardCounters.ALL to be used for Kinsbaile Borderguard and anything that cares about all counters
@@ -1559,19 +1560,17 @@ public class CardFactoryUtil {
// Count$ColoredCreatures *a DOMAIN for creatures*
if (sq[0].contains("ColoredCreatures")) {
int n = 0;
int mask = 0;
List<Card> someCards = CardLists.filter(cc.getCardsIn(ZoneType.Battlefield), Presets.CREATURES);
for (final String color : Constant.Color.ONLY_COLORS) {
if (!CardLists.getColor(someCards, color).isEmpty()) {
n++;
for (final Card crd : someCards) {
mask |= CardUtil.getColors(crd).getColor();
}
}
return doXMath(n, m, c);
return doXMath(ColorSet.fromMask(mask).countColors(), m, c);
}
// Count$CardMulticolor.<numMC>.<numNotMC>
if (sq[0].contains("CardMulticolor")) {
final boolean isMulti = CardUtil.getColors(c).size() > 1;
final boolean isMulti = CardUtil.getColors(c).isMulticolor();
return doXMath(Integer.parseInt(sq[isMulti ? 1 : 2]), m, c);
}
@@ -1769,31 +1768,17 @@ public class CardFactoryUtil {
// someCards = someCards.filter(CardListFilter.WHITE);
// }
// "White Creatures" - Count$WhiteTypeYouCtrl.Creature
if (sq[0].contains("White")) {
someCards = CardLists.filter(someCards, Presets.WHITE);
}
if (sq[0].contains("Blue")) {
someCards = CardLists.filter(someCards, Presets.BLUE);
}
if (sq[0].contains("Black")) {
someCards = CardLists.filter(someCards, Presets.BLACK);
}
if (sq[0].contains("Red")) {
someCards = CardLists.filter(someCards, Presets.RED);
}
if (sq[0].contains("Green")) {
someCards = CardLists.filter(someCards, Presets.GREEN);
}
if (sq[0].contains("White")) someCards = CardLists.filter(someCards, CardPredicates.isColor(MagicColor.WHITE));
if (sq[0].contains("Blue")) someCards = CardLists.filter(someCards, CardPredicates.isColor(MagicColor.BLUE));
if (sq[0].contains("Black")) someCards = CardLists.filter(someCards, CardPredicates.isColor(MagicColor.BLACK));
if (sq[0].contains("Red")) someCards = CardLists.filter(someCards, CardPredicates.isColor(MagicColor.RED));
if (sq[0].contains("Green")) someCards = CardLists.filter(someCards, CardPredicates.isColor(MagicColor.GREEN));
if (sq[0].contains("Multicolor")) {
someCards = CardLists.filter(someCards, new Predicate<Card>() {
@Override
public boolean apply(final Card c) {
return CardUtil.getColors(c).size() > 1;
return CardUtil.getColors(c).isMulticolor();
}
});
}
@@ -1802,7 +1787,7 @@ public class CardFactoryUtil {
someCards = CardLists.filter(someCards, new Predicate<Card>() {
@Override
public boolean apply(final Card c) {
return (CardUtil.getColors(c).size() == 1);
return CardUtil.getColors(c).isMonoColor();
}
});
}
@@ -1929,36 +1914,30 @@ public class CardFactoryUtil {
* a {@link forge.CardList} object.
* @return a boolean.
*/
public static boolean isMostProminentColor(final List<Card> list, final String color) {
public static byte getMostProminentColors(final List<Card> list) {
int cntColors = MagicColor.WUBRG.length;
final Integer[] map = new Integer[cntColors];
final Map<String, Integer> map = new HashMap<String, Integer>();
for (final Card c : list) {
for (final String color2 : CardUtil.getColors(c)) {
if (color2.equals("colorless")) {
// nothing to do
} else if (!map.containsKey(color2)) {
map.put(color2, 1);
} else {
map.put(color2, map.get(color2) + 1);
}
for (final Card crd : list) {
ColorSet color = CardUtil.getColors(crd);
for(int i = 0; i < cntColors; i++) {
if( color.hasAnyColor(MagicColor.WUBRG[i]))
map[i]++;
}
} // for
if (map.isEmpty() || !map.containsKey(color)) {
return false;
byte mask = 0;
int nMax = -1;
for(int i = 0; i < cntColors; i++) {
if ( map[i] > nMax )
mask = MagicColor.WUBRG[i];
else if ( map[i] == nMax )
mask |= MagicColor.WUBRG[i];
else
continue;
nMax = map[i];
}
int num = map.get(color);
for (final Entry<String, Integer> entry : map.entrySet()) {
if (num < entry.getValue()) {
return false;
}
}
return true;
return mask;
}
/**

2
src/main/java/forge/deck/generate/GenerateColoredDeckBase.java
View File

@@ -236,7 +236,7 @@ public abstract class GenerateColoredDeckBase {
// start with all cards
// remove cards that generated decks don't like
Predicate<CardRules> canPlay = pt == PlayerType.HUMAN ? GenerateDeckUtil.HUMAN_CAN_PLAY : GenerateDeckUtil.AI_CAN_PLAY;
Predicate<CardRules> hasColor = new GenerateDeckUtil.CanBePaidWithColors(colors);
Predicate<CardRules> hasColor = new GenerateDeckUtil.MatchColorIdentity(colors);
if (!Singletons.getModel().getPreferences().getPrefBoolean(FPref.DECKGEN_ARTIFACTS)) {
hasColor = Predicates.or(hasColor, GenerateDeckUtil.COLORLESS_CARDS);

4
src/main/java/forge/deck/generate/GenerateDeckUtil.java
View File

@@ -62,10 +62,10 @@ public class GenerateDeckUtil {
}
};
public static class CanBePaidWithColors implements Predicate<CardRules> {
public static class MatchColorIdentity implements Predicate<CardRules> {
private final ColorSet allowedColor;
public CanBePaidWithColors(ColorSet color) {
public MatchColorIdentity(ColorSet color) {
allowedColor = color;
}

37
src/main/java/forge/game/ai/ComputerUtilCard.java
View File

@@ -9,7 +9,6 @@ import java.util.Map;
import java.util.Map.Entry;
import java.util.Random;
import com.esotericsoftware.minlog.Log;
import com.google.common.base.Function;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
@@ -18,9 +17,10 @@ import com.google.common.collect.Iterables;
import forge.Card;
import forge.CardLists;
import forge.CardPredicates;
import forge.CardUtil;
import forge.Constant;
import forge.card.CardType;
import forge.card.MagicColor;
import forge.card.cardfactory.CardFactoryUtil;
import forge.card.spellability.SpellAbility;
import forge.deck.CardPool;
import forge.deck.Deck;
@@ -814,35 +814,12 @@ public class ComputerUtilCard {
* @return a {@link java.lang.String} object.
*/
public static String getMostProminentColor(final List<Card> list) {
final Map<String, Integer> map = new HashMap<String, Integer>();
for (final Card c : list) {
for (final String color : CardUtil.getColors(c)) {
if (color.equals("colorless")) {
// nothing to do
} else if (!map.containsKey(color)) {
map.put(color, 1);
} else {
map.put(color, map.get(color) + 1);
byte colors = CardFactoryUtil.getMostProminentColors(list);
for(byte c : MagicColor.WUBRG) {
if ( (colors & c) != 0 )
return MagicColor.toLongString(c);
}
}
} // for
int max = 0;
String maxColor = "";
for (final Entry<String, Integer> entry : map.entrySet()) {
final String color = entry.getKey();
Log.debug(color + " - " + entry.getValue());
if (max < entry.getValue()) {
max = entry.getValue();
maxColor = color;
}
}
return maxColor;
return Constant.Color.WHITE; // no difference, there was no prominent color
}
public static List<String> getColorByProminence(final List<Card> list) {

6
src/main/java/forge/game/limited/LimitedDeckBuilder.java
View File

@@ -101,7 +101,7 @@ public class LimitedDeckBuilder {
*/
public Deck buildDeck() {
// 1. Prepare
hasColor = Predicates.or(new GenerateDeckUtil.CanBePaidWithColors(colors), GenerateDeckUtil.COLORLESS_CARDS);
hasColor = Predicates.or(new GenerateDeckUtil.MatchColorIdentity(colors), GenerateDeckUtil.COLORLESS_CARDS);
colorList = Iterables.filter(aiPlayables, Predicates.compose(hasColor, CardPrinted.FN_GET_RULES));
onColorCreatures = Iterables.filter(colorList,
Predicates.compose(CardRulesPredicates.Presets.IS_CREATURE, CardPrinted.FN_GET_RULES));
@@ -431,13 +431,13 @@ public class LimitedDeckBuilder {
for (Pair<Double, CardPrinted> bean : ranked) {
// Want a card that has just one "off" color.
ColorSet off = colors.getOffColors(bean.getValue().getRules().getColor());
if (off.isWhite() || off.isBlue() || off.isBlack() || off.isRed() || off.isGreen()) {
if (off.isMonoColor()) {
colors = ColorSet.fromMask(colors.getColor() | off.getColor());
break;
}
}
hasColor = Predicates.or(new GenerateDeckUtil.CanBePaidWithColors(colors),
hasColor = Predicates.or(new GenerateDeckUtil.MatchColorIdentity(colors),
GenerateDeckUtil.COLORLESS_CARDS);
Iterable<CardPrinted> threeColorList = Iterables.filter(aiPlayables,
Predicates.compose(hasColor, CardPrinted.FN_GET_RULES));

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

@@ -27,6 +27,7 @@ import org.apache.commons.lang3.StringUtils;
import com.esotericsoftware.minlog.Log;
import com.google.common.base.Predicate;
import com.google.common.collect.Iterables;
import forge.Card;
import forge.CardLists;
@@ -36,6 +37,7 @@ import forge.Constant;
import forge.GameEntity;
import forge.Singletons;
import forge.card.CardType;
import forge.card.MagicColor;
import forge.card.ability.ApiType;
import forge.card.cardfactory.CardFactoryUtil;
import forge.card.cost.Cost;
@@ -941,12 +943,10 @@ public class CombatUtil {
return false;
}
} else if (keyword.equals("CARDNAME can't attack unless defending player controls a blue permanent.")) {
temp = CardLists.getColor(list, Constant.Color.BLUE);
if (temp.isEmpty()) {
if (!Iterables.any(list, CardPredicates.isColor(MagicColor.BLUE)))
return false;
}
}
}
// The creature won't untap next turn
if (c.isTapped() && !Untap.canUntap(c)) {

9
src/main/java/forge/game/player/Player.java
View File

@@ -36,12 +36,12 @@ import forge.Card;
import forge.CardLists;
import forge.CardPredicates;
import forge.CardPredicates.Presets;
import forge.CardUtil;
import forge.Constant.Preferences;
import forge.CounterType;
import forge.FThreads;
import forge.GameEntity;
import forge.Singletons;
import forge.card.MagicColor;
import forge.card.ability.AbilityFactory;
import forge.card.ability.AbilityUtils;
import forge.card.cardfactory.CardFactoryUtil;
@@ -2800,12 +2800,7 @@ public abstract class Player extends GameEntity implements Comparable<Player> {
}
public List<Card> getColoredCardsInPlay(final String color) {
return CardLists.filter(getCardsIn(ZoneType.Battlefield), new Predicate<Card>() {
@Override
public boolean apply(final Card c) {
return CardUtil.getColors(c).contains(color);
}
});
return CardLists.filter(getCardsIn(ZoneType.Battlefield), CardPredicates.isColor(MagicColor.fromName(color)));
}
public int getCounterDoublersMagnitude(final CounterType type) {

18
src/main/java/forge/gui/GuiDisplayUtil.java
View File

@@ -42,11 +42,11 @@ import forge.CardCharacteristicName;
import forge.CardLists;
import forge.CardPredicates;
import forge.CardUtil;
import forge.Constant;
import forge.CounterType;
import forge.FThreads;
import forge.Singletons;
import forge.card.CardType;
import forge.card.ColorSet;
import forge.card.spellability.AbilityManaPart;
import forge.card.spellability.SpellAbility;
import forge.card.trigger.TriggerType;
@@ -71,23 +71,23 @@ public final class GuiDisplayUtil {
return BorderFactory.createEmptyBorder(2, 2, 2, 2);
}
java.awt.Color color;
final List<String> list = CardUtil.getColors(card);
final ColorSet list = CardUtil.getColors(card);
if (card.isFaceDown()) {
color = Color.gray;
} else if (list.size() > 1) {
} else if (list.isMulticolor()) {
color = Color.orange;
} else if (list.get(0).equals(Constant.Color.BLACK)) {
} else if (list.hasBlack()) {
color = Color.black;
} else if (list.get(0).equals(Constant.Color.GREEN)) {
} else if (list.hasGreen()) {
color = new Color(0, 220, 39);
} else if (list.get(0).equals(Constant.Color.WHITE)) {
} else if (list.hasWhite()) {
color = Color.white;
} else if (list.get(0).equals(Constant.Color.RED)) {
} else if (list.hasRed()) {
color = Color.red;
} else if (list.get(0).equals(Constant.Color.BLUE)) {
} else if (list.hasBlue()) {
color = Color.blue;
} else if (list.get(0).equals(Constant.Color.COLORLESS)) {
} else if (list.isColorless()) {
color = Color.gray;
} else {
color = new Color(200, 0, 230); // If your card has a violet border,

2
src/main/java/forge/gui/match/views/VStack.java
View File

@@ -205,7 +205,7 @@ public enum VStack implements IVDoc<CStack> {
private Color[] getSpellColor(SpellAbilityStackInstance s0) {
if (s0.getStackDescription().startsWith("Morph "))
return new Color[] { new Color(0, 0, 0, 0), FSkin.getColor(FSkin.Colors.CLR_TEXT) };
if (CardUtil.getColors(s0.getSourceCard()).size() > 1)
if (CardUtil.getColors(s0.getSourceCard()).isMulticolor())
return new Color[] { new Color(253, 175, 63), Color.black };
if (s0.getSourceCard().isBlack()) return new Color[] { Color.black, Color.white };