2013-04-12 19:32:25 -07:00
|
|
|
package magic.model;
|
|
|
|
|
|
|
|
import magic.ai.ArtificialScoringSystem;
|
2013-10-17 01:27:46 -07:00
|
|
|
import magic.data.CardDefinitions;
|
2014-04-18 06:58:52 -07:00
|
|
|
import magic.data.CardProperty;
|
2013-04-12 19:32:25 -07:00
|
|
|
import magic.model.event.MagicActivation;
|
|
|
|
import magic.model.event.MagicActivationHints;
|
|
|
|
import magic.model.event.MagicCardActivation;
|
|
|
|
import magic.model.event.MagicCardEvent;
|
2014-04-18 06:58:52 -07:00
|
|
|
import magic.model.event.MagicEvent;
|
|
|
|
import magic.model.event.MagicEventSource;
|
2013-04-12 19:32:25 -07:00
|
|
|
import magic.model.event.MagicManaActivation;
|
2014-04-18 06:58:52 -07:00
|
|
|
import magic.model.event.MagicPayManaCostEvent;
|
2013-04-12 19:32:25 -07:00
|
|
|
import magic.model.event.MagicPermanentActivation;
|
|
|
|
import magic.model.event.MagicPlayCardEvent;
|
|
|
|
import magic.model.event.MagicTiming;
|
|
|
|
import magic.model.mstatic.MagicCDA;
|
|
|
|
import magic.model.mstatic.MagicStatic;
|
|
|
|
import magic.model.trigger.MagicTrigger;
|
|
|
|
import magic.model.trigger.MagicWhenComesIntoPlayTrigger;
|
|
|
|
import magic.model.trigger.MagicWhenDrawnTrigger;
|
2014-04-18 06:58:52 -07:00
|
|
|
import magic.model.trigger.MagicWhenPutIntoGraveyardTrigger;
|
|
|
|
import magic.model.trigger.MagicWhenSpellIsCastTrigger;
|
2014-08-25 06:13:33 -07:00
|
|
|
import magic.model.trigger.MagicWhenCycleTrigger;
|
2015-03-10 06:44:17 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
import java.util.ArrayList;
|
2014-04-18 06:58:52 -07:00
|
|
|
import java.util.Collection;
|
2013-04-12 19:32:25 -07:00
|
|
|
import java.util.Comparator;
|
|
|
|
import java.util.EnumSet;
|
2014-04-18 06:58:52 -07:00
|
|
|
import java.util.LinkedList;
|
|
|
|
import java.util.List;
|
|
|
|
import java.util.Set;
|
2015-03-10 06:44:17 -07:00
|
|
|
import java.util.Date;
|
2013-04-12 19:32:25 -07:00
|
|
|
|
2013-08-29 07:24:58 -07:00
|
|
|
public class MagicCardDefinition implements MagicAbilityStore {
|
2013-04-12 19:32:25 -07:00
|
|
|
|
|
|
|
public static final MagicCardDefinition UNKNOWN = new MagicCardDefinition() {
|
|
|
|
//definition for unknown cards
|
|
|
|
@Override
|
|
|
|
protected void initialize() {
|
|
|
|
setName("Unknown");
|
2015-05-09 07:01:39 -07:00
|
|
|
setDistinctName("Unknown");
|
2013-04-12 19:32:25 -07:00
|
|
|
setToken();
|
|
|
|
setValue(1);
|
|
|
|
addType(MagicType.Creature);
|
|
|
|
setCost(MagicManaCost.create("{15}"));
|
|
|
|
setPowerToughness(1,1);
|
|
|
|
addAbility(MagicAbility.Defender);
|
|
|
|
addAbility(MagicAbility.CannotBeCountered);
|
|
|
|
addAbility(MagicAbility.Shroud);
|
|
|
|
setTiming(MagicTiming.Main);
|
2014-08-03 05:26:20 -07:00
|
|
|
setIndex(1000000);
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-08-03 05:11:17 -07:00
|
|
|
public static final MagicCardDefinition MORPH = new MagicCardDefinition() {
|
2014-07-31 19:47:14 -07:00
|
|
|
//definition for face down cards
|
2014-07-31 09:32:22 -07:00
|
|
|
@Override
|
|
|
|
protected void initialize() {
|
|
|
|
setName("");
|
2015-05-09 07:01:39 -07:00
|
|
|
setDistinctName("2/2 face-down creature");
|
2014-07-31 09:32:22 -07:00
|
|
|
setValue(1);
|
|
|
|
addType(MagicType.Creature);
|
|
|
|
setCost(MagicManaCost.create("{0}"));
|
|
|
|
setPowerToughness(2, 2);
|
|
|
|
setTiming(MagicTiming.Main);
|
2014-08-03 05:26:20 -07:00
|
|
|
setIndex(1000001);
|
2014-07-31 09:32:22 -07:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
// name displayed in UI, may be repeated in tokens
|
|
|
|
private String name;
|
|
|
|
|
|
|
|
// name used for mapping and persistence, must be unique
|
2015-05-09 07:01:39 -07:00
|
|
|
private String distinctName;
|
2014-06-02 12:36:18 -07:00
|
|
|
private boolean isValid = true;
|
2014-06-02 12:45:36 -07:00
|
|
|
private boolean isScriptFileMissing = false;
|
2013-04-12 19:32:25 -07:00
|
|
|
|
|
|
|
private String imageURL;
|
|
|
|
private String cardInfoUrl = "";
|
|
|
|
private int imageCount = 1;
|
2015-03-10 06:44:17 -07:00
|
|
|
private Date imageUpdated;
|
2013-04-12 19:32:25 -07:00
|
|
|
private int index=-1;
|
|
|
|
private double value;
|
2014-06-11 10:57:38 -07:00
|
|
|
private int gathererRating;
|
2013-04-12 19:32:25 -07:00
|
|
|
private int removal;
|
|
|
|
private int score=-1; // not initialized
|
|
|
|
private MagicRarity rarity;
|
2014-08-18 18:31:15 -07:00
|
|
|
private boolean token = false;
|
|
|
|
private boolean hidden = false;
|
2013-04-12 19:32:25 -07:00
|
|
|
private int typeFlags;
|
|
|
|
private EnumSet<MagicSubType> subTypeFlags = EnumSet.noneOf(MagicSubType.class);
|
|
|
|
private EnumSet<MagicAbility> abilityFlags = EnumSet.noneOf(MagicAbility.class);
|
2013-06-23 06:19:01 -07:00
|
|
|
private int colorFlags = -1;
|
2013-04-12 19:32:25 -07:00
|
|
|
private MagicManaCost cost=MagicManaCost.ZERO;
|
|
|
|
private String manaSourceText="";
|
|
|
|
private final int[] manaSource=new int[MagicColor.NR_COLORS];
|
|
|
|
private int power;
|
|
|
|
private int toughness;
|
|
|
|
private String text = "";
|
|
|
|
private MagicStaticType staticType=MagicStaticType.None;
|
|
|
|
private MagicTiming timing=MagicTiming.None;
|
|
|
|
private MagicCardEvent cardEvent=MagicPlayCardEvent.create();
|
2013-07-07 06:16:11 -07:00
|
|
|
private final Collection<MagicActivation<MagicPermanent>> permActivations=new ArrayList<MagicActivation<MagicPermanent>>();
|
2014-07-31 20:55:26 -07:00
|
|
|
private final Collection<MagicActivation<MagicPermanent>> morphActivations=new ArrayList<MagicActivation<MagicPermanent>>();
|
2013-07-07 06:16:11 -07:00
|
|
|
private final LinkedList<MagicActivation<MagicCard>> cardActivations = new LinkedList<MagicActivation<MagicCard>>();
|
2014-04-17 05:10:06 -07:00
|
|
|
private final LinkedList<MagicActivation<MagicCard>> graveyardActivations = new LinkedList<MagicActivation<MagicCard>>();
|
2013-04-12 19:32:25 -07:00
|
|
|
private final Collection<MagicCDA> CDAs = new ArrayList<MagicCDA>();
|
|
|
|
private final Collection<MagicTrigger<?>> triggers = new ArrayList<MagicTrigger<?>>();
|
|
|
|
private final Collection<MagicStatic> statics=new ArrayList<MagicStatic>();
|
|
|
|
private final LinkedList<MagicWhenComesIntoPlayTrigger> comeIntoPlayTriggers = new LinkedList<MagicWhenComesIntoPlayTrigger>();
|
|
|
|
private final Collection<MagicWhenSpellIsCastTrigger> spellIsCastTriggers = new ArrayList<MagicWhenSpellIsCastTrigger>();
|
2014-08-25 06:13:33 -07:00
|
|
|
private final Collection<MagicWhenCycleTrigger> cycleTriggers = new ArrayList<MagicWhenCycleTrigger>();
|
2013-04-12 19:32:25 -07:00
|
|
|
private final Collection<MagicWhenDrawnTrigger> drawnTriggers = new ArrayList<MagicWhenDrawnTrigger>();
|
|
|
|
private final Collection<MagicWhenPutIntoGraveyardTrigger> putIntoGraveyardTriggers = new ArrayList<MagicWhenPutIntoGraveyardTrigger>();
|
|
|
|
private final Collection<MagicManaActivation> manaActivations=new ArrayList<MagicManaActivation>();
|
2013-06-15 20:16:56 -07:00
|
|
|
private final Collection<MagicEventSource> costEventSources=new ArrayList<MagicEventSource>();
|
2013-04-12 19:32:25 -07:00
|
|
|
private boolean excludeManaOrCombat;
|
2014-08-06 08:29:43 -07:00
|
|
|
private MagicCardDefinition flipCardDefinition;
|
|
|
|
private MagicCardDefinition transformCardDefinition;
|
2013-04-12 19:32:25 -07:00
|
|
|
|
2013-10-21 23:39:48 -07:00
|
|
|
private String abilityProperty;
|
2013-04-12 19:32:25 -07:00
|
|
|
private String requiresGroovy;
|
2014-08-15 01:18:54 -07:00
|
|
|
private String effectProperty;
|
2014-08-17 13:54:38 -07:00
|
|
|
private String flipCardName;
|
2014-08-17 13:31:48 -07:00
|
|
|
private String transformCardName;
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2014-05-01 00:16:14 -07:00
|
|
|
private boolean isMissing = false;
|
|
|
|
|
2014-03-24 09:20:56 -07:00
|
|
|
private Set<MagicType> cardType = EnumSet.noneOf(MagicType.class);
|
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public MagicCardDefinition() {
|
2013-06-23 18:33:35 -07:00
|
|
|
initialize();
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
2014-07-27 22:05:25 -07:00
|
|
|
|
|
|
|
public static MagicCardDefinition create(final MagicCardDefinitionInit init) {
|
|
|
|
final MagicCardDefinition cdef = new MagicCardDefinition();
|
|
|
|
init.initialize(cdef);
|
2015-04-19 20:23:13 -07:00
|
|
|
cdef.validate();
|
2014-07-27 22:05:25 -07:00
|
|
|
return cdef;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
protected void initialize() {}
|
|
|
|
|
2013-10-21 23:39:48 -07:00
|
|
|
public void setAbilityProperty(final String value) {
|
|
|
|
abilityProperty = value;
|
|
|
|
}
|
2013-04-12 19:32:25 -07:00
|
|
|
|
|
|
|
public void setRequiresGroovy(final String value) {
|
|
|
|
requiresGroovy = value;
|
|
|
|
}
|
2014-08-05 11:43:05 -07:00
|
|
|
|
2014-08-15 01:18:54 -07:00
|
|
|
public void setEffectProperty(final String value) {
|
|
|
|
effectProperty = value;
|
|
|
|
}
|
|
|
|
|
2014-08-17 13:54:38 -07:00
|
|
|
public void setFlipCardName(final String value) {
|
|
|
|
flipCardName = value;
|
2014-08-05 11:43:05 -07:00
|
|
|
}
|
2014-08-05 14:26:47 -07:00
|
|
|
|
2014-08-17 13:31:48 -07:00
|
|
|
public void setTransformCardName(final String value) {
|
|
|
|
transformCardName = value;
|
2014-08-06 08:29:43 -07:00
|
|
|
}
|
|
|
|
|
2014-08-05 14:26:47 -07:00
|
|
|
public void setHidden() {
|
|
|
|
hidden = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
public boolean isHidden() {
|
|
|
|
return hidden;
|
|
|
|
}
|
2013-04-12 19:32:25 -07:00
|
|
|
|
2013-10-21 23:42:39 -07:00
|
|
|
public void loadAbilities() {
|
2013-04-12 19:32:25 -07:00
|
|
|
if (requiresGroovy != null) {
|
|
|
|
CardProperty.LOAD_GROOVY_CODE.setProperty(this, requiresGroovy);
|
|
|
|
requiresGroovy = null;
|
|
|
|
}
|
2013-10-21 23:39:48 -07:00
|
|
|
if (abilityProperty != null) {
|
|
|
|
CardProperty.LOAD_ABILITY.setProperty(this, abilityProperty);
|
|
|
|
abilityProperty = null;
|
|
|
|
}
|
2014-08-15 01:18:54 -07:00
|
|
|
if (effectProperty != null) {
|
|
|
|
CardProperty.LOAD_EFFECT.setProperty(this, effectProperty);
|
|
|
|
effectProperty = null;
|
|
|
|
}
|
2014-08-17 13:52:38 -07:00
|
|
|
if (getFlippedDefinition().isHidden()) {
|
2014-08-09 22:22:47 -07:00
|
|
|
flipCardDefinition.loadAbilities();
|
2014-08-05 20:51:09 -07:00
|
|
|
}
|
2014-08-17 13:33:49 -07:00
|
|
|
if (getTransformedDefinition().isHidden()) {
|
2014-08-09 22:22:47 -07:00
|
|
|
transformCardDefinition.loadAbilities();
|
2014-08-06 08:29:43 -07:00
|
|
|
}
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean isValid() {
|
2014-06-02 12:36:18 -07:00
|
|
|
return isValid;
|
|
|
|
}
|
|
|
|
public void setIsValid(boolean b) {
|
|
|
|
this.isValid = b;
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
|
|
|
|
2015-03-10 06:44:17 -07:00
|
|
|
public void setImageUpdated(final Date d) {
|
|
|
|
imageUpdated = d;
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
|
|
|
|
2015-03-14 13:47:49 -07:00
|
|
|
public boolean isImageUpdatedAfter(final Date d) {
|
2015-03-10 06:44:17 -07:00
|
|
|
return imageUpdated != null && imageUpdated.after(d);
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2015-05-09 07:48:03 -07:00
|
|
|
/**
|
|
|
|
* Returns the name of the card exactly as it appears on the printed card.
|
|
|
|
* <p>
|
|
|
|
* Note that in the case of token cards this means it may return the
|
|
|
|
* same name (eg. five different Wurm tokens would all return "Wurm").
|
|
|
|
*
|
|
|
|
* @see getDistinctName()
|
|
|
|
*/
|
2013-04-12 19:32:25 -07:00
|
|
|
public String getName() {
|
|
|
|
return name;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void setName(final String name) {
|
|
|
|
this.name = name;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2015-05-09 07:48:03 -07:00
|
|
|
/**
|
|
|
|
* Returns a guaranteed distinct card name.
|
|
|
|
* <p>
|
|
|
|
* In most cases this will be the same as {@link getName()} but for tokens
|
|
|
|
* of the same type (eg. Wurm) this will return a name that clearly identifies
|
|
|
|
* the card (eg. 5/5 green Wurm creature token with trample).
|
|
|
|
*
|
|
|
|
*/
|
2015-05-09 07:01:39 -07:00
|
|
|
public String getDistinctName() {
|
|
|
|
return distinctName;
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
|
|
|
|
2015-05-09 07:01:39 -07:00
|
|
|
public void setDistinctName(final String name) {
|
|
|
|
distinctName = name;
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2015-05-08 22:15:01 -07:00
|
|
|
/**
|
|
|
|
* Returns the name of the card containing only ASCII characters.
|
|
|
|
*/
|
|
|
|
public String getAsciiName() {
|
2015-05-09 07:01:39 -07:00
|
|
|
return CardDefinitions.getASCII(distinctName);
|
2015-05-08 22:15:01 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the name of the script/groovy file without extension
|
|
|
|
*/
|
|
|
|
public String getFilename() {
|
2015-05-09 07:01:39 -07:00
|
|
|
return CardDefinitions.getCanonicalName(distinctName);
|
2015-05-08 22:15:01 -07:00
|
|
|
}
|
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void setIndex(final int index) {
|
|
|
|
this.index=index;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public int getIndex() {
|
|
|
|
return index;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public String getImageName() {
|
2014-07-31 19:47:14 -07:00
|
|
|
return token ?
|
2015-05-09 07:01:39 -07:00
|
|
|
CardDefinitions.getCanonicalName(distinctName):
|
|
|
|
distinctName.replaceAll("[<>:\"/\\\\|?*\\x00-\\x1F]", "_");
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
public void setImageCount(final int count) {
|
|
|
|
this.imageCount = count;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public int getImageCount() {
|
|
|
|
return imageCount;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void setImageURL(final String imageURL) {
|
|
|
|
this.imageURL = imageURL;
|
|
|
|
}
|
2014-07-31 09:32:22 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public String getImageURL() {
|
|
|
|
return imageURL;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void setCardInfoURL(final String url) {
|
|
|
|
this.cardInfoUrl = url;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public String getCardInfoURL() {
|
|
|
|
return this.cardInfoUrl;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public String getCardTextName() {
|
|
|
|
return getImageName();
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void setValue(final double value) {
|
|
|
|
this.value = value;
|
2014-06-11 10:57:38 -07:00
|
|
|
this.gathererRating = (int)(value * 1000);
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
public double getValue() {
|
|
|
|
return value;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2014-06-11 10:57:38 -07:00
|
|
|
/**
|
|
|
|
* Returns the "value" * 1000 which is used to sort cards in the card explorer.
|
|
|
|
* <p>
|
|
|
|
* The "value" property actually represents the members rating from the Gatherer
|
|
|
|
* website but as a double value it cannot be used with a comparator.
|
|
|
|
*/
|
|
|
|
public int getGathererRating() {
|
|
|
|
return gathererRating;
|
|
|
|
}
|
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void setRemoval(final int removal) {
|
|
|
|
this.removal=removal;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public int getRemoval() {
|
|
|
|
return removal;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public int getScore() {
|
|
|
|
if (score<0) {
|
|
|
|
score=ArtificialScoringSystem.getCardDefinitionScore(this);
|
|
|
|
}
|
|
|
|
return score;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public int getFreeScore() {
|
|
|
|
if (score<0) {
|
|
|
|
score=ArtificialScoringSystem.getFreeCardDefinitionScore(this);
|
|
|
|
}
|
|
|
|
return score;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void setRarity(final char c) {
|
|
|
|
this.rarity = MagicRarity.getRarity(c);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean isRarity(final MagicRarity r) {
|
|
|
|
return this.rarity == r;
|
|
|
|
}
|
|
|
|
|
|
|
|
public int getRarity() {
|
|
|
|
return rarity.ordinal();
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public String getRarityString() {
|
2015-04-22 22:23:36 -07:00
|
|
|
return (rarity == null ? "" : rarity.getName());
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void setToken() {
|
|
|
|
token=true;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean isToken() {
|
|
|
|
return token;
|
|
|
|
}
|
2014-07-31 09:32:22 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
int getTypeFlags() {
|
|
|
|
return typeFlags;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void addType(final MagicType type) {
|
2013-06-23 19:31:32 -07:00
|
|
|
typeFlags |= type.getMask();
|
|
|
|
if (type == MagicType.Land) {
|
|
|
|
if (colorFlags == -1) {
|
|
|
|
// Lands default to colorless
|
|
|
|
colorFlags = 0;
|
|
|
|
} else {
|
2014-05-01 00:16:14 -07:00
|
|
|
assert colorFlags != 0 : "redundant color declaration: " + colorFlags;
|
2013-06-23 19:31:32 -07:00
|
|
|
}
|
|
|
|
}
|
2014-03-24 09:20:56 -07:00
|
|
|
cardType.add(type);
|
|
|
|
}
|
|
|
|
|
|
|
|
public Set<MagicType> getCardType() {
|
|
|
|
return cardType;
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean hasType(final MagicType type) {
|
|
|
|
return (typeFlags&type.getMask())!=0;
|
|
|
|
}
|
2014-08-05 11:43:05 -07:00
|
|
|
|
|
|
|
public MagicCardDefinition getFlippedDefinition() {
|
2014-08-17 13:52:38 -07:00
|
|
|
if (flipCardDefinition == null) {
|
|
|
|
flipCardDefinition = isFlipCard() ?
|
2014-08-17 13:54:38 -07:00
|
|
|
CardDefinitions.getCard(flipCardName) :
|
2014-08-17 13:52:38 -07:00
|
|
|
MagicCardDefinition.UNKNOWN;
|
|
|
|
}
|
2014-08-05 18:48:53 -07:00
|
|
|
return flipCardDefinition;
|
2014-08-05 11:43:05 -07:00
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2014-08-06 08:29:43 -07:00
|
|
|
public MagicCardDefinition getTransformedDefinition() {
|
2014-08-17 13:33:49 -07:00
|
|
|
if (transformCardDefinition == null) {
|
|
|
|
transformCardDefinition = isDoubleFaced() ?
|
|
|
|
CardDefinitions.getCard(transformCardName) :
|
|
|
|
MagicCardDefinition.UNKNOWN;
|
|
|
|
}
|
2014-08-06 08:29:43 -07:00
|
|
|
return transformCardDefinition;
|
|
|
|
}
|
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean isBasic() {
|
|
|
|
return hasType(MagicType.Basic);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean isLand() {
|
|
|
|
return hasType(MagicType.Land);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean isCreature() {
|
|
|
|
return hasType(MagicType.Creature);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean isArtifact() {
|
|
|
|
return hasType(MagicType.Artifact);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean isEquipment() {
|
2014-04-13 08:06:07 -07:00
|
|
|
return hasSubType(MagicSubType.Equipment);
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean isPlaneswalker() {
|
|
|
|
return hasType(MagicType.Planeswalker);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean isEnchantment() {
|
|
|
|
return hasType(MagicType.Enchantment);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean isLegendary() {
|
|
|
|
return hasType(MagicType.Legendary);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean isTribal() {
|
|
|
|
return hasType(MagicType.Tribal);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean isAura() {
|
|
|
|
return isEnchantment() && hasSubType(MagicSubType.Aura);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean isInstant() {
|
|
|
|
return hasType(MagicType.Instant);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean isSorcery() {
|
|
|
|
return hasType(MagicType.Sorcery);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean isSpell() {
|
|
|
|
return isInstant()||isSorcery();
|
|
|
|
}
|
2014-05-01 00:16:14 -07:00
|
|
|
|
2014-04-05 23:11:37 -07:00
|
|
|
public boolean isPermanent() {
|
|
|
|
return isSpell() == false;
|
|
|
|
}
|
2014-08-05 11:43:05 -07:00
|
|
|
|
|
|
|
public boolean isFlipCard() {
|
2014-08-17 13:54:38 -07:00
|
|
|
return flipCardName != null;
|
2014-08-05 11:43:05 -07:00
|
|
|
}
|
2014-08-06 08:29:43 -07:00
|
|
|
|
|
|
|
public boolean isDoubleFaced() {
|
2014-08-17 13:31:48 -07:00
|
|
|
return transformCardName != null;
|
2014-08-06 08:29:43 -07:00
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2014-09-10 01:58:35 -07:00
|
|
|
public boolean hasMultipleAspects() {
|
|
|
|
return isFlipCard() || isDoubleFaced();
|
|
|
|
}
|
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public String getLongTypeString() {
|
|
|
|
if (isBasic()) {
|
|
|
|
return "Basic " + getTypeString();
|
|
|
|
}
|
|
|
|
if (isLegendary()) {
|
|
|
|
return "Legendary " + getTypeString();
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
if (isTribal()) {
|
|
|
|
return "Tribal " + getTypeString();
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
return getTypeString();
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public String getTypeString() {
|
|
|
|
final StringBuilder sb = new StringBuilder();
|
|
|
|
if (isLand()) {
|
|
|
|
sb.append(MagicType.Land.toString());
|
2013-06-23 18:33:35 -07:00
|
|
|
}
|
2013-04-12 19:32:25 -07:00
|
|
|
if (isArtifact()) {
|
|
|
|
if (sb.length() > 0) {
|
|
|
|
sb.append(" ");
|
|
|
|
}
|
|
|
|
sb.append(MagicType.Artifact.toString());
|
2013-06-23 18:33:35 -07:00
|
|
|
}
|
2013-04-12 19:32:25 -07:00
|
|
|
if (isCreature()) {
|
|
|
|
if (sb.length() > 0) {
|
|
|
|
sb.append(" ");
|
|
|
|
}
|
|
|
|
sb.append(MagicType.Creature.toString());
|
2013-06-23 18:33:35 -07:00
|
|
|
}
|
2013-04-12 19:32:25 -07:00
|
|
|
if (isEnchantment()) {
|
|
|
|
if (sb.length() > 0) {
|
|
|
|
sb.append(" ");
|
|
|
|
}
|
|
|
|
sb.append(MagicType.Enchantment.toString());
|
2013-06-23 18:33:35 -07:00
|
|
|
}
|
2013-04-12 19:32:25 -07:00
|
|
|
if (isInstant()) {
|
|
|
|
if (sb.length() > 0) {
|
|
|
|
sb.append(" ");
|
|
|
|
}
|
|
|
|
sb.append(MagicType.Instant.toString());
|
2013-06-23 18:33:35 -07:00
|
|
|
}
|
2013-04-12 19:32:25 -07:00
|
|
|
if (isSorcery()) {
|
|
|
|
if (sb.length() > 0) {
|
|
|
|
sb.append(" ");
|
|
|
|
}
|
|
|
|
sb.append(MagicType.Sorcery.toString());
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
|
|
|
return sb.toString();
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
public boolean usesStack() {
|
|
|
|
return !isLand();
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void setSubTypes(final String[] subTypeNames) {
|
|
|
|
subTypeFlags = MagicSubType.getSubTypes(subTypeNames);
|
|
|
|
}
|
|
|
|
|
2014-07-27 22:05:25 -07:00
|
|
|
public void addSubType(final MagicSubType subType) {
|
|
|
|
subTypeFlags.add(subType);
|
|
|
|
}
|
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
EnumSet<MagicSubType> genSubTypeFlags() {
|
|
|
|
return subTypeFlags.clone();
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-10-24 01:13:34 -07:00
|
|
|
public EnumSet<MagicSubType> getSubTypeFlags() {
|
2013-04-12 19:32:25 -07:00
|
|
|
final EnumSet<MagicSubType> subTypes = genSubTypeFlags();
|
|
|
|
applyCDASubType(null, null, subTypes);
|
|
|
|
return subTypes;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-10-13 03:27:37 -07:00
|
|
|
public void applyCDASubType(final MagicGame game, final MagicPlayer player, final Set<MagicSubType> flags) {
|
2013-04-12 19:32:25 -07:00
|
|
|
for (final MagicCDA lv : CDAs) {
|
|
|
|
lv.getSubTypeFlags(game, player, flags);
|
|
|
|
}
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public String getSubTypeString() {
|
|
|
|
final String brackets = getSubTypeFlags().toString(); // [...,...]
|
|
|
|
if (brackets.length() <= 2) {
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
return brackets.substring(1, brackets.length() - 1);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean hasSubType(final MagicSubType subType) {
|
|
|
|
return getSubTypeFlags().contains(subType);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void setColors(final String colors) {
|
2013-06-23 19:31:32 -07:00
|
|
|
colorFlags = MagicColor.getFlags(colors);
|
2014-08-11 22:25:37 -07:00
|
|
|
assert cost == MagicManaCost.ZERO || colorFlags != cost.getColorFlags() : "redundant color declaration: " + colorFlags;
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean hasColor(final MagicColor color) {
|
2015-04-22 22:23:36 -07:00
|
|
|
return (colorFlags&color.getMask())!=0;
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
public boolean isColorless() {
|
|
|
|
return colorFlags == 0;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public int getColorFlags() {
|
|
|
|
return colorFlags;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public int getConvertedCost() {
|
|
|
|
return cost.getConvertedCost();
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean hasConvertedCost(final int c) {
|
|
|
|
return getConvertedCost() == c;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public int getCostBucket() {
|
|
|
|
switch (getConvertedCost()) {
|
|
|
|
case 0:
|
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
return 0;
|
|
|
|
case 3:
|
|
|
|
case 4:
|
|
|
|
return 1;
|
2013-06-23 18:33:35 -07:00
|
|
|
default:
|
2013-04-12 19:32:25 -07:00
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean hasX() {
|
|
|
|
return cost.hasX();
|
|
|
|
}
|
|
|
|
|
|
|
|
public void setCost(final MagicManaCost aCost) {
|
|
|
|
cost = aCost;
|
2013-06-23 06:19:01 -07:00
|
|
|
if (colorFlags == -1) {
|
2013-06-23 19:31:32 -07:00
|
|
|
// color defaults to follow mana cost
|
2013-06-23 06:19:01 -07:00
|
|
|
colorFlags = cost.getColorFlags();
|
2013-06-23 19:31:32 -07:00
|
|
|
} else {
|
2014-05-01 00:16:14 -07:00
|
|
|
assert colorFlags != cost.getColorFlags() : "redundant color declaration: " + colorFlags;
|
2013-06-23 06:19:01 -07:00
|
|
|
}
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
|
|
|
|
2013-06-23 18:33:35 -07:00
|
|
|
public void validate() {
|
|
|
|
//every card should have a timing hint
|
2013-04-12 19:32:25 -07:00
|
|
|
if (!isToken() && getTiming() == MagicTiming.None) {
|
|
|
|
throw new RuntimeException(
|
|
|
|
getName() + " does not have a timing hint"
|
|
|
|
);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-06-23 06:34:53 -07:00
|
|
|
//check colorFlags is set
|
|
|
|
if (colorFlags == -1) {
|
|
|
|
throw new RuntimeException(name + "'s color is not set");
|
|
|
|
}
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
public MagicManaCost getCost() {
|
|
|
|
return cost;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-08-30 21:00:50 -07:00
|
|
|
public Iterable<? extends MagicEvent> getCostEvent(final MagicCard source) {
|
2013-06-15 20:16:56 -07:00
|
|
|
final List<MagicEvent> costEvent = new ArrayList<MagicEvent>();
|
2013-04-12 19:32:25 -07:00
|
|
|
if (cost != MagicManaCost.ZERO) {
|
|
|
|
costEvent.add(new MagicPayManaCostEvent(
|
|
|
|
source,
|
|
|
|
cost
|
|
|
|
));
|
|
|
|
}
|
2013-06-15 20:16:56 -07:00
|
|
|
for (final MagicEventSource eventSource : costEventSources) {
|
|
|
|
costEvent.add(eventSource.getEvent(source));
|
|
|
|
}
|
2013-08-30 21:00:50 -07:00
|
|
|
return costEvent;
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2014-03-13 03:24:17 -07:00
|
|
|
public boolean isPlayable(final MagicDeckProfile profile) {
|
2013-04-12 19:32:25 -07:00
|
|
|
if (isLand()) {
|
|
|
|
int source = 0;
|
|
|
|
for (final MagicColor color : profile.getColors()) {
|
|
|
|
source += getManaSource(color);
|
|
|
|
}
|
|
|
|
return source > 4;
|
|
|
|
} else {
|
|
|
|
return cost.getCostScore(profile) > 0;
|
|
|
|
}
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void setManaSourceText(final String sourceText) {
|
|
|
|
manaSourceText=sourceText;
|
|
|
|
for (int index=0;index<sourceText.length();index+=2) {
|
|
|
|
final char symbol=sourceText.charAt(index);
|
|
|
|
final int source=sourceText.charAt(index+1)-'0';
|
|
|
|
final MagicColor color=MagicColor.getColor(symbol);
|
|
|
|
manaSource[color.ordinal()]=source;
|
|
|
|
}
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public int getManaSource(final MagicColor color) {
|
|
|
|
return manaSource[color.ordinal()];
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void setPowerToughness(final int aPower, final int aToughness) {
|
|
|
|
power = aPower;
|
|
|
|
toughness = aToughness;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public int getCardPower() {
|
|
|
|
return power;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public int getCardToughness() {
|
|
|
|
return toughness;
|
|
|
|
}
|
|
|
|
|
|
|
|
public MagicPowerToughness genPowerToughness() {
|
|
|
|
return new MagicPowerToughness(power, toughness);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void applyCDAPowerToughness(
|
2013-06-23 18:33:35 -07:00
|
|
|
final MagicGame game,
|
|
|
|
final MagicPlayer player,
|
2013-04-12 19:32:25 -07:00
|
|
|
final MagicPermanent perm,
|
|
|
|
final MagicPowerToughness pt) {
|
|
|
|
for (final MagicCDA lv : CDAs) {
|
|
|
|
lv.modPowerToughness(game, player, perm, pt);
|
|
|
|
}
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void addAbility(final MagicAbility ability) {
|
|
|
|
abilityFlags.add(ability);
|
|
|
|
}
|
|
|
|
|
|
|
|
public Set<MagicAbility> genAbilityFlags() {
|
|
|
|
return abilityFlags.clone();
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean hasAbility(final MagicAbility ability) {
|
|
|
|
return abilityFlags.contains(ability);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void setText(final String text) {
|
|
|
|
this.text = text;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public String getText() {
|
|
|
|
return this.text;
|
|
|
|
}
|
2015-04-22 23:35:17 -07:00
|
|
|
|
|
|
|
public String getFlattenedText() {
|
|
|
|
return this.text.replace("\n", " ");
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void setStaticType(final MagicStaticType staticType) {
|
|
|
|
this.staticType=staticType;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
MagicStaticType getStaticType() {
|
|
|
|
return staticType;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void setTiming(final MagicTiming timing) {
|
|
|
|
this.timing=timing;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public MagicTiming getTiming() {
|
|
|
|
return timing;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void add(final MagicChangeCardDefinition mod) {
|
|
|
|
mod.change(this);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void setEvent(final MagicCardEvent aCardEvent) {
|
|
|
|
assert cardEvent == MagicPlayCardEvent.create() : "Attempting to set two MagicCardEvents for " + this;
|
|
|
|
cardEvent = aCardEvent;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public MagicCardEvent getCardEvent() {
|
|
|
|
return cardEvent;
|
|
|
|
}
|
|
|
|
|
|
|
|
public MagicActivationHints getActivationHints() {
|
|
|
|
return new MagicActivationHints(timing,true);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
// cast card activation is the first element of cardActivations
|
2013-09-08 23:04:29 -07:00
|
|
|
public MagicActivation<MagicCard> getCastActivation() {
|
2013-04-12 19:32:25 -07:00
|
|
|
assert cardActivations.size() >= 1 : this + " has no card activations";
|
|
|
|
return cardActivations.getFirst();
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-07-07 06:16:11 -07:00
|
|
|
public Collection<MagicActivation<MagicCard>> getCardActivations() {
|
2013-04-12 19:32:25 -07:00
|
|
|
return cardActivations;
|
|
|
|
}
|
2014-05-01 00:16:14 -07:00
|
|
|
|
2014-04-17 05:10:06 -07:00
|
|
|
public Collection<MagicActivation<MagicCard>> getGraveyardActivations() {
|
|
|
|
return graveyardActivations;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void addCDA(final MagicCDA cda) {
|
|
|
|
CDAs.add(cda);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-06-15 20:16:56 -07:00
|
|
|
public void addCostEvent(final MagicEventSource eventSource) {
|
|
|
|
costEventSources.add(eventSource);
|
|
|
|
}
|
2013-04-12 19:32:25 -07:00
|
|
|
|
|
|
|
public void addTrigger(final MagicWhenSpellIsCastTrigger trigger) {
|
|
|
|
spellIsCastTriggers.add(trigger);
|
|
|
|
}
|
2014-08-25 06:13:33 -07:00
|
|
|
|
|
|
|
public void addTrigger(final MagicWhenCycleTrigger trigger) {
|
|
|
|
cycleTriggers.add(trigger);
|
|
|
|
}
|
2013-04-12 19:32:25 -07:00
|
|
|
|
|
|
|
public void addTrigger(final MagicWhenComesIntoPlayTrigger trigger) {
|
|
|
|
if (trigger.usesStack()) {
|
|
|
|
comeIntoPlayTriggers.add(trigger);
|
|
|
|
} else {
|
|
|
|
comeIntoPlayTriggers.addFirst(trigger);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void addTrigger(final MagicWhenPutIntoGraveyardTrigger trigger) {
|
|
|
|
putIntoGraveyardTriggers.add(trigger);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void addTrigger(final MagicWhenDrawnTrigger trigger) {
|
|
|
|
drawnTriggers.add(trigger);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void addTrigger(final MagicTrigger<?> trigger) {
|
|
|
|
triggers.add(trigger);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void addStatic(final MagicStatic mstatic) {
|
|
|
|
statics.add(mstatic);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public Collection<MagicTrigger<?>> getTriggers() {
|
|
|
|
return triggers;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public Collection<MagicStatic> getStatics() {
|
|
|
|
return statics;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public Collection<MagicWhenSpellIsCastTrigger> getSpellIsCastTriggers() {
|
|
|
|
return spellIsCastTriggers;
|
|
|
|
}
|
2014-08-25 06:13:33 -07:00
|
|
|
|
|
|
|
public Collection<MagicWhenCycleTrigger> getCycleTriggers() {
|
|
|
|
return cycleTriggers;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public Collection<MagicWhenComesIntoPlayTrigger> getComeIntoPlayTriggers() {
|
|
|
|
return comeIntoPlayTriggers;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public Collection<MagicWhenPutIntoGraveyardTrigger> getPutIntoGraveyardTriggers() {
|
|
|
|
return putIntoGraveyardTriggers;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public Collection<MagicWhenDrawnTrigger> getDrawnTriggers() {
|
|
|
|
return drawnTriggers;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void addAct(final MagicPermanentActivation activation) {
|
2013-07-07 06:16:11 -07:00
|
|
|
permActivations.add(activation);
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
2014-07-31 20:55:26 -07:00
|
|
|
|
|
|
|
public void addMorphAct(final MagicPermanentActivation activation) {
|
|
|
|
morphActivations.add(activation);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void addCardAct(final MagicCardActivation activation) {
|
2013-06-15 18:41:55 -07:00
|
|
|
cardActivations.add(activation);
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
2014-05-01 00:16:14 -07:00
|
|
|
|
2014-04-17 05:10:06 -07:00
|
|
|
public void addGraveyardAct(final MagicCardActivation activation) {
|
|
|
|
graveyardActivations.add(activation);
|
|
|
|
}
|
2014-05-01 00:16:14 -07:00
|
|
|
|
2014-02-17 21:29:41 -08:00
|
|
|
public void setCardAct(final MagicCardActivation activation) {
|
2015-03-04 18:00:39 -08:00
|
|
|
assert cardActivations.size() == 1 : "removing multiple (" + cardActivations.size() + ") card activations";
|
2014-02-17 21:29:41 -08:00
|
|
|
cardActivations.clear();
|
|
|
|
cardActivations.add(activation);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-07-07 06:16:11 -07:00
|
|
|
public Collection<MagicActivation<MagicPermanent>> getActivations() {
|
|
|
|
return permActivations;
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|
2014-07-31 20:55:26 -07:00
|
|
|
|
|
|
|
public Collection<MagicActivation<MagicPermanent>> getMorphActivations() {
|
|
|
|
return morphActivations;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void addManaAct(final MagicManaActivation activation) {
|
|
|
|
manaActivations.add(activation);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public Collection<MagicManaActivation> getManaActivations() {
|
|
|
|
return manaActivations;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public void setExcludeManaOrCombat() {
|
|
|
|
excludeManaOrCombat=true;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean hasExcludeManaOrCombat() {
|
|
|
|
return excludeManaOrCombat;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
private boolean subTypeHasText(final String s) {
|
|
|
|
final MagicSubType[] subTypeValues = MagicSubType.values();
|
|
|
|
for (final MagicSubType subtype : subTypeValues) {
|
2014-04-10 20:43:22 -07:00
|
|
|
if (subTypeFlags.contains(subtype) && subtype.toString().toLowerCase().contains(s)) {
|
2013-04-12 19:32:25 -07:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
private boolean abilityHasText(final String s) {
|
2013-07-22 23:00:54 -07:00
|
|
|
for (final MagicAbility ability : MagicAbility.values()) {
|
2014-04-10 20:43:22 -07:00
|
|
|
if (hasAbility(ability) && ability.getName().toLowerCase().contains(s)) {
|
2013-04-12 19:32:25 -07:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public boolean hasText(String s) {
|
|
|
|
s = s.toLowerCase();
|
|
|
|
return (
|
2015-05-09 07:01:39 -07:00
|
|
|
CardDefinitions.getASCII(distinctName).toLowerCase().contains(s) ||
|
2014-05-18 13:28:27 -07:00
|
|
|
CardDefinitions.getASCII(name).toLowerCase().contains(s) ||
|
2013-04-12 19:32:25 -07:00
|
|
|
subTypeHasText(s) ||
|
|
|
|
abilityHasText(s) ||
|
2014-05-18 13:28:27 -07:00
|
|
|
CardDefinitions.getASCII(getText()).toLowerCase().contains(s)
|
2013-04-12 19:32:25 -07:00
|
|
|
);
|
|
|
|
}
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
@Override
|
|
|
|
public String toString() {
|
|
|
|
return getName();
|
|
|
|
}
|
|
|
|
|
|
|
|
public static final Comparator<MagicCardDefinition> NAME_COMPARATOR_DESC=new Comparator<MagicCardDefinition>() {
|
|
|
|
@Override
|
|
|
|
public int compare(final MagicCardDefinition cardDefinition1,final MagicCardDefinition cardDefinition2) {
|
|
|
|
return cardDefinition1.getName().compareTo(cardDefinition2.getName());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
public static final Comparator<MagicCardDefinition> NAME_COMPARATOR_ASC=new Comparator<MagicCardDefinition>() {
|
|
|
|
@Override
|
|
|
|
public int compare(final MagicCardDefinition cardDefinition1,final MagicCardDefinition cardDefinition2) {
|
|
|
|
return NAME_COMPARATOR_DESC.compare(cardDefinition2, cardDefinition1);
|
|
|
|
}
|
|
|
|
};
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public static final Comparator<MagicCardDefinition> CONVERTED_COMPARATOR_DESC=new Comparator<MagicCardDefinition>() {
|
|
|
|
@Override
|
|
|
|
public int compare(final MagicCardDefinition cardDefinition1,final MagicCardDefinition cardDefinition2) {
|
|
|
|
final int cdif=cardDefinition1.getConvertedCost()-cardDefinition2.getConvertedCost();
|
|
|
|
if (cdif!=0) {
|
|
|
|
return cdif;
|
|
|
|
}
|
|
|
|
return cardDefinition1.getName().compareTo(cardDefinition2.getName());
|
|
|
|
}
|
|
|
|
};
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
public static final Comparator<MagicCardDefinition> CONVERTED_COMPARATOR_ASC=new Comparator<MagicCardDefinition>() {
|
|
|
|
@Override
|
|
|
|
public int compare(final MagicCardDefinition cardDefinition1,final MagicCardDefinition cardDefinition2) {
|
|
|
|
return CONVERTED_COMPARATOR_DESC.compare(cardDefinition2, cardDefinition1);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
public static final Comparator<MagicCardDefinition> TYPE_COMPARATOR_DESC=new Comparator<MagicCardDefinition>() {
|
|
|
|
@Override
|
2013-06-23 18:33:35 -07:00
|
|
|
public int compare(final MagicCardDefinition cardDefinition1,final MagicCardDefinition cardDefinition2) {
|
2013-04-12 19:32:25 -07:00
|
|
|
final int c = cardDefinition1.getTypeString().compareTo(cardDefinition2.getTypeString());
|
2014-04-10 20:43:22 -07:00
|
|
|
if (c == 0) {
|
2013-04-12 19:32:25 -07:00
|
|
|
return cardDefinition1.getLongTypeString().compareTo(cardDefinition2.getLongTypeString());
|
|
|
|
}
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
public static final Comparator<MagicCardDefinition> TYPE_COMPARATOR_ASC=new Comparator<MagicCardDefinition>() {
|
|
|
|
@Override
|
|
|
|
public int compare(final MagicCardDefinition cardDefinition1,final MagicCardDefinition cardDefinition2) {
|
|
|
|
return TYPE_COMPARATOR_DESC.compare(cardDefinition2, cardDefinition1);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
public static final Comparator<MagicCardDefinition> RARITY_COMPARATOR_DESC=new Comparator<MagicCardDefinition>() {
|
|
|
|
@Override
|
|
|
|
public int compare(final MagicCardDefinition cardDefinition1,final MagicCardDefinition cardDefinition2) {
|
|
|
|
return cardDefinition1.getRarityString().compareTo(cardDefinition2.getRarityString());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
public static final Comparator<MagicCardDefinition> RARITY_COMPARATOR_ASC=new Comparator<MagicCardDefinition>() {
|
|
|
|
@Override
|
|
|
|
public int compare(final MagicCardDefinition cardDefinition1,final MagicCardDefinition cardDefinition2) {
|
|
|
|
return RARITY_COMPARATOR_DESC.compare(cardDefinition2, cardDefinition1);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
public static final Comparator<MagicCardDefinition> POWER_COMPARATOR_DESC=new Comparator<MagicCardDefinition>() {
|
|
|
|
@Override
|
|
|
|
public int compare(final MagicCardDefinition cardDefinition1,final MagicCardDefinition cardDefinition2) {
|
|
|
|
final int p1 = cardDefinition1.isCreature() ? cardDefinition1.getCardPower() : -100;
|
|
|
|
final int p2 = cardDefinition2.isCreature() ? cardDefinition2.getCardPower() : -100;
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
if (p1 != p2) {
|
|
|
|
return p1 - p2;
|
|
|
|
} else {
|
|
|
|
return cardDefinition1.getName().compareTo(cardDefinition2.getName());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
public static final Comparator<MagicCardDefinition> POWER_COMPARATOR_ASC=new Comparator<MagicCardDefinition>() {
|
|
|
|
@Override
|
|
|
|
public int compare(final MagicCardDefinition cardDefinition1,final MagicCardDefinition cardDefinition2) {
|
|
|
|
return POWER_COMPARATOR_DESC.compare(cardDefinition2, cardDefinition1);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
public static final Comparator<MagicCardDefinition> TOUGHNESS_COMPARATOR_DESC=new Comparator<MagicCardDefinition>() {
|
|
|
|
@Override
|
|
|
|
public int compare(final MagicCardDefinition cardDefinition1,final MagicCardDefinition cardDefinition2) {
|
|
|
|
final int t1 = cardDefinition1.isCreature() ? cardDefinition1.getCardToughness() : -100;
|
|
|
|
final int t2 = cardDefinition2.isCreature() ? cardDefinition2.getCardToughness() : -100;
|
2013-06-23 18:33:35 -07:00
|
|
|
|
2013-04-12 19:32:25 -07:00
|
|
|
if (t1 != t2) {
|
|
|
|
return t1 - t2;
|
|
|
|
} else {
|
|
|
|
return cardDefinition1.getName().compareTo(cardDefinition2.getName());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
public static final Comparator<MagicCardDefinition> TOUGHNESS_COMPARATOR_ASC=new Comparator<MagicCardDefinition>() {
|
|
|
|
@Override
|
|
|
|
public int compare(final MagicCardDefinition cardDefinition1,final MagicCardDefinition cardDefinition2) {
|
|
|
|
return TOUGHNESS_COMPARATOR_DESC.compare(cardDefinition2, cardDefinition1);
|
|
|
|
}
|
|
|
|
};
|
2014-05-01 00:16:14 -07:00
|
|
|
|
|
|
|
public void setIsMissing(boolean b) {
|
|
|
|
this.isMissing = b;
|
|
|
|
}
|
|
|
|
public boolean isMissing() {
|
|
|
|
return isMissing;
|
|
|
|
}
|
2014-06-02 12:45:36 -07:00
|
|
|
|
|
|
|
public void setIsScriptFileMissing(boolean b) {
|
|
|
|
isScriptFileMissing = b;
|
|
|
|
}
|
|
|
|
public boolean IsScriptFileMissing() {
|
|
|
|
return isScriptFileMissing;
|
|
|
|
}
|
2013-04-12 19:32:25 -07:00
|
|
|
}
|