external-repos/forge
1
0
Fork 0
mirror of https://github.com/Card-Forge/forge.git synced 2025-11-20 12:48:00 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
750cb63448dd24a4d15b05e425ae17abee56c149
forge/src/forge/CardFactory.java

16561 lines
754 KiB
Java
Raw Blame History

package forge;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Vector;
import javax.swing.JOptionPane;
import forge.error.ErrorViewer;
import forge.properties.ForgeProps;
import forge.properties.NewConstants;
public class CardFactory implements NewConstants {
// String cardname is the key, Card is the value
private Map<String, Card> map = new HashMap<String, Card>();
private CardList allCards = new CardList();
private HashSet<String> removedCardList;
private Card blankCard = new Card(); //new code
public CardFactory(String filename) {
this(new File(filename));
}
public CardFactory(File file) {
SpellAbility spell = new SpellAbility(SpellAbility.Spell, blankCard) {
//neither computer nor human play can play this card
@Override
public boolean canPlay() {
return false;
}
@Override
public void resolve() {}
};
blankCard.addSpellAbility(spell);
spell.setManaCost("1");
blankCard.setName("Removed Card");
//owner and controller will be wrong sometimes
//but I don't think it will matter
//theoretically blankCard will go to the wrong graveyard
blankCard.setOwner(Constant.Player.Human);
blankCard.setController(Constant.Player.Human);
removedCardList = new HashSet<String>(FileUtil.readFile(ForgeProps.getFile(REMOVED)));
try {
readCards(file);
// initialize CardList allCards
Iterator<String> it = map.keySet().iterator();
Card c;
while(it.hasNext()) {
c = getCard(it.next().toString(), Constant.Player.Human);
allCards.add(c);
//System.out.println("cardName: " + c.getName());
}
} catch(Exception ex) {
ErrorViewer.showError(ex);
}
}// constructor
public CardList getAllCards() {
return new CardList(allCards.toArray());
}// getAllCards()
private void readCards(File file) {
map.clear();
ReadCard read = new ReadCard(ForgeProps.getFile(CARDS));
try {
read.run();
// javax.swing.SwingUtilities.invokeAndWait(read);
} catch(Exception ex) {
ErrorViewer.showError(ex);
throw new RuntimeException("CardFactory : readCards() thread error - " + ex.getMessage());
}
ArrayList<Card> simpleList = read.getCards();
Card s;
Iterator<Card> it = simpleList.iterator();
while(it.hasNext()) {
s = it.next();
map.put(s.getName(), s);
//System.out.println("cardName: " + s.getName());
}
}// readCard()
final public Card dynamicCopyCard(Card in)
{
if(in.getType().contains("Creature")) {
Card card2 = new Card();
card2 = CardFactory_Creatures.getCard(in, in.getName(), in.getOwner(), this);
return card2;
} else if(in.getType().contains("Aura")) {
Card card2 = new Card();
card2 = CardFactory_Auras.getCard(in, in.getName(), in.getOwner());
return card2;
} else if(in.getType().contains("Equipment")) {
Card card2 = new Card();
card2 = CardFactory_Equipment.getCard(in, in.getName(), in.getOwner());
return card2;
} else if(in.getType().contains("Planeswalker")) {
Card card2 = new Card();
card2 = CardFactory_Planeswalkers.getCard(in, in.getName(), in.getOwner());
return card2;
} else if(in.getType().contains("Land")) {
Card card2 = new Card();
card2 = CardFactory_Lands.getCard(in, in.getName(), in.getOwner());
return card2;
}
else
{
Card out = getCard(in.getName(), in.getOwner());
out.setUniqueNumber(in.getUniqueNumber());
return out;
}
}
final public Card copyCard(Card in) {
Card out = getCard(in.getName(), in.getOwner());
out.setUniqueNumber(in.getUniqueNumber());
return out;
}
/*
final public Card getCard(String cardName, String owner) {
cardName = AllZone.NameChanger.getOriginalName(cardName);
return getCard2(cardName, owner);
}
*/
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//this is the new getCard() method, you have to remove the old getCard()
final public Card getCard(String cardName, String owner) {
if(removedCardList.contains(cardName) || cardName.equals(blankCard.getName())) return blankCard;
return getCard2(cardName, owner);
}
private final int hasKeyword(Card c, String k) {
ArrayList<String> a = c.getKeyword();
for(int i = 0; i < a.size(); i++)
if(a.get(i).toString().startsWith(k)) return i;
return -1;
}
private final int shouldManaAbility(Card c) {
ArrayList<String> a = c.getIntrinsicKeyword();
for(int i = 0; i < a.size(); i++)
if(a.get(i).toString().contains(": add ")) return i;
return -1;
}
final private Card getCard2(final String cardName, final String owner) {
//o should be Card object
Object o = map.get(cardName);
if(o == null) throw new RuntimeException("CardFactory : getCard() invalid card name - " + cardName);
final Card card = copyStats(o);
card.setOwner(owner);
card.setController(owner);
//may have to change the spell
//this is so permanents like creatures and artifacts have a "default" spell
if(!card.isLand()) card.addSpellAbility(new Spell_Permanent(card));
//look for "Comes into play tapped." in the "no text" line
//of card.txt and add the appropriate code to make that happen
if(card.getKeyword().contains("Comes into play tapped.")) {
card.addComesIntoPlayCommand(new Command() {
private static final long serialVersionUID = 203335252453049234L;
public void execute() {
card.tap();
}
});
}//if "Comes into play tapped."
// Support for using string variables to define Count$ for X or Y
// Or just about any other String that a card object needs at any given time
while(hasKeyword(card, "SVar") != -1) {
int n = hasKeyword(card, "SVar");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
if(k.length > 2) card.SetSVar(k[1], k[2]);
}
}
/* //Creatures with simple, self-targeted mana-activated keyword adding abilities
//-1 means not found
while(hasKeyword(card, "KPump") != -1)
{
int n = hasKeyword(card, "KPump");
if(n != -1)
{
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final String manaCost = k[0].substring(6);
final String keyword = k[1];
final Command untilEOT = new Command()
{
private static final long serialVersionUID = -2904643243256352517L;
public void execute()
{
if(AllZone.GameAction.isCardInPlay(card))
{
card.removeIntrinsicKeyword(keyword);
}
}
};
SpellAbility ability = new Ability_Activated(card, manaCost)
{
private static final long serialVersionUID = -630655617339584299L;
public boolean canPlayAI()
{
//in case if a lifelink pump, allow multiple pumps
if (CardFactoryUtil.AI_doesCreatureAttack(card) &&
!card.getKeyword().contains(keyword))
{
Random r = new Random();
if (r.nextFloat() <= Math.pow(.6667, card.getAbilityUsed()))
return true;
else
return false;
}
else
return false;
}
public boolean canPlay()
{
if (CardFactoryUtil.canUseAbility(card) && AllZone.GameAction.isCardInPlay(card))
return true;
else
return false;
}
public void resolve()
{
if(AllZone.GameAction.isCardInPlay(card))
{
card.addIntrinsicKeyword(keyword);
card.setAbilityUsed(card.getAbilityUsed()+1);
AllZone.EndOfTurn.addUntil(untilEOT);
}
}
};
String Desc = new String();
Desc = cardName + " gains " + keyword + " until end of turn.";
ability.setDescription(manaCost + ": " + Desc);
ability.setStackDescription(Desc);
card.addSpellAbility(ability);
}//if (should pump card)
}//while - card has more pump keywords - Blistering Dieflyn has two pump keywords
//Creatures with simple, self-targeted mana-activated power and/or toughness
//pumping abilities
//is the card "self pumper" like Furnace Whelp - this card gets +1/+1 until end of turn?
//-1 means not found
while (hasKeyword(card, "PTPump") != -1)
{
int n = hasKeyword(card, "PTPump");
if(n != -1)
{
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
final int attack[] = new int[1];
final int defense[] = new int[1];
String k[] = parse.split(":");
String pt[] = k[1].split("/");
final String manaCost = k[0].substring(7);
Integer na = card.getNetAttack();
Integer nd = card.getNetDefense();
pt[0].replace("p", na.toString());
pt[0].replace("t", nd.toString());
pt[1].replace("p", na.toString());
pt[1].replace("t", nd.toString());
attack[0] = Integer.parseInt(pt[0].replace("+", ""));
defense[0] = Integer.parseInt(pt[1].replace("+", ""));
final Command untilEOT = new Command()
{
private static final long serialVersionUID = -4518618729662470596L;
public void execute()
{
if(AllZone.GameAction.isCardInPlay(card))
{
card.addTempAttackBoost(-attack[0]);
card.addTempDefenseBoost(-defense[0]);
}
}
};
SpellAbility ability = new Ability_Activated(card, manaCost)
{
private static final long serialVersionUID = -5718931378326228534L;
public boolean canPlayAI()
{
if (card.getNetDefense() + defense[0] < 1) // no point if it would kill the creature outright
return false;
return CardFactoryUtil.AI_doesCreatureAttack(card);
}
public boolean canPlay()
{
if (CardFactoryUtil.canUseAbility(card) && AllZone.GameAction.isCardInPlay(card) &&
!card.isFaceDown())
return true;
else
return false;
}
public void resolve()
{
if(AllZone.GameAction.isCardInPlay(card))
{
card.addTempAttackBoost(attack[0]);
card.addTempDefenseBoost(defense[0]);
card.setAbilityUsed(card.getAbilityUsed()+1);
AllZone.EndOfTurn.addUntil(untilEOT);
}
}
};
String Desc = new String();
Desc = cardName + " gets ";
if (attack[0] > 0)
Desc = Desc + "+" + attack[0];
else
Desc = Desc + attack[0];
Desc = Desc + "/";
if (defense[0] > 0)
Desc = Desc + "+" + defense[0];
else
Desc = Desc + defense[0];
Desc = Desc + " until end of turn.";
ability.setDescription(manaCost + ": " + Desc);
ability.setStackDescription(Desc);
card.addSpellAbility(ability);
}//if (should pump card)
}//while - card has more pump keywords - Blistering Dieflyn has two pump keywords
//Creatures with simple, self-targeted mana-activated power and/or toughness
//pumping plus keyword adding abilities
//is the card "self pumper" like Furnance Whelp - this card gets +1/+1 until end of turn?
//-1 means not found
while(hasKeyword(card, "PTKPump") != -1)
{
int n = hasKeyword(card, "PTKPump");
if(n != -1)
{
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
final int attack[] = new int[1];
final int defense[] = new int[1];
String k[] = parse.split(":");
String ptk[] = k[1].split("/");
final String manaCost = k[0].substring(8);
attack[0] = Integer.parseInt(ptk[0].replace("+", ""));
defense[0] = Integer.parseInt(ptk[1].replace("+", ""));
final String keyword = ptk[2];
final Command untilEOT = new Command()
{
private static final long serialVersionUID = -3554196069508466753L;
public void execute()
{
if(AllZone.GameAction.isCardInPlay(card))
{
card.removeIntrinsicKeyword(keyword);
card.addTempAttackBoost(-attack[0]);
card.addTempDefenseBoost(-defense[0]);
}
}
};
SpellAbility ability = new Ability_Activated(card, manaCost)
{
private static final long serialVersionUID = 4196412133232530875L;
public boolean canPlayAI()
{
if (card.getNetDefense() + defense[0] < 1) // no point if it would kill the creature outright
return false;
if (card.getKeyword().contains(keyword))
return false;
return CardFactoryUtil.AI_doesCreatureAttack(card);
}
public boolean canPlay()
{
if (CardFactoryUtil.canUseAbility(card) && AllZone.GameAction.isCardInPlay(card) &&
!card.isFaceDown())
return true;
else
return false;
}
public void resolve()
{
if(AllZone.GameAction.isCardInPlay(card))
{
card.addIntrinsicKeyword(keyword);
card.addTempAttackBoost(attack[0]);
card.addTempDefenseBoost(defense[0]);
card.setAbilityUsed(card.getAbilityUsed()+1);
AllZone.EndOfTurn.addUntil(untilEOT);
}
}
};
String Desc = new String();
Desc = cardName + " gets ";
if (attack[0] > 0)
Desc = Desc + "+" + attack[0];
else
Desc = Desc + attack[0];
Desc = Desc + "/";
if (defense[0] > 0)
Desc = Desc + "+" + defense[0];
else
Desc = Desc + defense[0];
Desc = Desc + " and gains " + keyword + " until end of turn.";
ability.setDescription(manaCost + ": " + Desc);
ability.setStackDescription(Desc);
card.addSpellAbility(ability);
}//if (should pump card)
}//while - card has more pump keywords - Blistering Dieflyn has two pump keywords
//Creatures with simple, targeted keyword adding abilities
// costs may include "T" to indicate a tap cost
//-1 means not found
while(hasKeyword(card, "TgtKPump") != -1)
{
int n = hasKeyword(card, "TgtKPump");
if(n != -1)
{
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
String tmpCost = k[0].substring(9);
final String keyword = k[1];
boolean tapCost = false;
boolean tapOnlyCost = false;
if (tmpCost.contains("T"))
{
tapCost = true;
tmpCost = tmpCost.replace("T", "");
tmpCost = tmpCost.trim();
if (tmpCost.length() == 0)
tapOnlyCost = true;
}
final String manaCost = tmpCost;
String tempDesc = new String();
tempDesc = "Target creature gains " + keyword + " until end of turn.";
final String Desc = tempDesc;
if (! tapCost)
{
final SpellAbility ability = new Ability_Activated(card, manaCost)
{
private static final long serialVersionUID = -1118592153328758083L;
public boolean canPlayAI()
{
//if(CardFactoryUtil.AI_doesCreatureAttack(card))
// return false;
CardList list = getCreature();
if (list.isEmpty())
return false;
else
{
Random r = new Random();
if (r.nextFloat() <= Math.pow(.6667, card.getAbilityUsed()))
return true;
else
return false;
}
}
public boolean canPlay()
{
if (CardFactoryUtil.canUseAbility(card) && AllZone.GameAction.isCardInPlay(card)&&
!card.isFaceDown())
return true;
else
return false;
}
public void chooseTargetAI()
{
Card target = CardFactoryUtil.AI_getBestCreature(getCreature());
setTargetCard(target);
}
CardList getCreature()
{
CardList list = new CardList(AllZone.Computer_Play.getCards());
list = list.filter(new CardListFilter()
{
public boolean addCard(Card c)
{
return c.isCreature() &&
(!CardFactoryUtil.AI_doesCreatureAttack(c)) && CardFactoryUtil.canTarget(card, c) &&
(! c.getKeyword().contains(keyword)) &&
(! c.getKeyword().contains("Defender")) &&
(! c.hasSickness() && keyword.equals("Haste"));
}
});
// list.remove(card); // if mana-only cost, allow self-target
return list;
}//getCreature()
public void resolve()
{
if(AllZone.GameAction.isCardInPlay(getTargetCard()) && CardFactoryUtil.canTarget(card, getTargetCard()) )
{
final Card[] creature = new Card[1];
final Command EOT = new Command()
{
private static final long serialVersionUID = -8840812331316327448L;
public void execute()
{
if(AllZone.GameAction.isCardInPlay(creature[0]))
creature[0].removeExtrinsicKeyword(keyword);
}
};
creature[0] = getTargetCard();
creature[0].addExtrinsicKeyword(keyword);
card.setAbilityUsed(card.getAbilityUsed()+1);
AllZone.EndOfTurn.addUntil(EOT);
}//if (card is in play)
}//resolve()
};//SpellAbility
ability.setDescription(manaCost + ": " + Desc);
ability.setStackDescription(Desc);
ability.setBeforePayMana(CardFactoryUtil.input_targetCreature(ability));
card.addSpellAbility(ability);
}
if (tapOnlyCost)
{
final SpellAbility ability = new Ability_Tap(card)
{
private static final long serialVersionUID = 5252594757468128739L;
public boolean canPlayAI()
{
if(CardFactoryUtil.AI_doesCreatureAttack(card))
return false;
return getCreature().size() != 0;
}
public boolean canPlay()
{
boolean sick = true;
if (!card.hasSickness() || !card.isCreature())
sick = false;
if (card.isUntapped() && CardFactoryUtil.canUseAbility(card) && AllZone.GameAction.isCardInPlay(card)
&& !sick && !card.isFaceDown())
return true;
else
return false;
}
public void chooseTargetAI()
{
card.tap();
Card target = CardFactoryUtil.AI_getBestCreature(getCreature());
setTargetCard(target);
}
CardList getCreature()
{
CardList list = new CardList(AllZone.Computer_Play.getCards());
list = list.filter(new CardListFilter()
{
public boolean addCard(Card c)
{
return c.isCreature() &&
(!CardFactoryUtil.AI_doesCreatureAttack(c)) &&
(! c.getKeyword().contains(keyword)) &&
(! c.getKeyword().contains("Defender")) &&
(! c.hasSickness() && keyword.equals("Haste"));
}
});
list.remove(card);
return list;
}//getCreature()
public void resolve()
{
if(AllZone.GameAction.isCardInPlay(getTargetCard()) && CardFactoryUtil.canTarget(card, getTargetCard()))
{
final Card[] creature = new Card[1];
final Command EOT = new Command()
{
private static final long serialVersionUID = 2134353417588894452L;
public void execute()
{
if(AllZone.GameAction.isCardInPlay(creature[0]))
creature[0].removeExtrinsicKeyword(keyword);
}
};
creature[0] = getTargetCard();
creature[0].addExtrinsicKeyword(keyword);
AllZone.EndOfTurn.addUntil(EOT);
}//if (card is in play)
}//resolve()
};//SpellAbility
ability.setDescription("tap: " + Desc);
ability.setStackDescription(Desc);
ability.setBeforePayMana(CardFactoryUtil.input_targetCreature(ability));
card.addSpellAbility(ability);
}
if (! tapOnlyCost && tapCost)
{
final SpellAbility ability = new Ability_Tap(card, manaCost)
{
private static final long serialVersionUID = 7593387152288440603L;
public boolean canPlayAI()
{
if(CardFactoryUtil.AI_doesCreatureAttack(card))
return false;
return getCreature().size() != 0;
}
public boolean canPlay()
{
boolean sick = true;
if (!card.hasSickness() || !card.isCreature())
sick = false;
if (card.isUntapped() && CardFactoryUtil.canUseAbility(card) && AllZone.GameAction.isCardInPlay(card) &&
!sick && !card.isFaceDown())
return true;
else
return false;
}
public void chooseTargetAI()
{
card.tap();
Card target = CardFactoryUtil.AI_getBestCreature(getCreature());
setTargetCard(target);
}
CardList getCreature()
{
CardList list = new CardList(AllZone.Computer_Play.getCards());
list = list.filter(new CardListFilter()
{
public boolean addCard(Card c)
{
return c.isCreature() &&
(!CardFactoryUtil.AI_doesCreatureAttack(c)) &&
(! c.getKeyword().contains(keyword)) &&
(! c.getKeyword().contains("Defender")) &&
(! c.hasSickness() && keyword.equals("Haste"));
}
});
list.remove(card);
return list;
}//getCreature()
public void resolve()
{
if(AllZone.GameAction.isCardInPlay(getTargetCard()) && CardFactoryUtil.canTarget(card ,getTargetCard()))
{
final Card[] creature = new Card[1];
final Command EOT = new Command()
{
private static final long serialVersionUID = 3532917180149273560L;
public void execute()
{
if(AllZone.GameAction.isCardInPlay(creature[0]))
creature[0].removeExtrinsicKeyword(keyword);
}
};
creature[0] = getTargetCard();
creature[0].addExtrinsicKeyword(keyword);
AllZone.EndOfTurn.addUntil(EOT);
}//if (card is in play)
}//resolve()
};//SpellAbility
ability.setDescription(manaCost + ", tap: " + Desc);
ability.setStackDescription(Desc);
ability.setBeforePayMana(CardFactoryUtil.input_targetCreature(ability));
card.addSpellAbility(ability);
}
}
}//while
*/
//Creatures with self-regenerate abilities
//-1 means keyword "RegenerateMe" not found
while(hasKeyword(card, "RegenerateMe") != -1) {
int n = hasKeyword(card, "RegenerateMe");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final String manacost = k[1];
final Command untilEOT = new Command() {
private static final long serialVersionUID = -7619842476705984912L;
public void execute() {
card.setShield(0);
}
};
final SpellAbility a1 = new Ability(card, manacost) {
@Override
public boolean canPlayAI() {
if(CardFactoryUtil.AI_isMainPhase()) {
if(CardFactoryUtil.AI_doesCreatureAttack(card)) {
//"Fuzzy logic" to determine if using a regenerate ability might be helpful because
//we can't wait to decide to play this ability during combat, like the human can
//weight[] is a set of probability percentages to be averaged later
int weight[] = new int[3];
// cards with real keywords (flying, trample, etc) are probably more desireable
if(card.getKeyword().size() > 0) weight[0] = 75;
else weight[0] = 0;
// if there are many cards in hand, then maybe it's not such a great idea to waste mana
CardList HandList = new CardList(AllZone.getZone(Constant.Zone.Hand,
Constant.Player.Computer).getCards());
if(HandList.size() >= 4) weight[1] = 25;
else weight[1] = 75;
// compare the highest converted mana cost of cards in hand to the number of lands
// if there's spare mana, then regeneration might be viable
int hCMC = 0;
for(int i = 0; i < HandList.size(); i++)
if(CardUtil.getConvertedManaCost(HandList.getCard(i).getManaCost()) > hCMC) hCMC = CardUtil.getConvertedManaCost(HandList.getCard(
i).getManaCost());
CardList LandList = new CardList(AllZone.getZone(Constant.Zone.Play,
Constant.Player.Computer).getCards());
LandList = LandList.getType("Land");
//most regenerate abilities cost 2 or less
if(hCMC + 2 >= LandList.size()) weight[2] = 50;
else weight[2] = 0;
// ultimately, it's random fate that dictates if this was the right play
int aw = (weight[0] + weight[1] + weight[2]) / 3;
Random r = new Random();
if(r.nextInt(100) <= aw) return true;
}
}
return false;
}
@Override
public void resolve() {
card.addShield();
AllZone.EndOfTurn.addUntil(untilEOT);
}
}; //SpellAbility
card.addSpellAbility(a1);
String Desc = "";
Desc = "Regenerate " + cardName;
a1.setDescription(manacost + ": " + Desc);
a1.setStackDescription(Desc);
a1.setBeforePayMana(new Input_PayManaCost(a1));
} //if (should RegenerateMe)
} //while - card has more RegenerateMe - Jungle Troll has two Regenerate keywords
while(hasKeyword(card, "abPump") != -1) {
int n = hasKeyword(card, "abPump");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final boolean Tgt[] = {false};
Tgt[0] = k[0].contains("Tgt");
String tmpCost;
if(Tgt[0]) tmpCost = k[0].substring(9);
else tmpCost = k[0].substring(6);
boolean tapCost = false;
boolean tapOnlyCost = false;
if(tmpCost.contains("T")) {
tapCost = true;
tmpCost = tmpCost.replace("T", "");
tmpCost = tmpCost.trim();
if(tmpCost.length() == 0) tapOnlyCost = true;
}
final String manaCost = tmpCost.trim();
final int NumAttack[] = {-1138};
final String AttackX[] = {"none"};
final int NumDefense[] = {-1138};
final String DefenseX[] = {"none"};
final String Keyword[] = {"none"};
String ptk[] = k[1].split("/");
if(ptk.length == 1) // keyword only
Keyword[0] = ptk[0];
if(ptk.length >= 2) // power/toughness
{
if(ptk[0].matches("[\\+\\-][XY]")) {
String xy = card.getSVar(ptk[0].replaceAll("[\\+\\-]", ""));
if(xy.startsWith("Count$")) {
String kk[] = xy.split("\\$");
AttackX[0] = kk[1];
if(ptk[0].contains("-")) // handle "-X" or "-Y"
if(AttackX[0].contains("/")) // already contains math element
AttackX[0] = AttackX[0].replace("/", "/Negative"); // insert into existing math element
else AttackX[0] += "/Negative"; // add math element
}
} else if(ptk[0].matches("[\\+\\-][0-9]")) NumAttack[0] = Integer.parseInt(ptk[0].replace("+",
""));
if(ptk[1].matches("[\\+\\-][XY]")) {
String xy = card.getSVar(ptk[1].replaceAll("[\\+\\-]", ""));
if(xy.startsWith("Count$")) {
String kk[] = xy.split("\\$");
DefenseX[0] = kk[1];
if(ptk[1].contains("-")) //handle "-X" or "-Y"
if(DefenseX[0].contains("/")) // already contains math element
DefenseX[0] = DefenseX[0].replace("/", "/Negative"); // insert into existing math element
else DefenseX[0] += "/Negative"; // add math element
}
} else if(ptk[1].matches("[\\+\\-][0-9]")) NumDefense[0] = Integer.parseInt(ptk[1].replace(
"+", ""));
}
if(ptk.length == 3) // power/toughness/keyword
Keyword[0] = ptk[2];
final String DrawBack[] = {"none"};
final String spDesc[] = {"none"};
final String stDesc[] = {"none"};
String d = "none";
StringBuilder sbD = new StringBuilder();
if((AttackX[0].equals("none") && !(NumAttack[0] == -1138))
&& (DefenseX[0].equals("none") && !(NumDefense[0] == -1138)) && Keyword[0].equals("none")) {
// pt boost
if(Tgt[0] == true) sbD.append("Target creature gets ");
else {
sbD.append(cardName);
sbD.append(" gets ");
}
if(NumAttack[0] > 0 || (NumAttack[0] == 0 && NumDefense[0] > 0)) // +0/+1
sbD.append("+");
else if(NumAttack[0] < 0 || (NumAttack[0] == 0 && NumDefense[0] < 0)) // -0/-1
sbD.append("-");
sbD.append(Math.abs(NumAttack[0]) + "/");
if(NumDefense[0] > 0 || (NumDefense[0] == 0 && NumAttack[0] > 0)) // +1/+0
sbD.append("+");
else if(NumDefense[0] < 0 || (NumDefense[0] == 0 && NumAttack[0] < 0)) // -1/-0
sbD.append("-");
sbD.append(Math.abs(NumDefense[0]));
sbD.append(" until end of turn.");
}
if((AttackX[0].equals("none") && NumAttack[0] == -1138)
&& (DefenseX[0].equals("none") && NumDefense[0] == -1138) && !Keyword[0].equals("none")) {
// k boost
if(Tgt[0] == true) sbD.append("Target creature gains ");
else {
sbD.append(cardName);
sbD.append(" gains ");
}
sbD.append(Keyword[0]);
sbD.append(" until end of turn.");
}
if((AttackX[0].equals("none") && !(NumAttack[0] == -1138))
&& (DefenseX[0].equals("none") && !(NumDefense[0] == -1138)) && !Keyword[0].equals("none")) {
// ptk boost
if(Tgt[0] == true) sbD.append("Target creature gets ");
else {
sbD.append(cardName);
sbD.append(" gets ");
}
if(NumAttack[0] > 0 || (NumAttack[0] == 0 && NumDefense[0] > 0)) // +0/+1
sbD.append("+");
else if(NumAttack[0] < 0 || (NumAttack[0] == 0 && NumDefense[0] < 0)) // -0/-1
sbD.append("-");
sbD.append(Math.abs(NumAttack[0]) + "/");
if(NumDefense[0] > 0 || (NumDefense[0] == 0 && NumAttack[0] > 0)) // +1/+0
sbD.append("+");
else if(NumDefense[0] < 0 || (NumDefense[0] == 0 && NumAttack[0] < 0)) // -1/-0
sbD.append("-");
sbD.append(Math.abs(NumDefense[0]));
sbD.append(" and gains ");
sbD.append(Keyword[0]);
sbD.append(" until end of turn.");
}
//if (!sbD.toString().isEmpty())
if(sbD.toString().trim().length() != 0) d = sbD.toString();
if(k.length > 2) {
if(k[2].contains("Drawback$")) {
String kk[] = k[2].split("\\$");
DrawBack[0] = kk[1];
if(k.length > 3) d = k[3];
} else if(k.length > 2) d = k[2];
}
if(!d.equals("none")) {
if(tapOnlyCost == true) spDesc[0] = "Tap: " + d;
else if(tapCost == true) spDesc[0] = manaCost + ", tap: " + d;
else spDesc[0] = manaCost + ": " + d;
stDesc[0] = d;
}
if(!tapCost) {
final SpellAbility ability = new Ability_Activated(card, manaCost) {
private static final long serialVersionUID = -1118592153328758083L;
private int defense;
private String keyword;
private int getNumAttack() {
if(NumAttack[0] != -1138) return NumAttack[0];
if(!AttackX[0].equals("none")) return CardFactoryUtil.xCount(card, AttackX[0]);
return 0;
}
private int getNumDefense() {
if(NumDefense[0] != -1138) return NumDefense[0];
if(!DefenseX[0].equals("none")) return CardFactoryUtil.xCount(card, DefenseX[0]);
return 0;
}
@Override
public boolean canPlayAI() {
defense = getNumDefense();
keyword = Keyword[0];
if(AllZone.Phase.getPhase().equals(Constant.Phase.Main2)) return false;
if(Tgt[0] == false) {
setTargetCard(card);
if((card.getNetDefense() + defense > 0) && (!card.getKeyword().contains(keyword))) if(card.hasSickness()
&& keyword.equals("Haste")) return true;
else if((card.hasSickness() && (!keyword.equals("Haste")))
|| ((!card.hasSickness()) && keyword.equals("Haste"))) return false;
else {
Random r = new Random();
if(r.nextFloat() <= Math.pow(.6667, card.getAbilityUsed())) return CardFactoryUtil.AI_doesCreatureAttack(card);
}
}
CardList list = getCreatures();
if(!list.isEmpty()) {
boolean goodt = false;
Card t = new Card();
while(goodt == false && !list.isEmpty()) // loop until we find a target that is best and won't die when targeted or until no more creatures
{
t = CardFactoryUtil.AI_getBestCreature(list);
if((t.getNetDefense() + defense) > 0) // handle negative defense pumps
goodt = true;
else list.remove(t);
}
if(goodt == true) {
Random r = new Random();
if(r.nextFloat() <= Math.pow(.6667, card.getAbilityUsed())) {
setTargetCard(t);
return true;
}
}
}
return false;
}
@Override
public boolean canPlay() {
return (CardFactoryUtil.canUseAbility(card))
&& (AllZone.GameAction.isCardInPlay(card)) && (!card.isFaceDown());
}
private CardList getCreatures() {
CardList list = new CardList(AllZone.Computer_Play.getCards());
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
if(c.isCreature()) {
if(c.hasSickness() && keyword.equals("Haste")) // AI_doesCreatureAttack would have prevented the effect from granting haste, because it assumes the creature would already have it
return CardFactoryUtil.canTarget(card, c);
return (CardFactoryUtil.AI_doesCreatureAttack(c))
&& (CardFactoryUtil.canTarget(card, c))
&& (!keyword.equals("none") && !c.getKeyword().contains(keyword))
&& (!(!c.hasSickness()) && keyword.equals("Haste")); // if creature doesn't have sickness, the haste keyword won't help
}
return false;
}
});
// list.remove(card); // if mana-only cost, allow self-target
return list;
}//getCreatures()
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& (CardFactoryUtil.canTarget(card, getTargetCard()) || !Tgt[0] )) {
final Card[] creature = new Card[1];
if(Tgt[0] == true) creature[0] = getTargetCard();
else creature[0] = card;
final int a = getNumAttack();
final int d = getNumDefense();
final Command EOT = new Command() {
private static final long serialVersionUID = -8840812331316327448L;
public void execute() {
if(AllZone.GameAction.isCardInPlay(creature[0])) {
creature[0].addTempAttackBoost(-1 * a);
creature[0].addTempDefenseBoost(-1 * d);
if(!Keyword[0].equals("none")) creature[0].removeExtrinsicKeyword(Keyword[0]);
}
}
};
creature[0].addTempAttackBoost(a);
creature[0].addTempDefenseBoost(d);
if(!Keyword[0].equals("none")) creature[0].addExtrinsicKeyword(Keyword[0]);
card.setAbilityUsed(card.getAbilityUsed() + 1);
AllZone.EndOfTurn.addUntil(EOT);
if(!DrawBack[0].equals("none")) CardFactoryUtil.doDrawBack(DrawBack[0], 0,
card.getController(),
AllZone.GameAction.getOpponent(card.getController()), null, card,
creature[0]);
}//if (card is in play)
}//resolve()
};//SpellAbility
ability.setDescription(spDesc[0]);
ability.setStackDescription(stDesc[0]);
if(Tgt[0] == true) ability.setBeforePayMana(CardFactoryUtil.input_targetCreature(ability));
else ability.setTargetCard(card);
card.addSpellAbility(ability);
}
if(tapCost) {
final SpellAbility ability = new Ability_Tap(card) {
private static final long serialVersionUID = 5252594757468128739L;
private int defense;
private String keyword;
private int getNumAttack() {
if(NumAttack[0] != -1138) return NumAttack[0];
if(!AttackX[0].equals("none")) return CardFactoryUtil.xCount(card, AttackX[0]);
return 0;
}
private int getNumDefense() {
if(NumDefense[0] != -1138) return NumDefense[0];
if(!DefenseX[0].equals("none")) return CardFactoryUtil.xCount(card, DefenseX[0]);
return 0;
}
@Override
public boolean canPlayAI() {
defense = getNumDefense();
keyword = Keyword[0];
if(CardFactoryUtil.AI_doesCreatureAttack(card)) return false;
if(AllZone.Phase.getPhase().equals(Constant.Phase.Main2)) return false;
CardList list = getCreatures();
if(!list.isEmpty()) {
boolean goodt = false;
Card t = new Card();
while(goodt == false && !list.isEmpty()) {
t = CardFactoryUtil.AI_getBestCreature(list);
if((t.getNetDefense() + defense) > 0) goodt = true;
else list.remove(t);
}
if(goodt == true) {
setTargetCard(t);
return true;
}
}
return false;
}
@Override
public boolean canPlay() {
boolean sick = true;
if(!card.hasSickness() || !card.isCreature()) sick = false;
if(card.isUntapped() && AllZone.GameAction.isCardInPlay(card) && !sick
&& !card.isFaceDown()) return true;
else return false;
}
CardList getCreatures() {
CardList list = new CardList(AllZone.Computer_Play.getCards());
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
if(c.isCreature()) {
if(c.hasSickness() && keyword.equals("Haste")) return CardFactoryUtil.canTarget(
card, c);
return (CardFactoryUtil.AI_doesCreatureAttack(c))
&& (CardFactoryUtil.canTarget(card, c))
&& (!keyword.equals("none") && !c.getKeyword().contains(keyword))
&& (!(!c.hasSickness()) && keyword.equals("Haste"));
}
return false;
}
});
list.remove(card);
return list;
}//getCreature()
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
final Card[] creature = new Card[1];
if(Tgt[0] == true) creature[0] = getTargetCard();
else creature[0] = card;
final int a = getNumAttack();
final int d = getNumDefense();
final Command EOT = new Command() {
private static final long serialVersionUID = 2134353417588894452L;
public void execute() {
if(AllZone.GameAction.isCardInPlay(creature[0])) {
creature[0].addTempAttackBoost(-1 * a);
creature[0].addTempDefenseBoost(-1 * d);
if(!Keyword[0].equals("none")) creature[0].removeExtrinsicKeyword(Keyword[0]);
}
}
};
creature[0].addTempAttackBoost(a);
creature[0].addTempDefenseBoost(d);
if(!Keyword[0].equals("none")) creature[0].addExtrinsicKeyword(Keyword[0]);
AllZone.EndOfTurn.addUntil(EOT);
if(!DrawBack[0].equals("none")) CardFactoryUtil.doDrawBack(DrawBack[0], 0,
card.getController(),
AllZone.GameAction.getOpponent(card.getController()), null, card,
creature[0]);
}//if (card is in play)
}//resolve()
};//SpellAbility
ability.setDescription(spDesc[0]);
ability.setStackDescription(stDesc[0]);
if(Tgt[0] == true) ability.setBeforePayMana(CardFactoryUtil.input_targetCreature(ability));
else ability.setTargetCard(card);
if(!tapOnlyCost) ability.setManaCost(manaCost);
card.addSpellAbility(ability);
}
}
}//while
if(hasKeyword(card, "Untap") != -1) {
int n = hasKeyword(card, "Untap");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final String manacost = k[1];
card.addSpellAbility(CardFactoryUtil.ability_Untap(card, manacost));
}
}
if(hasKeyword(card, "Remove three spore counters") != -1) {
int n = hasKeyword(card, "Remove three spore counters");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
card.addSpellAbility(CardFactoryUtil.ability_Spore_Saproling(card));
}
}//Spore Saproling
if(hasKeyword(card, "spDamageTgt") != -1) {
int n = hasKeyword(card, "spDamageTgt");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
card.clearSpellAbility();
String k[] = parse.split(":");
final boolean TgtCreature[] = {false};
final boolean TgtPlayer[] = {false};
final boolean TgtCP[] = {false};
final boolean TgtOpp[] = {false};
if(k[0].contains("CP")) TgtCP[0] = true;
else if(k[0].contains("P")) TgtPlayer[0] = true;
else if(k[0].contains("C")) TgtCreature[0] = true;
else if(k[0].contains("Opp")) TgtOpp[0] = true;
// how much damage
final int NumDmg[] = {-1};
final String NumDmgX[] = {"none"};
if(k[1].matches("X")) {
String x = card.getSVar(k[1]);
if(x.startsWith("Count$")) {
String kk[] = x.split("\\$");
NumDmgX[0] = kk[1];
}
} else if(k[1].matches("[0-9][0-9]?")) NumDmg[0] = Integer.parseInt(k[1]);
//drawbacks and descriptions
final String DrawBack[] = {"none"};
final String spDesc[] = {"none"};
final String stDesc[] = {"none"};
if(k.length > 2) {
if(k[2].contains("Drawback$")) {
String kk[] = k[2].split("\\$");
DrawBack[0] = kk[1];
if(k.length > 3) spDesc[0] = k[3];
if(k.length > 4) stDesc[0] = k[4];
} else {
if(k.length > 2) spDesc[0] = k[2];
if(k.length > 3) stDesc[0] = k[3];
}
}
final SpellAbility DamageTgt = new Spell(card) {
private static final long serialVersionUID = 7239608350643325111L;
private int damage;
public int getNumDamage() {
if(NumDmg[0] != -1) return NumDmg[0];
if(!NumDmgX[0].equals("none")) return CardFactoryUtil.xCount(card, NumDmgX[0]);
return 0;
}
boolean shouldTgtP() {
PlayerZone compHand = AllZone.getZone(Constant.Zone.Hand, Constant.Player.Computer);
CardList hand = new CardList(compHand.getCards());
if(hand.size() >= 7) // anti-discard-at-EOT
return true;
if(AllZone.Human_Life.getLife() < (10 - damage)) // if damage from this spell would drop the human to less than 10 life
return true;
return false;
}
Card chooseTgtC() {
// Combo alert!!
PlayerZone compy = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
CardList cPlay = new CardList(compy.getCards());
if(cPlay.size() > 0) for(int i = 0; i < cPlay.size(); i++)
if(cPlay.get(i).getName().equals("Stuffy Doll")) return cPlay.get(i);
PlayerZone human = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList hPlay = new CardList(human.getCards());
hPlay = hPlay.filter(new CardListFilter() {
public boolean addCard(Card c) {
// will include creatures already dealt damage
return c.isCreature() && ((c.getNetDefense() + c.getDamage()) <= damage)
&& CardFactoryUtil.canTarget(card, c);
}
});
if(hPlay.size() > 0) {
Card best = hPlay.get(0);
if(hPlay.size() > 1) {
for(int i = 1; i < hPlay.size(); i++) {
Card b = hPlay.get(i);
// choose best overall creature?
if(b.getSpellAbility().length > best.getSpellAbility().length
|| b.getKeyword().size() > best.getKeyword().size()
|| b.getNetAttack() > best.getNetAttack()) best = b;
}
}
return best;
}
return null;
}
@Override
public boolean canPlayAI() {
damage = getNumDamage();
if(TgtCP[0] == true) {
if(shouldTgtP() == true) {
setTargetPlayer(Constant.Player.Human);
return true;
}
Card c = chooseTgtC();
if(c != null) {
setTargetCard(c);
return true;
}
}
if(TgtPlayer[0] == true || TgtOpp[0] == true) {
setTargetPlayer(Constant.Player.Human);
return true;
}
if(TgtCreature[0] == true) {
Card c = chooseTgtC();
if(c != null) {
setTargetCard(c);
return true;
}
}
return false;
}
@Override
public void resolve() {
damage = getNumDamage();
String tgtP = "";
if(TgtOpp[0] == true) setTargetPlayer(AllZone.GameAction.getOpponent(card.getController()));
if(getTargetCard() != null) {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
Card c = getTargetCard();
//c.addDamage(damage);
AllZone.GameAction.addDamage(c, card, damage);
tgtP = c.getController();
}
} else {
AllZone.GameAction.addDamage(getTargetPlayer(), damage);
tgtP = getTargetPlayer();
}
if(!DrawBack[0].equals("none")) CardFactoryUtil.doDrawBack(DrawBack[0], damage,
card.getController(), AllZone.GameAction.getOpponent(card.getController()), tgtP,
card, getTargetCard());
}// resolove
}; //spellAbility
if(!spDesc[0].equals("none")) DamageTgt.setDescription(spDesc[0]);
else {
String s;
s = card.getName() + " deals " + NumDmg[0] + " damage to target";
if(TgtCP[0]) s = s + " creature or player.";
else if(TgtCreature[0]) s = s + " creature.";
else if(TgtPlayer[0]) s = s + " player.";
DamageTgt.setDescription(s);
}
if(!stDesc[0].equals("none")) DamageTgt.setStackDescription(stDesc[0]);
else DamageTgt.setStackDescription(card.getName() + " - deals " + NumDmg[0] + " damage.");
if(TgtCP[0]) DamageTgt.setBeforePayMana(CardFactoryUtil.input_targetCreaturePlayer(DamageTgt,
true, false));
else if(TgtCreature[0]) DamageTgt.setBeforePayMana(CardFactoryUtil.input_targetCreature(DamageTgt));
else if(TgtPlayer[0]) DamageTgt.setBeforePayMana(CardFactoryUtil.input_targetPlayer(DamageTgt));
card.addSpellAbility(DamageTgt);
}
}// spDamageTgt
/*
//Spell damage cards CP means Computer and Player (like shock, Lightning Bolt)
if (hasKeyword(card, "spDamageCP") != -1)
{
int n = hasKeyword(card, "spDamageCP");
if (n != -1)
{
String parse = card.getKeyword().get(n).toString();
//System.out.println("parse: " + parse);
card.removeIntrinsicKeyword(parse);
card.clearSpellAbility();
String k[] = parse.split(":");
final String dmg = k[1];
card.addSpellAbility(CardFactoryUtil.spellability_spDamageCP(card, dmg));
}
}
if (hasKeyword(card, "spDamageP") != -1)
{
int n = hasKeyword(card, "spDamageP");
if (n != -1)
{
String parse = card.getKeyword().get(n).toString();
card.removePrevIntrinsicKeyword(parse);
card.clearSpellAbility();
String k[] = parse.split(":");
final String dmg = k[1];
card.addSpellAbility(CardFactoryUtil.spellability_spDamageP(card, dmg));
}
}//SpDamageP
*/
while(hasKeyword(card, "abDamageTgt") != -1) {
int n = hasKeyword(card, "abDamageTgt");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final boolean TgtCreature[] = {false};
final boolean TgtPlayer[] = {false};
final boolean TgtCP[] = {false};
final boolean TgtOpp[] = {false};
String tmpCost = new String("");
if(k[0].contains("CP")) {
TgtCP[0] = true;
tmpCost = k[0].substring(13);
} else if(k[0].contains("P")) {
TgtPlayer[0] = true;
tmpCost = k[0].substring(12);
} else if(k[0].contains("C")) {
TgtCreature[0] = true;
tmpCost = k[0].substring(12);
}
boolean tapCost = false;
boolean tapOnlyCost = false;
if(tmpCost.contains("T")) {
tapCost = true;
tmpCost = tmpCost.replace("T", "");
tmpCost = tmpCost.trim();
if(tmpCost.length() == 0) tapOnlyCost = true;
}
final String manaCost = tmpCost;
final int NumDmg[] = {-1};
final String NumDmgX[] = {"none"};
if(k[1].matches("X")) {
String x = card.getSVar(k[1]);
if(x.startsWith("Count$")) {
String kk[] = x.split("\\$");
NumDmgX[0] = kk[1];
}
} else if(k[1].matches("[0-9][0-9]?")) NumDmg[0] = Integer.parseInt(k[1]);
//drawbacks and descriptions
final String DrawBack[] = {"none"};
final String spDesc[] = {"none"};
final String stDesc[] = {"none"};
if(k.length > 2) {
if(k[2].contains("Drawback$")) {
String kk[] = k[2].split("\\$");
DrawBack[0] = kk[1];
if(k.length > 3) spDesc[0] = k[3];
if(k.length > 4) stDesc[0] = k[4];
} else {
if(k.length > 2) spDesc[0] = k[2];
if(k.length > 3) stDesc[0] = k[3];
}
} else {
StringBuilder sb = new StringBuilder();
sb.append(card.getName());
sb.append(" deals " + NumDmg[0] + " damage to target ");
if(TgtCP[0]) sb.append("creature or player.");
else if(TgtCreature[0]) sb.append("creature.");
else if(TgtPlayer[0]) sb.append("player.");
spDesc[0] = sb.toString();
stDesc[0] = card.getName() + " -" + sb.toString();
}
if(tapOnlyCost == true) spDesc[0] = "Tap: " + spDesc[0];
else if(tapCost == true) spDesc[0] = manaCost + ", tap: " + spDesc[0];
else spDesc[0] = manaCost + ": " + spDesc[0];
if(!tapCost) {
final SpellAbility abDamage = new Ability_Activated(card, manaCost) {
private static final long serialVersionUID = -7560349014757367722L;
private int damage;
public int getNumDamage() {
if(NumDmg[0] != -1) return NumDmg[0];
if(!NumDmgX[0].equals("none")) return CardFactoryUtil.xCount(card, NumDmgX[0]);
return 0;
}
boolean shouldTgtP() {
PlayerZone compHand = AllZone.getZone(Constant.Zone.Hand, Constant.Player.Computer);
CardList hand = new CardList(compHand.getCards());
if(hand.size() >= 7) // anti-discard-at-EOT
return true;
if(AllZone.Human_Life.getLife() < (10 - damage)) // if damage from this spell would drop the human to less than 10 life
return true;
return false;
}
Card chooseTgtC() {
// Combo alert!!
PlayerZone compy = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
CardList cPlay = new CardList(compy.getCards());
if(cPlay.size() > 0) for(int i = 0; i < cPlay.size(); i++)
if(cPlay.get(i).getName().equals("Stuffy Doll")) return cPlay.get(i);
PlayerZone human = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList hPlay = new CardList(human.getCards());
hPlay = hPlay.filter(new CardListFilter() {
public boolean addCard(Card c) {
// will include creatures already dealt damage
return c.isCreature() && ((c.getNetDefense() + c.getDamage()) <= damage)
&& CardFactoryUtil.canTarget(card, c);
}
});
if(hPlay.size() > 0) {
Card best = hPlay.get(0);
if(hPlay.size() > 1) {
for(int i = 1; i < hPlay.size(); i++) {
Card b = hPlay.get(i);
// choose best overall creature?
if(b.getSpellAbility().length > best.getSpellAbility().length
|| b.getKeyword().size() > best.getKeyword().size()
|| b.getNetAttack() > best.getNetAttack()) best = b;
}
}
return best;
}
return null;
}
@Override
public boolean canPlayAI() {
damage = getNumDamage();
Random r = new Random(); // prevent run-away activations
boolean rr = false;
if(r.nextFloat() <= Math.pow(.6667, card.getAbilityUsed())) rr = true;
if(TgtCP[0] == true) {
if(shouldTgtP() == true) {
setTargetPlayer(Constant.Player.Human);
return rr && true;
}
Card c = chooseTgtC();
if(c != null) {
setTargetCard(c);
return rr && true;
}
}
if(TgtPlayer[0] == true || TgtOpp[0] == true) {
setTargetPlayer(Constant.Player.Human);
return rr && true;
}
if(TgtCreature[0] == true) {
Card c = chooseTgtC();
if(c != null) {
setTargetCard(c);
return rr && true;
}
}
return false;
}
@Override
public void resolve() {
int damage = getNumDamage();
String tgtP = "";
if(TgtOpp[0] == true) {
tgtP = AllZone.GameAction.getOpponent(card.getController());
setTargetPlayer(tgtP);
}
Card c = getTargetCard();
if(c != null) {
if(AllZone.GameAction.isCardInPlay(c) && CardFactoryUtil.canTarget(card, c)) {
AllZone.GameAction.addDamage(c, card, damage);
tgtP = c.getController();
}
} else {
tgtP = getTargetPlayer();
AllZone.GameAction.addDamage(tgtP, card, damage);
}
if(!DrawBack[0].equals("none")) CardFactoryUtil.doDrawBack(DrawBack[0], damage,
card.getController(), AllZone.GameAction.getOpponent(card.getController()),
tgtP, card, getTargetCard());
}//resolve()
};//Ability_Activated
abDamage.setDescription(spDesc[0]);
abDamage.setStackDescription(stDesc[0]);
if(TgtCP[0] == true) abDamage.setBeforePayMana(CardFactoryUtil.input_targetCreaturePlayer(
abDamage, true, false));
else if(TgtCreature[0] == true) abDamage.setBeforePayMana(CardFactoryUtil.input_targetCreature(abDamage));
else if(TgtPlayer[0] == true) abDamage.setBeforePayMana(CardFactoryUtil.input_targetPlayer(abDamage));
card.addSpellAbility(abDamage);
}//!tapCost
if(tapCost) {
final SpellAbility abDamage = new Ability_Tap(card) {
private static final long serialVersionUID = -7960649024757327722L;
private int damage;
public int getNumDamage() {
if(NumDmg[0] != -1) return NumDmg[0];
if(!NumDmgX[0].equals("none")) return CardFactoryUtil.xCount(card, NumDmgX[0]);
return 0;
}
boolean shouldTgtP() {
PlayerZone compHand = AllZone.getZone(Constant.Zone.Hand, Constant.Player.Computer);
CardList hand = new CardList(compHand.getCards());
if(hand.size() >= 7) // anti-discard-at-EOT
return true;
if(AllZone.Human_Life.getLife() < (10 - damage)) // if damage from this spell would drop the human to less than 10 life
return true;
return false;
}
Card chooseTgtC() {
// Combo alert!!
PlayerZone compy = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
CardList cPlay = new CardList(compy.getCards());
if(cPlay.size() > 0) for(int i = 0; i < cPlay.size(); i++)
if(cPlay.get(i).getName().equals("Stuffy Doll")) return cPlay.get(i);
PlayerZone human = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList hPlay = new CardList(human.getCards());
hPlay = hPlay.filter(new CardListFilter() {
public boolean addCard(Card c) {
// will include creatures already dealt damage
return c.isCreature() && ((c.getNetDefense() + c.getDamage()) <= damage)
&& CardFactoryUtil.canTarget(card, c);
}
});
if(hPlay.size() > 0) {
Card best = hPlay.get(0);
if(hPlay.size() > 1) {
for(int i = 1; i < hPlay.size(); i++) {
Card b = hPlay.get(i);
// choose best overall creature?
if(b.getSpellAbility().length > best.getSpellAbility().length
|| b.getKeyword().size() > best.getKeyword().size()
|| b.getNetAttack() > best.getNetAttack()) best = b;
}
}
return best;
}
return null;
}
@Override
public boolean canPlayAI() {
damage = getNumDamage();
boolean na = false;
if(!CardFactoryUtil.AI_doesCreatureAttack(card)) na = true;
if(TgtCP[0] == true) {
if(shouldTgtP() == true) {
setTargetPlayer(Constant.Player.Human);
return na && true;
}
Card c = chooseTgtC();
if(c != null) {
setTargetCard(c);
return na && true;
}
}
if(TgtPlayer[0] == true || TgtOpp[0] == true) {
setTargetPlayer(Constant.Player.Human);
return na && true;
}
if(TgtCreature[0] == true) {
Card c = chooseTgtC();
if(c != null) {
setTargetCard(c);
return na && true;
}
}
return false;
}
@Override
public void resolve() {
int damage = getNumDamage();
String tgtP = "";
if(TgtOpp[0] == true) {
tgtP = AllZone.GameAction.getOpponent(card.getController());
setTargetPlayer(tgtP);
}
Card c = getTargetCard();
if(c != null) {
if(AllZone.GameAction.isCardInPlay(c) && CardFactoryUtil.canTarget(card, c)) {
AllZone.GameAction.addDamage(c, card, damage);
tgtP = c.getController();
}
} else {
tgtP = getTargetPlayer();
AllZone.GameAction.addDamage(tgtP, card, damage);
}
if(!DrawBack[0].equals("none")) CardFactoryUtil.doDrawBack(DrawBack[0], damage,
card.getController(), AllZone.GameAction.getOpponent(card.getController()),
tgtP, card, getTargetCard());
}//resolve()
};//Ability_Tap
abDamage.setDescription(spDesc[0]);
abDamage.setStackDescription(stDesc[0]);
if(TgtCP[0] == true) abDamage.setBeforePayMana(CardFactoryUtil.input_targetCreaturePlayer(
abDamage, true, false));
else if(TgtCreature[0] == true) abDamage.setBeforePayMana(CardFactoryUtil.input_targetCreature(abDamage));
else if(TgtPlayer[0] == true) abDamage.setBeforePayMana(CardFactoryUtil.input_targetPlayer(abDamage));
if(!tapOnlyCost) abDamage.setManaCost(manaCost);
card.addSpellAbility(abDamage);
}//tapCost
}
}
if(hasKeyword(card, "abDamageCP") != -1) {
int n = hasKeyword(card, "abDamageCP");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
String tmpCost = k[0].substring(11);
final int dmg[] = new int[1];
dmg[0] = Integer.parseInt(k[1]);
boolean tapCost = false;
boolean tapOnlyCost = false;
if(tmpCost.contains("T")) {
tapCost = true;
tmpCost = tmpCost.replace("T", "");
tmpCost = tmpCost.trim();
if(tmpCost.length() == 0) tapOnlyCost = true;
}
final String manaCost = tmpCost;
String tempDesc = "";
tempDesc = cardName + " deals " + dmg[0] + " damage to target creature or player.";
final String Desc = tempDesc;
if(!tapCost) {
final SpellAbility ability = new Ability_Activated(card, manaCost) {
private static final long serialVersionUID = -7560349014757367722L;
@Override
public boolean canPlayAI() {
Random r = new Random();
if(r.nextFloat() <= Math.pow(.6667, card.getAbilityUsed())) return true;
else return false;
}
@Override
public void chooseTargetAI() {
CardList list = CardFactoryUtil.AI_getHumanCreature(dmg[0], card, true);
list.shuffle();
if(list.isEmpty() || AllZone.Human_Life.getLife() < 5 + dmg[0]) setTargetPlayer(Constant.Player.Human);
else setTargetCard(list.get(0));
}//chooseTargetAI
@Override
public void resolve() {
if(getTargetCard() != null) {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
if(card.getKeyword().contains("Wither")) getTargetCard().addCounter(
Counters.M1M1, dmg[0]);
else getTargetCard().addDamage(dmg[0], card);
if(card.getKeyword().contains("Lifelink")) GameActionUtil.executeLifeLinkEffects(
card, dmg[0]);
CardList cl = CardFactoryUtil.getAurasEnchanting(card, "Guilty Conscience");
for(Card c:cl) {
GameActionUtil.executeGuiltyConscienceEffects(card, c, dmg[0]);
}
}
} else {
AllZone.GameAction.getPlayerLife(getTargetPlayer()).subtractLife(dmg[0]);
if(card.getKeyword().contains("Lifelink")) GameActionUtil.executeLifeLinkEffects(
card, dmg[0]);
CardList cl = CardFactoryUtil.getAurasEnchanting(card, "Guilty Conscience");
for(Card c:cl) {
GameActionUtil.executeGuiltyConscienceEffects(card, c, dmg[0]);
}
}
}//resolve()
};//Ability_Activated
ability.setDescription(manaCost + ": " + Desc);
ability.setBeforePayMana(CardFactoryUtil.input_targetCreaturePlayer(ability, true, false));
card.addSpellAbility(ability);
}//!tapCost
if(tapOnlyCost == true) {
final Ability_Tap ability = new Ability_Tap(card) {
private static final long serialVersionUID = -7560349014757367722L;
@Override
public void chooseTargetAI() {
CardList list = CardFactoryUtil.AI_getHumanCreature(1, card, true);
list.shuffle();
if(list.isEmpty() || AllZone.Human_Life.getLife() < 5 + dmg[0]) setTargetPlayer(Constant.Player.Human);
else setTargetCard(list.get(0));
}//chooseTargetAI
@Override
public void resolve() {
if(getTargetCard() != null) {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
if(card.getKeyword().contains("Wither")) getTargetCard().addCounter(
Counters.M1M1, dmg[0]);
else getTargetCard().addDamage(dmg[0], card);
if(card.getKeyword().contains("Lifelink")) GameActionUtil.executeLifeLinkEffects(
card, dmg[0]);
CardList cl = CardFactoryUtil.getAurasEnchanting(card, "Guilty Conscience");
for(Card c:cl) {
GameActionUtil.executeGuiltyConscienceEffects(card, c, dmg[0]);
}
}
} else {
AllZone.GameAction.getPlayerLife(getTargetPlayer()).subtractLife(dmg[0]);
if(card.getKeyword().contains("Lifelink")) GameActionUtil.executeLifeLinkEffects(
card, dmg[0]);
CardList cl = CardFactoryUtil.getAurasEnchanting(card, "Guilty Conscience");
for(Card c:cl) {
GameActionUtil.executeGuiltyConscienceEffects(card, c, dmg[0]);
}
card.setDealtDmgToOppThisTurn(true);
}
}//resolve()
};//Ability_Tap
ability.setDescription("tap: " + Desc);
ability.setBeforePayMana(CardFactoryUtil.input_targetCreaturePlayer(ability, true, false));
card.addSpellAbility(ability);
}//tapOnlyCost
if(!tapOnlyCost && tapCost) {
final SpellAbility ability = new Ability_Tap(card, manaCost) {
private static final long serialVersionUID = -7560349014757367722L;
@Override
public void chooseTargetAI() {
CardList list = CardFactoryUtil.AI_getHumanCreature(1, card, true);
list.shuffle();
if(list.isEmpty() || AllZone.Human_Life.getLife() < 5 + dmg[0]) setTargetPlayer(Constant.Player.Human);
else setTargetCard(list.get(0));
}//chooseTargetAI
@Override
public void resolve() {
if(getTargetCard() != null) {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
if(card.getKeyword().contains("Wither")) getTargetCard().addCounter(
Counters.M1M1, dmg[0]);
else getTargetCard().addDamage(dmg[0], card);
if(card.getKeyword().contains("Lifelink")) GameActionUtil.executeLifeLinkEffects(
card, dmg[0]);
CardList cl = CardFactoryUtil.getAurasEnchanting(card, "Guilty Conscience");
for(Card c:cl) {
GameActionUtil.executeGuiltyConscienceEffects(card, c, dmg[0]);
}
}
} else {
AllZone.GameAction.getPlayerLife(getTargetPlayer()).subtractLife(dmg[0]);
if(card.getKeyword().contains("Lifelink")) GameActionUtil.executeLifeLinkEffects(
card, dmg[0]);
CardList cl = CardFactoryUtil.getAurasEnchanting(card, "Guilty Conscience");
for(Card c:cl) {
GameActionUtil.executeGuiltyConscienceEffects(card, c, dmg[0]);
}
card.setDealtDmgToOppThisTurn(true);
}
}//resolve()
};//Ability_Tap
ability.setDescription(manaCost + ", tap: " + Desc);
ability.setBeforePayMana(CardFactoryUtil.input_targetCreaturePlayer(ability, true, false));
card.addSpellAbility(ability);
}//!tapOnlyCost && tapCost
}//n
}//AbDamageCP
/* while (hasKeyword(card, "abTgtPTPump") != -1)
{
int n = hasKeyword(card, "abTgtPTPump");
if (n != -1)
{
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
String pt[] = k[1].split("/");
final int attack[] = new int[1];
final int defense[] = new int[1];
attack[0] = Integer.parseInt(pt[0].replace("+", ""));
defense[0] = Integer.parseInt(pt[1].replace("+", ""));
String tmpCost = k[0].substring(11);
boolean tapCost = false;
boolean tapOnlyCost = false;
if (tmpCost.contains("T"))
{
tapCost = true;
tmpCost = tmpCost.replace("T", "");
tmpCost = tmpCost.trim();
if (tmpCost.length() == 0)
tapOnlyCost = true;
}
final String manaCost = tmpCost;
//System.out.println("manaCost is " + manaCost + " for " + card.getName());
String tmpDesc = "";
tmpDesc = "Target creature gets ";
if (attack[0] > 0)
tmpDesc = tmpDesc + "+" + attack[0];
else
tmpDesc = tmpDesc + attack[0];
tmpDesc = tmpDesc + "/";
if (defense[0] > 0)
tmpDesc = tmpDesc + "+" + defense[0];
else
tmpDesc = tmpDesc + defense[0];
tmpDesc = tmpDesc + " until end of turn.";
final String Desc = tmpDesc;
if (!tapCost)
{
final SpellAbility ability = new Ability_Activated(card, manaCost)
{
private static final long serialVersionUID = -845173064437485113L;
public boolean canPlay()
{
if (CardFactoryUtil.canUseAbility(card) && AllZone.GameAction.isCardInPlay(card) &&
!card.isFaceDown())
return true;
else
return false;
}
public boolean canPlayAI()
{
CardList list = getAttackers();
if (list.isEmpty())
return false;
else
{
if (list.get(0).getNetDefense() + defense[0] < 1)
return false;
Random r = new Random();
if (r.nextFloat() <= Math.pow(.6667, card.getAbilityUsed()))
{
setTargetCard(list.get(0));
return true;
}
else
return false;
}
}//canPlayAI
public CardList getAttackers()
{
Card[] c = ComputerUtil.getAttackers().getAttackers();
CardList list = new CardList(c);
return list;
}//getAttacker
public void resolve()
{
if (AllZone.GameAction.isCardInPlay(getTargetCard()) && CardFactoryUtil.canTarget(card, getTargetCard()))
{
final Card[] creature = new Card[1];
creature[0] = getTargetCard();
creature[0].addTempAttackBoost(attack[0]);
creature[0].addTempDefenseBoost(defense[0]);
card.setAbilityUsed(card.getAbilityUsed()+1);
final Command EOT = new Command()
{
private static final long serialVersionUID = 122944434978198700L;
public void execute()
{
if (AllZone.GameAction.isCardInPlay(creature[0]))
{
creature[0].addTempAttackBoost(-attack[0]);
creature[0].addTempDefenseBoost(-defense[0]);
}
}
};//EOT
AllZone.EndOfTurn.addUntil(EOT);
}
}//resolve
};//ability
ability.setDescription(manaCost+": "+Desc);
ability.setStackDescription(Desc);
ability.setBeforePayMana(CardFactoryUtil.input_targetCreature(ability));
card.addSpellAbility(ability);
}//!tapCost
if (tapOnlyCost)
{
final SpellAbility ability = new Ability_Tap(card)
{
private static final long serialVersionUID = 6723777240105966031L;
public boolean canPlay()
{
boolean sick = true;
if (!card.hasSickness() || !card.isCreature())
sick = false;
if (card.isUntapped() && CardFactoryUtil.canUseAbility(card) &&
AllZone.GameAction.isCardInPlay(card) && !sick && !card.isFaceDown())
return true;
else
return false;
}//canPlay
public boolean canPlayAI()
{
CardList list = getAttackers();
if (list.isEmpty())
return false;
else
if (list.get(0).getNetDefense() + defense[0] < 1)
return false;
if (CardFactoryUtil.AI_doesCreatureAttack(card))
return false;
setTargetCard(list.get(0));
return true;
}//canPlayAI
public CardList getAttackers()
{
Card[] c = ComputerUtil.getAttackers().getAttackers();
CardList list = new CardList(c);
list.remove(card);
return list;
}
public void resolve()
{
if (AllZone.GameAction.isCardInPlay(getTargetCard()) && CardFactoryUtil.canTarget(card, getTargetCard()))
{
final Card[] creature = new Card[1];
creature[0] = getTargetCard();
creature[0].addTempAttackBoost(attack[0]);
creature[0].addTempDefenseBoost(defense[0]);
final Command EOT = new Command()
{
private static final long serialVersionUID = -852905560563053752L;
public void execute()
{
if (AllZone.GameAction.isCardInPlay(creature[0]))
{
creature[0].addTempAttackBoost(-attack[0]);
creature[0].addTempDefenseBoost(-defense[0]);
}
}
};//EOT
AllZone.EndOfTurn.addUntil(EOT);
}
}//resolve
};//ability
ability.setDescription("tap: "+Desc);
ability.setStackDescription(Desc);
ability.setBeforePayMana(CardFactoryUtil.input_targetCreature_NoCost_TapAbility((Ability_Tap)ability));
card.addSpellAbility(ability);
}//tapOnlyCost
if (!tapOnlyCost && tapCost)
{
final SpellAbility ability = new Ability_Tap(card, manaCost)
{
private static final long serialVersionUID = 2749576299299014851L;
public boolean canPlay()
{
boolean sick = true;
if (!card.hasSickness() || !card.isCreature())
sick = false;
if (card.isUntapped() && CardFactoryUtil.canUseAbility(card) &&
AllZone.GameAction.isCardInPlay(card) && !sick && !card.isFaceDown())
return true;
else
return false;
}//canPlay
public boolean canPlayAI()
{
CardList list = getAttackers();
if (list.isEmpty())
return false;
else
if (list.get(0).getNetDefense() + defense[0] < 1)
return false;
if (CardFactoryUtil.AI_doesCreatureAttack(card))
return false;
setTargetCard(list.get(0));
return true;
}//canPlayAI
public CardList getAttackers()
{
Card[] c = ComputerUtil.getAttackers().getAttackers();
CardList list = new CardList(c);
list.remove(card);
return list;
}//getAttackers
public void resolve()
{
if (AllZone.GameAction.isCardInPlay(getTargetCard()) && CardFactoryUtil.canTarget(card, getTargetCard()))
{
final Card[] creature = new Card[1];
creature[0] = getTargetCard();
creature[0].addTempAttackBoost(attack[0]);
creature[0].addTempDefenseBoost(defense[0]);
final Command EOT = new Command()
{
private static final long serialVersionUID = 8179097336678296338L;
public void execute()
{
if (AllZone.GameAction.isCardInPlay(creature[0]))
{
creature[0].addTempAttackBoost(-attack[0]);
creature[0].addTempDefenseBoost(-defense[0]);
}
}
};//EOT
AllZone.EndOfTurn.addUntil(EOT);
}
}//resolve
};//ability
ability.setDescription(manaCost+ ", tap: "+Desc);
ability.setStackDescription(Desc);
ability.setBeforePayMana(CardFactoryUtil.input_targetCreature(ability));
card.addSpellAbility(ability);
}//!tapCost
}
}//while
*/
// Generic destroy target card
if(hasKeyword(card, "spDestroyTgt") != -1) {
int n = hasKeyword(card, "spDestroyTgt");
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
String Targets = k[1]; // Artifact, Creature, Enchantment, Land, Permanent, White, Blue, Black, Red, Green, Colorless, MultiColor
// non-Artifact, non-Creature, non-Enchantment, non-Land, non-Permanent,
//non-White, non-Blue, non-Black, non-Red, non-Green, non-Colorless, non-MultiColor
final String Tgts[] = Targets.split(",");
String tmpDesc = card.getText().substring(15);
int i = tmpDesc.indexOf(".");
tmpDesc = tmpDesc.substring(0, i);
final String Selec = "Select target " + tmpDesc + " to destroy.";
final boolean NoRegen = (k.length == 3);
card.clearSpellAbility();
final SpellAbility spDstryTgt = new Spell(card) {
private static final long serialVersionUID = 142142142142L;
@Override
public boolean canPlayAI() {
CardList results = new CardList();
CardList choices = getTargets();
if(choices.size() > 0) {
for(int i = 0; i < Tgts.length; i++) {
if(Tgts[i].equals("Artifact")) {
if(CardFactoryUtil.AI_getBestArtifact(choices) != null) results.add(CardFactoryUtil.AI_getBestArtifact(choices));
} else if(Tgts[i].equals("Creature")) {
if(CardFactoryUtil.AI_getBestCreature(choices) != null) results.add(CardFactoryUtil.AI_getBestCreature(choices));
} else if(Tgts[i].equals("Enchantment")) {
if(CardFactoryUtil.AI_getBestEnchantment(choices, card, true) != null) results.add(CardFactoryUtil.AI_getBestEnchantment(
choices, card, true));
} else if(Tgts[i].equals("Land")) {
if(CardFactoryUtil.AI_getBestLand(choices) != null) results.add(CardFactoryUtil.AI_getBestLand(choices));
} else if(Tgts[i].equals("Permanent")) {
if(CardFactoryUtil.AI_getMostExpensivePermanent(choices, card, true) != null) results.add(CardFactoryUtil.AI_getMostExpensivePermanent(
choices, card, true));
}
}
}
if(results.size() > 0) {
results.shuffle();
setTargetCard(results.get(0));
return true;
}
return false;
}
CardList getTargets() {
CardList tmpList = new CardList();
tmpList.addAll(AllZone.Human_Play.getCards());
tmpList = tmpList.filter(new CardListFilter() {
public boolean addCard(Card c) {
return (CardFactoryUtil.canTarget(card, c));
}
});
return tmpList.getValidCards(Tgts);
}
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) if(NoRegen) AllZone.GameAction.destroyNoRegeneration(getTargetCard());
else AllZone.GameAction.destroy(getTargetCard());
}
}; //SpDstryTgt
Input InGetTarget = new Input() {
private static final long serialVersionUID = -142142142142L;
@Override
public void showMessage() {
CardList allCards = new CardList();
allCards.addAll(AllZone.Human_Play.getCards());
allCards.addAll(AllZone.Computer_Play.getCards());
allCards.filter(new CardListFilter() {
public boolean addCard(Card c) {
return (CardFactoryUtil.canTarget(card, c));
}
});
CardList choices = allCards.getValidCards(Tgts);
boolean free = false;
if(this.isFree()) free = true;
stopSetNext(CardFactoryUtil.input_targetSpecific(spDstryTgt, choices, Selec, true, free));
}
};//InGetTarget
//card.clearSpellAbility();
spDstryTgt.setBeforePayMana(InGetTarget);
spDstryTgt.setDescription(card.getText());
card.setText("");
card.addSpellAbility(spDstryTgt);
}//spDestroyTgt
while(hasKeyword(card, "abDrawCards") != -1) {
int n = hasKeyword(card, "abDrawCards");
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final boolean Tgt[] = {false};
Tgt[0] = k[0].contains("Tgt");
String tmpCost = "";
if(Tgt[0]) tmpCost = k[0].substring(14);
else tmpCost = k[0].substring(11);
boolean tapCost = false;
boolean tapOnlyCost = false;
if(tmpCost.contains("T")) {
tapCost = true;
tmpCost = tmpCost.replace("T", "");
tmpCost = tmpCost.trim();
if(tmpCost.length() == 0) tapOnlyCost = true;
}
final String manaCost = tmpCost;
final int NumCards[] = {-1};
final String NumCardsX[] = {"none"};
if(k[1].matches("X")) {
String x = card.getSVar(k[1]);
if(x.startsWith("Count$")) {
String kk[] = x.split("\\$");
NumCardsX[0] = kk[1];
}
} else if(k[1].matches("[0-9][0-9]?")) NumCards[0] = Integer.parseInt(k[1]);
// drawbacks and descriptions
final String DrawBack[] = {"none"};
final String spDesc[] = {"none"};
final String stDesc[] = {"none"};
if(k.length > 2) {
if(k[2].contains("Drawback$")) {
String kk[] = k[2].split("\\$");
DrawBack[0] = kk[1];
if(k.length > 3) spDesc[0] = k[3];
if(k.length > 4) stDesc[0] = k[4];
} else {
if(k.length > 2) spDesc[0] = k[2];
if(k.length > 3) stDesc[0] = k[3];
}
}
if(tapOnlyCost == true) spDesc[0] = "Tap: " + spDesc[0];
else if(tapCost == true) spDesc[0] = manaCost + ", tap: " + spDesc[0];
else spDesc[0] = manaCost + ": " + spDesc[0];
if(!tapCost) {
final SpellAbility abDraw = new Ability_Activated(card, manaCost) {
private static final long serialVersionUID = -206739246009089196L;
private int ncards;
public int getNumCards() {
if(NumCards[0] != -1) return NumCards[0];
if(!NumCardsX[0].equals("none")) return CardFactoryUtil.xCount(card, NumCardsX[0]);
return 0;
}
@Override
public boolean canPlayAI() {
ncards = getNumCards();
int h = AllZone.getZone(Constant.Zone.Hand, Constant.Player.Computer).size();
int hl = AllZone.getZone(Constant.Zone.Library, Constant.Player.Human).size();
int cl = AllZone.getZone(Constant.Zone.Library, Constant.Player.Computer).size();
Random r = new Random();
// prevent run-away activations - first time will always return true
boolean rr = false;
if(r.nextFloat() <= Math.pow(.6667, card.getAbilityUsed())) rr = true;
if(((hl - ncards) < 2) && Tgt[0]) // attempt to deck the human
{
setTargetPlayer(Constant.Player.Human);
return true && rr;
}
if(((h + ncards) <= 7) && !((cl - ncards) < 1) && (r.nextInt(10) > 4)) {
setTargetPlayer(Constant.Player.Computer);
return true && rr;
}
return false;
}
@Override
public void resolve() {
ncards = getNumCards();
String TgtPlayer = card.getController();
if(Tgt[0]) TgtPlayer = getTargetPlayer();
for(int i = 0; i < ncards; i++)
AllZone.GameAction.drawCard(TgtPlayer);
if(!DrawBack[0].equals("none")) CardFactoryUtil.doDrawBack(DrawBack[0], ncards,
card.getController(), AllZone.GameAction.getOpponent(card.getController()),
TgtPlayer, card, null);
}
};
abDraw.setDescription(spDesc[0]);
abDraw.setStackDescription(stDesc[0]);
if(Tgt[0] == true) abDraw.setBeforePayMana(CardFactoryUtil.input_targetPlayer(abDraw));
card.addSpellAbility(abDraw);
}//!tapCost
if(tapCost) {
final SpellAbility abDraw = new Ability_Tap(card) {
private static final long serialVersionUID = -2149577241283487990L;
private int ncards;
public int getNumCards() {
if(NumCards[0] != -1) return NumCards[0];
if(!NumCardsX[0].equals("none")) return CardFactoryUtil.xCount(card, NumCardsX[0]);
return 0;
}
@Override
public boolean canPlayAI() {
ncards = getNumCards();
int h = AllZone.getZone(Constant.Zone.Hand, Constant.Player.Computer).size();
int hl = AllZone.getZone(Constant.Zone.Library, Constant.Player.Human).size();
int cl = AllZone.getZone(Constant.Zone.Library, Constant.Player.Computer).size();
Random r = new Random();
if(((hl - ncards) < 2) && Tgt[0]) // attempt to deck the human if possible
{
setTargetPlayer(Constant.Player.Human);
return true;
}
if(((h + ncards) <= 7) && !((cl - ncards) < 1) && (r.nextInt(10) > 4)) {
setTargetPlayer(Constant.Player.Computer);
return true;
}
return false;
}
@Override
public void resolve() {
ncards = getNumCards();
String TgtPlayer = card.getController();
if(Tgt[0]) TgtPlayer = getTargetPlayer();
for(int i = 0; i < ncards; i++)
AllZone.GameAction.drawCard(TgtPlayer);
if(!DrawBack[0].equals("none")) CardFactoryUtil.doDrawBack(DrawBack[0], ncards,
card.getController(), AllZone.GameAction.getOpponent(card.getController()),
TgtPlayer, card, null);
}
};
abDraw.setDescription(spDesc[0]);
abDraw.setStackDescription(stDesc[0]);
if(!tapOnlyCost) abDraw.setManaCost(manaCost);
if(Tgt[0] == true) abDraw.setBeforePayMana(CardFactoryUtil.input_targetPlayer(abDraw));
card.addSpellAbility(abDraw);
}//tapCost
}
if(hasKeyword(card, "spDrawCards") != -1) {
int n = hasKeyword(card, "spDrawCards");
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final boolean Tgt[] = {false};
Tgt[0] = k[0].contains("Tgt");
final int NumCards[] = {-1};
final String NumCardsX[] = {"none"};
if(k[1].matches("X")) {
String x = card.getSVar(k[1]);
if(x.startsWith("Count$")) {
String kk[] = x.split("\\$");
NumCardsX[0] = kk[1];
}
} else if(k[1].matches("[0-9][0-9]?")) NumCards[0] = Integer.parseInt(k[1]);
// drawbacks and descriptions
final String DrawBack[] = {"none"};
final String spDesc[] = {"none"};
final String stDesc[] = {"none"};
if(k.length > 2) {
if(k[2].contains("Drawback$")) {
String kk[] = k[2].split("\\$");
DrawBack[0] = kk[1];
if(k.length > 3) spDesc[0] = k[3];
if(k.length > 4) stDesc[0] = k[4];
} else {
if(k.length > 2) spDesc[0] = k[2];
if(k.length > 3) stDesc[0] = k[3];
}
}
final SpellAbility spDraw = new Spell(card) {
private static final long serialVersionUID = -7049779241008089696L;
private int ncards;
public int getNumCards() {
if(NumCards[0] != -1) return NumCards[0];
if(!NumCardsX[0].equals("none")) return CardFactoryUtil.xCount(card, NumCardsX[0]);
return 0;
}
@Override
public boolean canPlayAI() {
ncards = getNumCards();
int h = AllZone.getZone(Constant.Zone.Hand, Constant.Player.Computer).size();
int hl = AllZone.getZone(Constant.Zone.Library, Constant.Player.Human).size();
int cl = AllZone.getZone(Constant.Zone.Library, Constant.Player.Computer).size();
Random r = new Random();
if(((hl - ncards) < 2) && Tgt[0]) // attempt to deck the human if possible
{
setTargetPlayer(Constant.Player.Human);
return true;
}
if(((h + ncards) <= 7) && !((cl - ncards) < 1) && (r.nextInt(10) > 4)) {
setTargetPlayer(Constant.Player.Computer);
return true;
}
return false;
}
@Override
public void resolve() {
ncards = getNumCards();
String TgtPlayer = card.getController();
if(Tgt[0]) TgtPlayer = getTargetPlayer();
for(int i = 0; i < ncards; i++)
AllZone.GameAction.drawCard(TgtPlayer);
if(!DrawBack[0].equals("none")) CardFactoryUtil.doDrawBack(DrawBack[0], ncards,
card.getController(), AllZone.GameAction.getOpponent(card.getController()), TgtPlayer,
card, null);
}
};
if(Tgt[0]) spDraw.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spDraw));
if(!spDesc[0].equals("none")) spDraw.setDescription(spDesc[0]);
else spDraw.setDescription("Draw " + NumCards[0] + " cards.");
if(!stDesc[0].equals("none")) spDraw.setStackDescription(stDesc[0]);
else spDraw.setStackDescription("You draw " + NumCards[0] + " cards.");
card.clearSpellAbility();
card.addSpellAbility(spDraw);
}//spDrawCards
//Spell gain life lose life cards (like Soul Feast)
if(hasKeyword(card, "spLoseLifeGainLife") != -1) {
int n = hasKeyword(card, "spLoseLifeGainLife");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final String lfdmg = k[1];
final String spDesc[] = {"none"};
final String stDesc[] = {"none"};
if(k.length > 2) spDesc[0] = k[2];
if(k.length > 3) stDesc[0] = k[3];
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -8361697584661592092L;
@Override
public void resolve() {
final int n = Integer.parseInt(lfdmg);
AllZone.GameAction.getPlayerLife(getTargetPlayer()).subtractLife(n);
PlayerLife life = AllZone.GameAction.getPlayerLife(card.getController());
life.addLife(n);
}//resolve()
};//SpellAbility
spell.setChooseTargetAI(CardFactoryUtil.AI_targetHuman());
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
if(spDesc[0].equals("none")) // create the card description
{
spDesc[0] = ("Target player loses " + lfdmg + " life and you gain " + lfdmg + " life.");
}
if(stDesc[0].equals("none")) // create the card stack description
{
stDesc[0] = (card.getName() + " - target loses life and you gain life.");
}
spell.setDescription(spDesc[0]);
spell.setStackDescription(stDesc[0]);
card.clearSpellAbility();
card.addSpellAbility(spell);
if(cardName.equals("Absorb Vis")) {
card.addSpellAbility(CardFactoryUtil.ability_typecycle(card, "1 B", "Basic"));
}
return card;
}
}// spLoseLifeGainLife
if(hasKeyword(card, "SearchRebel") != -1) {
int n = hasKeyword(card, "SearchRebel");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final String manacost = k[1];
card.addSpellAbility(CardFactoryUtil.ability_Rebel_Search(card, manacost));
}
}//Rebel search
if(hasKeyword(card, "SearchMerc") != -1) {
int n = hasKeyword(card, "SearchMerc");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final String manacost = k[1];
card.addSpellAbility(CardFactoryUtil.ability_Merc_Search(card, manacost));
}
}//Merc search
if(hasKeyword(card, "Morph") != -1) {
int n = hasKeyword(card, "Morph");
if(n != -1) {
card.setPrevIntrinsicKeyword(card.getIntrinsicKeyword());
card.setPrevType(card.getType());
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final String manacost = k[1];
int attack = card.getBaseAttack();
int defense = card.getBaseDefense();
String orgManaCost = card.getManaCost();
card.addSpellAbility(CardFactoryUtil.ability_Morph_Up(card, manacost, orgManaCost, attack, defense));
card.addSpellAbility(CardFactoryUtil.ability_Morph_Down(card));
}
}//Morph
if(hasKeyword(card, "Flashback") != -1) {
int n = hasKeyword(card, "Flashback");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
//card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final String manacost = k[1];
card.addSpellAbility(CardFactoryUtil.ability_Flashback(card, manacost, "0"));
}
}//flashback
if(hasKeyword(card, "Devour") != -1) {
int n = hasKeyword(card, "Devour");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final String magnitude = k[1];
final int multiplier = Integer.parseInt(magnitude);
//final String player = card.getController();
final int[] numCreatures = new int[1];
final SpellAbility devour = new Spell(card) {
private static final long serialVersionUID = 4888189840817163900L;
@Override
public void resolve() {
int totalCounters = numCreatures[0] * multiplier;
card.addCounter(Counters.P1P1, totalCounters);
if(card.getName().equals("Skullmulcher")) {
for(int i = 0; i < numCreatures[0]; i++) {
AllZone.GameAction.drawCard(card.getController());
}
} else if(card.getName().equals("Caldera Hellion")) {
PlayerZone hPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
PlayerZone cPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
CardList creatures = new CardList();
creatures.addAll(hPlay.getCards());
creatures.addAll(cPlay.getCards());
creatures = creatures.getType("Creature");
for(int i = 0; i < creatures.size(); i++) {
Card crd = creatures.get(i);
if(CardFactoryUtil.canDamage(card, crd)) crd.addDamage(3, card);
}
}
}
@Override
public boolean canPlay() {
return AllZone.Phase.getActivePlayer().equals(card.getController()) && card.isFaceDown()
&& !AllZone.Phase.getPhase().equals("End of Turn")
&& AllZone.GameAction.isCardInPlay(card);
}
};//devour
Command intoPlay = new Command() {
private static final long serialVersionUID = -7530312713496897814L;
public void execute() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList creats = new CardList(play.getCards());
creats = creats.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isCreature() && !c.equals(card);
}
});
//System.out.println("Creats size: " + creats.size());
if(card.getController().equals(Constant.Player.Human)) {
if (creats.size() > 0)
{
List<Card> selection = AllZone.Display.getChoices("Select creatures to sacrifice", creats.toArray());
numCreatures[0] = selection.size();
for(int m = 0; m < selection.size(); m++) {
AllZone.GameAction.sacrifice(selection.get(m));
}
}
}//human
else {
int count = 0;
for(int i = 0; i < creats.size(); i++) {
Card c = creats.get(i);
if(c.getNetAttack() <= 1 && c.getNetDefense() <= 2) {
AllZone.GameAction.sacrifice(c);
count++;
}
//is this needed?
AllZone.Computer_Play.updateObservers();
}
numCreatures[0] = count;
}
AllZone.Stack.add(devour);
}
};
devour.setStackDescription(card.getName() + " - gets " + magnitude
+ " +1/+1 counter(s) per devoured creature.");
devour.setDescription("Devour " + magnitude);
card.addSpellAbility(devour);
card.addComesIntoPlayCommand(intoPlay);
//card.addSpellAbility(CardFactoryUtil.ability_Devour(card, magnitude));
}
}//Devour
while(hasKeyword(card, "Modular") != -1) {
int n = hasKeyword(card, "Modular");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
final int m = Integer.parseInt(parse.substring(8));
String t = card.getSpellText();
if(!t.equals("")) t += "\r\n";
card.setText(t
+ parse
+ " (This enters the battlefield with "
+ m
+ " +1/+1 counters on it. When it's put into a graveyard, you may put its +1/+1 counters on target artifact creature.)");//Erm help? Isn't there a normal way to do this?...
card.addComesIntoPlayCommand(new Command() {
private static final long serialVersionUID = 339412525059881775L;
public void execute() {
card.addCounter(Counters.P1P1, m);
}
});
final SpellAbility ability = new Ability(card, "0") {
@Override
public void resolve() {
if(card.getController().equals(Constant.Player.Computer)) {
CardList choices = new CardList(AllZone.Computer_Play.getCards()).filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isCreature() && c.isArtifact();
}
});
if(choices.size() != 0) CardFactoryUtil.AI_getBestCreature(choices).addCounter(
Counters.P1P1, getSourceCard().getCounters(Counters.P1P1));
} else {
final SpellAbility ability = this;
AllZone.InputControl.setInput(new Input() {
private static final long serialVersionUID = 2322926875771867901L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target artifact creature");
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card card2, PlayerZone zone) {
if(card2.isCreature() && card2.isArtifact() && zone.is(Constant.Zone.Play)
&& CardFactoryUtil.canTarget(ability, card)) {
card2.addCounter(Counters.P1P1, ability.getSourceCard().getCounters(
Counters.P1P1));//combining input and resolve is skirting rules and hacky at best, but non-stackability of destroyCommand Inputs turns into a major problem when the keyword is mainly used during the simultaneous destruction of combat.
stop();
}
}
});
}//else
}//resolve()
};
card.addDestroyCommand(new Command() {
private static final long serialVersionUID = 304026662487997331L;
public void execute() {
ability.setStackDescription("Put " + card.getCounters(Counters.P1P1)
+ " +1/+1 counter/s from " + card + " on target artifact creature.");
AllZone.Stack.push(ability);
}
});
}
}//while shouldModular
if(hasKeyword(card, "1, Sacrifice " + card.getName() + ": Draw a card.") != -1) {
int n = hasKeyword(card, "1, Sacrifice " + card.getName() + ": Draw a card.");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
card.addSpellAbility(CardFactoryUtil.ability_Spellbomb(card));
}
}//Spellbomb
// Generic target creature pump
if(hasKeyword(card, "spPumpTgt") != -1) {
int n = hasKeyword(card, "spPumpTgt");
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final int NumAttack[] = {-1138};
final String AttackX[] = {"none"};
final int NumDefense[] = {-1138};
final String DefenseX[] = {"none"};
final String Keyword[] = {"none"};
String ptk[] = k[1].split("/");
if(ptk.length == 1) Keyword[0] = ptk[0];
if(ptk.length >= 2) {
if(ptk[0].matches("[\\+\\-][XY]")) {
String xy = card.getSVar(ptk[0].replaceAll("[\\+\\-]", ""));
if(xy.startsWith("Count$")) {
String kk[] = xy.split("\\$");
AttackX[0] = kk[1];
if(ptk[0].contains("-")) if(AttackX[0].contains("/")) AttackX[0] = AttackX[0].replace("/",
"/Negative");
else AttackX[0] += "/Negative";
}
} else if(ptk[0].matches("[\\+\\-][0-9]")) NumAttack[0] = Integer.parseInt(ptk[0].replace("+", ""));
if(ptk[1].matches("[\\+\\-][XY]")) {
String xy = card.getSVar(ptk[1].replaceAll("[\\+\\-]", ""));
if(xy.startsWith("Count$")) {
String kk[] = xy.split("\\$");
DefenseX[0] = kk[1];
if(ptk[1].contains("-")) if(DefenseX[0].contains("/")) DefenseX[0] = DefenseX[0].replace(
"/", "/Negative");
else DefenseX[0] += "/Negative";
}
} else if(ptk[1].matches("[\\+\\-][0-9]")) NumDefense[0] = Integer.parseInt(ptk[1].replace("+", ""));
}
if(ptk.length == 3) Keyword[0] = ptk[2];
final String DrawBack[] = {"none"};
final String spDesc[] = {"none"};
final String stDesc[] = {"none"};
//String d = new String("none");
StringBuilder sb = new StringBuilder();
if((AttackX[0].equals("none") && !(NumAttack[0] == -1138))
&& (DefenseX[0].equals("none") && !(NumDefense[0] == -1138)) && Keyword[0].equals("none")) {
// pt boost
sb.append("Target creature gets ");
if(NumAttack[0] > 0 || (NumAttack[0] == 0 && NumDefense[0] > 0)) // +0/+1
sb.append("+");
else if(NumAttack[0] < 0 || (NumAttack[0] == 0 && NumDefense[0] < 0)) // -0/-1
sb.append("-");
sb.append(Math.abs(NumAttack[0]) + "/");
if(NumDefense[0] > 0 || (NumDefense[0] == 0 && NumAttack[0] > 0)) // +1/+0
sb.append("+");
else if(NumDefense[0] < 0 || (NumDefense[0] == 0 && NumAttack[0] < 0)) // -1/-0
sb.append("-");
sb.append(Math.abs(NumDefense[0]) + " until end of turn.");
}
if((AttackX[0].equals("none") && NumAttack[0] == -1138)
&& (DefenseX[0].equals("none") && NumDefense[0] == -1138) && !Keyword[0].equals("none")) {
// k boost
sb.append("Target creature gains " + Keyword[0] + " until end of turn.");
}
if((AttackX[0].equals("none") && !(NumAttack[0] == -1138))
&& (DefenseX[0].equals("none") && !(NumDefense[0] == -1138)) && !Keyword[0].equals("none")) {
// ptk boost
sb.append("Target creature gets ");
if(NumAttack[0] > 0 || (NumAttack[0] == 0 && NumDefense[0] > 0)) // +0/+1
sb.append("+");
else if(NumAttack[0] < 0 || (NumAttack[0] == 0 && NumDefense[0] < 0)) // -0/-1
sb.append("-");
sb.append(Math.abs(NumAttack[0]) + "/");
if(NumDefense[0] > 0 || (NumDefense[0] == 0 && NumAttack[0] > 0)) // +1/+0
sb.append("+");
else if(NumDefense[0] < 0 || (NumDefense[0] == 0 && NumAttack[0] < 0)) // -1/-0
sb.append("-");
sb.append(Math.abs(NumDefense[0]));
sb.append(" and gains " + Keyword[0] + " until end of turn.");
}
if(k.length > 2) {
if(k[2].contains("Drawback$")) {
String kk[] = k[2].split("\\$");
DrawBack[0] = kk[1];
if(k.length > 3) spDesc[0] = k[3];
if(k.length > 4) stDesc[0] = k[4];
} else {
if(k.length > 2) spDesc[0] = k[2];
if(k.length > 3) stDesc[0] = k[3];
}
} else if(!sb.toString().equals("none")) {
spDesc[0] = sb.toString();
stDesc[0] = sb.toString();
}
SpellAbility spPump = new Spell(card) {
private static final long serialVersionUID = 42244224L;
private int getNumAttack() {
if(NumAttack[0] != -1138) return NumAttack[0];
if(!AttackX[0].equals("none")) return CardFactoryUtil.xCount(card, AttackX[0]);
return 0;
}
private int getNumDefense() {
if(NumDefense[0] != -1138) return NumDefense[0];
if(!DefenseX[0].equals("none")) return CardFactoryUtil.xCount(card, DefenseX[0]);
return 0;
}
@Override
public boolean canPlayAI() {
int defense = getNumDefense();
if(AllZone.Phase.getPhase().equals(Constant.Phase.Main2)) return false;
CardList list = getCreatures();
if(!list.isEmpty()) {
boolean goodt = false;
Card t = new Card();
while(goodt == false && !list.isEmpty()) {
t = CardFactoryUtil.AI_getBestCreature(list);
if((t.getNetDefense() + defense) > 0) goodt = true;
else list.remove(t);
}
if(goodt == true) {
setTargetCard(t);
return true;
}
}
return false;
}
CardList getCreatures() {
CardList list = new CardList(AllZone.Computer_Play.getCards());
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
if(c.isCreature()) {
if(c.hasSickness() && Keyword[0].equals("Haste")) return CardFactoryUtil.canTarget(
card, c);
return (CardFactoryUtil.AI_doesCreatureAttack(c))
&& (CardFactoryUtil.canTarget(card, c))
&& (!Keyword[0].equals("none") && !c.getKeyword().contains(Keyword[0]))
&& (!(!c.hasSickness()) && Keyword[0].equals("Haste"));
}
return false;
}
});
return list;
}
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
final Card[] creature = new Card[1];
creature[0] = getTargetCard();
final int a = getNumAttack();
final int d = getNumDefense();
final Command untilEOT = new Command() {
private static final long serialVersionUID = -42244224L;
public void execute() {
if(AllZone.GameAction.isCardInPlay(creature[0])) {
creature[0].addTempAttackBoost(-1 * a);
creature[0].addTempDefenseBoost(-1 * d);
if(!Keyword[0].equals("none")) creature[0].removeExtrinsicKeyword(Keyword[0]);
}
}
};
creature[0].addTempAttackBoost(a);
creature[0].addTempDefenseBoost(d);
if(!Keyword[0].equals("none")) creature[0].addExtrinsicKeyword(Keyword[0]);
AllZone.EndOfTurn.addUntil(untilEOT);
if(!DrawBack[0].equals("none")) CardFactoryUtil.doDrawBack(DrawBack[0], 0,
card.getController(), AllZone.GameAction.getOpponent(card.getController()),
creature[0].getController(), card, creature[0]);
}
}//resolve
};//SpellAbility
spPump.setBeforePayMana(CardFactoryUtil.input_targetCreature(spPump));
spPump.setDescription(spDesc[0]);
spPump.setStackDescription(stDesc[0]);
card.clearSpellAbility();
card.addSpellAbility(spPump);
}
if(hasKeyword(card, "spRaiseDead") != -1) {
int n = hasKeyword(card, "spRaiseDead");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":"); // charm descriptions will appear at k[2] and k[3]
final String kk[] = k[1].split("/"); // numCreatures = kk[0], other fields = kk[1] through kk[2]
int numFieldsKK = kk.length;
final int numCreatures = Integer.parseInt(kk[0]);
boolean quantifier = false;
String tmpTgt = "Creature";
for(int i = 2; i <= numFieldsKK; i++) {
if(kk[(i - 1)].equals("Some")) {
quantifier = true;
} else // can only be a specific creature type at his time, Goblin for goblin creatures and Tarfire
{
tmpTgt = kk[i - 1];
}
}
final String targetTypeToReturn = tmpTgt;
final boolean weReturnUpTo = quantifier;
final String spDesc[] = {"none"};
final String stDesc[] = {"none"};
if(k.length > 2) spDesc[0] = k[2];
if(k.length > 3) stDesc[0] = k[3];
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 6938982619919149188L;
@Override
public boolean canPlayAI() {
return getGraveCreatures().size() >= numCreatures;
}
CardList targets;
@Override
public void chooseTargetAI() {
CardList grave = getGraveCreatures();
targets = new CardList();
if(targetTypeToReturn.equals("Creature")) {
for(int i = 0; i < numCreatures; i++) {
Card c = CardFactoryUtil.AI_getBestCreature(grave);
targets.add(c);
grave.remove(c);
}
} else // this is for returning Goblins and Tarfire (and Changelings ?)
{
for(int i = 0; i < numCreatures; i++) {
Card c = CardFactoryUtil.getRandomCard(grave); // getRandomCard(grave);
targets.add(c);
grave.remove(c);
}
}
}
@Override
public void resolve() {
if(card.getController().equals(Constant.Player.Human)) {
CardList grave = getGraveCreatures();
targets = new CardList();
if(weReturnUpTo) // this is for spells which state Return up to X target creature card
{
for(int i = 0; i < numCreatures; i++) {
Card c = AllZone.Display.getChoiceOptional("Select card", grave.toArray());
targets.add(c);
grave.remove(c);
}
}
else if(grave.size() > numCreatures) // this is for spells which state Return target creature card
for(int i = 0; i < numCreatures; i++) {
Card c = AllZone.Display.getChoice("Select card", grave.toArray());
targets.add(c);
grave.remove(c);
}
else targets = grave;
}
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, card.getController());
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
for(Card c:targets)
if(AllZone.GameAction.isCardInZone(c, grave)) AllZone.GameAction.moveTo(hand, c);
}//resolve()
@Override
public boolean canPlay() {
return getGraveCreatures().size() >= numCreatures;
}
CardList getGraveCreatures() {
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, card.getController());
CardList list = new CardList(grave.getCards());
String cardController = card.getController();
if(cardController.equals("Human") || (cardController.equals("Computer"))
&& (targetTypeToReturn.equals("Creature"))) {
list = list.getType(targetTypeToReturn);
} else // prevent the computer from using a Boggart Birth Rite to return a Boggart Birth Rite
{
CardList tempList = new CardList(grave.getCards());
tempList = list.getType(targetTypeToReturn);
list = new CardList();
for(int i = 0; i < tempList.size(); i++) {
if(!cardName.equals(tempList.get(i).getName())) {
list.add(tempList.get(i));
}
}
}
return list;
}
};//SpellAbility
if(spDesc[0].equals("none")) // create the card descriptiopn
{
spDesc[0] = ("Return ");
if(weReturnUpTo) {
spDesc[0] = (spDesc[0] + "up to ");
}
if(numCreatures > 1) {
spDesc[0] = (spDesc[0] + numCreatures + " ");
}
spDesc[0] = (spDesc[0] + "target ");
if(targetTypeToReturn.equals("Creature")) {
spDesc[0] = (spDesc[0] + "creature");
} else {
spDesc[0] = (spDesc[0] + targetTypeToReturn);
}
if(numCreatures > 1) {
spDesc[0] = (spDesc[0] + "s");
}
spDesc[0] = (spDesc[0] + " card");
if(numCreatures > 1) {
spDesc[0] = (spDesc[0] + "s");
}
spDesc[0] = (spDesc[0] + " from your graveyard to your hand.");
}
if(stDesc[0].equals("none")) // create the card stack descriptiopn
{
stDesc[0] = (card.getName() + " - returns target card");
if(numCreatures > 1) {
stDesc[0] = (stDesc[0] + "s");
}
stDesc[0] = (stDesc[0] + " from " + card.getController() + "'s graveyard to "
+ card.getController() + "'s hand.");
}
spell.setDescription(spDesc[0]);
spell.setStackDescription(stDesc[0]);
card.clearSpellAbility();
card.addSpellAbility(spell);
}
}// spRaiseDead
while(shouldManaAbility(card) != -1) {
int n = shouldManaAbility(card);
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
final Ability_Mana ability = new Ability_Mana(card, parse) {
private static final long serialVersionUID = -113811381138L;
@Override
public boolean canPlayAI() {
return false;
}
};
//ability.setDescription(parse);
card.addSpellAbility(ability);
}
}
////////////////////////////////////////////////////////////////
if(card.getKeyword().contains("When this card comes into play, draw a card.")) {
final SpellAbility ability = new Ability(card, "0") {
@Override
public void resolve() {
AllZone.GameAction.drawCard(card.getController());
}//resolve()
};//SpellAbility
Command intoPlay = new Command() {
private static final long serialVersionUID = 1707519783018941582L;
public void execute() {
ability.setStackDescription(card.getName() + " - " + card.getController() + " draws a card.");
AllZone.Stack.add(ability);
}
};
card.addComesIntoPlayCommand(intoPlay);
}//end if
//******************************************************************
//************** Link to different CardFactories *******************
if(card.getType().contains("Creature")) {
Card card2 = new Card();
card2 = CardFactory_Creatures.getCard(card, cardName, owner, this);
return card2;
} else if(card.getType().contains("Aura")) {
Card card2 = new Card();
card2 = CardFactory_Auras.getCard(card, cardName, owner);
return card2;
} else if(card.getType().contains("Equipment")) {
Card card2 = new Card();
card2 = CardFactory_Equipment.getCard(card, cardName, owner);
return card2;
} else if(card.getType().contains("Planeswalker")) {
Card card2 = new Card();
card2 = CardFactory_Planeswalkers.getCard(card, cardName, owner);
return card2;
} else if(card.getType().contains("Land")) {
Card card2 = new Card();
card2 = CardFactory_Lands.getCard(card, cardName, owner);
return card2;
}
//*************** START *********** START **************************
if(cardName.equals("Burst of Speed") || cardName.equals("Chorus of Woe")
|| cardName.equals("Dance of Shadows") || cardName.equals("Desperate Charge")
|| cardName.equals("Glorious Charge") || cardName.equals("Kjeldoran War Cry")
|| cardName.equals("Magnify") || cardName.equals("Nature's Cloak")
|| cardName.equals("Nocturnal Raid") || cardName.equals("Overrun")
|| cardName.equals("Path of Anger's Flame") || cardName.equals("Resuscitate")
|| cardName.equals("Righteous Charge") || cardName.equals("Scare Tactics")
|| cardName.equals("Shield Wall") || cardName.equals("Solidarity")
|| cardName.equals("Steadfastness") || cardName.equals("Tortoise Formation")
|| cardName.equals("Tromp the Domains") || cardName.equals("Valorous Charge")
|| cardName.equals("Virtuous Charge") || cardName.equals("Vitalizing Wind")
|| cardName.equals("Warrior's Charge") || cardName.equals("Warrior's Honor")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -5844664906503221006L;
@Override
public boolean canPlayAI() {
return getAttacker() != null;
}
public Card getAttacker() {
//target creatures that is going to attack
Combat c = ComputerUtil.getAttackers();
Card[] att = c.getAttackers();
if(cardName.equals("Dance of Shadows") || cardName.equals("Overrun")
|| cardName.equals("Tromp the Domains")) {
if(att.length > 2) // Effect best used with a few creatures
return att[0];
else return null;
}
if(cardName.equals("Burst of Speed") || cardName.equals("Chorus of Woe")
|| cardName.equals("Desperate Charge") || cardName.equals("Glorious Charge")
|| cardName.equals("Kjeldoran War Cry") || cardName.equals("Magnify")
|| cardName.equals("Nature's Cloak") || cardName.equals("Nocturnal Raid")
|| cardName.equals("Path of Anger's Flame") || cardName.equals("Resuscitate")
|| cardName.equals("Righteous Charge") || cardName.equals("Scare Tactics")
|| cardName.equals("Shield Wall") || cardName.equals("Solidarity")
|| cardName.equals("Steadfastness") || cardName.equals("Tortoise Formation")
|| cardName.equals("Valorous Charge") || cardName.equals("Vitalizing Wind")
|| cardName.equals("Virtuous Charge") || cardName.equals("Warrior's Charge")
|| cardName.equals("Warrior's Honor")) {
if(att.length > 1) // Effect best used on at least a couple creatures
return att[0];
else return null;
}
return null;
}//getAttacker()
int getPowerBoost() {
if(cardName.equals("Tromp the Domains")) return getTtDBoost();
if(cardName.equals("Kjeldoran War Cry")) return getKWCBoost();
if(cardName.equals("Chorus of Woe") || cardName.equals("Dance of Shadows")
|| cardName.equals("Glorious Charge") || cardName.equals("Magnify")
|| cardName.equals("Scare Tactics") || cardName.equals("Virtuous Charge")
|| cardName.equals("Warrior's Charge") || cardName.equals("Warrior's Honor")) return 1;
if(cardName.equals("Desperate Charge") || cardName.equals("Nocturnal Raid")
|| cardName.equals("Path of Anger's Flame") || cardName.equals("Righteous Charge")
|| cardName.equals("Valorous Charge")) return 2;
if(cardName.equals("Overrun")) return 3;
if(cardName.equals("Vitalizing Wind")) return 7;
return 0;
}//getPowerBoost()
int getToughBoost() {
if(cardName.equals("Tromp the Domains")) return getTtDBoost();
if(cardName.equals("Kjeldoran War Cry")) return getKWCBoost();
if(cardName.equals("Glorious Charge") || cardName.equals("Magnify")
|| cardName.equals("Virtuous Charge") || cardName.equals("Warrior's Charge")
|| cardName.equals("Warrior's Honor")) return 1;
if(cardName.equals("Righteous Charge") || cardName.equals("Shield Wall")) return 2;
if(cardName.equals("Overrun") || cardName.equals("Steadfastness")) return 3;
if(cardName.equals("Solidarity")) return 5;
if(cardName.equals("Vitalizing Wind")) return 7;
return 0;
}//getToughBoost()
String getKeywordBoost() {
if(cardName.equals("Burst of Speed")) return "Haste";
if(cardName.equals("Overrun") || cardName.equals("Tromp the Domains")) return "Trample";
if(cardName.equals("Dance of Shadows")) return "Fear";
if(cardName.equals("Nature's Cloak")) return "Forestwalk";
if(cardName.equals("Resuscitate")) return "RegenerateMe:1";
if(cardName.equals("Tortoise Formation")) return "Shroud";
return "None";
}//getKeywordBoost()
int getTtDBoost() // Tromp the Domains - +1/+1 for each basic land you control
{
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList land = new CardList(play.getCards());
String basic[] = {"Forest", "Plains", "Mountain", "Island", "Swamp"};
int count = 0;
for(int i = 0; i < basic.length; i++) {
CardList c = land.getType(basic[i]);
if(!c.isEmpty()) count++;
}
return count;
}//getTtDBoost
int getKWCBoost() // Kjeldoran War Cry - +X/+X, X = 1 + Num(KWC in All Graveyards)
{
PlayerZone hYard = AllZone.getZone(Constant.Zone.Graveyard, Constant.Player.Human);
PlayerZone cYard = AllZone.getZone(Constant.Zone.Graveyard, Constant.Player.Computer);
CardList allYards = new CardList();
allYards.addAll(hYard.getCards());
allYards.addAll(cYard.getCards());
allYards = allYards.getName("Kjeldoran War Cry");
return allYards.size() + 1;
}//getKWCBoost
@Override
public void resolve() {
final int pboost = getPowerBoost();
final int tboost = getToughBoost();
final String kboost = getKeywordBoost();
CardList list = new CardList();
if(cardName.equals("Burst of Speed")
|| // Creatures "you" Control
cardName.equals("Chorus of Woe") || cardName.equals("Dance of Shadows")
|| cardName.equals("Desperate Charge") || cardName.equals("Glorious Charge")
|| cardName.equals("Kjeldoran War Cry") || cardName.equals("Nature's Cloak")
|| cardName.equals("Overrun") || cardName.equals("Path of Anger's Flame")
|| cardName.equals("Resuscitate") || cardName.equals("Righteous Charge")
|| cardName.equals("Scare Tactics") || cardName.equals("Shield Wall")
|| cardName.equals("Solidarity") || cardName.equals("Steadfastness")
|| cardName.equals("Tortoise Formation") || cardName.equals("Virtuous Charge")
|| cardName.equals("Vitalizing Wind") || cardName.equals("Warrior's Charge")
|| cardName.equals("Warrior's Honor")) {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
list.addAll(play.getCards());
if(cardName.equals("Nature's Cloak")) list = list.getColor("G");
}
if(cardName.equals("Magnify") || // All Creatures in Play
cardName.equals("Nocturnal Raid") || // All Black Creatures in Play
cardName.equals("Valorous Charge")) // All White Creatures in Play
{
PlayerZone human = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
PlayerZone comp = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
list.addAll(human.getCards());
list.addAll(comp.getCards());
if(cardName.equals("Nocturnal Raid")) list = list.getColor("B");
if(cardName.equals("Valorous Charge")) list = list.getColor("W");
}
for(int i = 0; i < list.size(); i++) {
final Card[] target = new Card[1];
target[0] = list.get(i);
final Command untilEOT = new Command() {
private static final long serialVersionUID = 5063161656920609389L;
public void execute() {
if(AllZone.GameAction.isCardInPlay(target[0])) {
target[0].addTempAttackBoost(-pboost);
target[0].addTempDefenseBoost(-tboost);
if(!kboost.equals("None")) target[0].removeExtrinsicKeyword(kboost);
}
}
};//Command
if(AllZone.GameAction.isCardInPlay(target[0])) {
target[0].addTempAttackBoost(pboost);
target[0].addTempDefenseBoost(tboost);
if(!kboost.equals("None")) target[0].addExtrinsicKeyword(kboost);
AllZone.EndOfTurn.addUntil(untilEOT);
}//if
}//for
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Pyrohemia")) {
SpellAbility ability = new Ability(card, "R") {
@Override
public boolean canPlayAI() {
CardList human = new CardList(AllZone.Human_Play.getCards());
CardList computer = new CardList(AllZone.Computer_Play.getCards());
human = human.getType("Creature");
computer = computer.getType("Creature");
return AllZone.Computer_Life.getLife() > 2 && !(human.size() == 0 && 0 < computer.size());
}
@Override
public void resolve() {
//get all creatures
CardList list = new CardList();
list.addAll(AllZone.Human_Play.getCards());
list.addAll(AllZone.Computer_Play.getCards());
list = list.getType("Creature");
for(int i = 0; i < list.size(); i++) {
if(CardFactoryUtil.canDamage(card, list.get(i))) list.get(i).addDamage(1, card);
}
AllZone.Human_Life.subtractLife(1);
AllZone.Computer_Life.subtractLife(1);
}//resolve()
};//SpellAbility
ability.setDescription("R: Pyrohemia deals 1 damage to each creature and each player.");
ability.setStackDescription(card + " deals 1 damage to each creature and each player.");
card.clearSpellAbility();
card.addSpellAbility(new Spell_Permanent(card) {
private static final long serialVersionUID = 5596915641671666843L;
@Override
public boolean canPlayAI() {
//get all creatures
CardList list = new CardList();
list.addAll(AllZone.Human_Play.getCards());
list.addAll(AllZone.Computer_Play.getCards());
list = list.getType("Creature");
return 0 < list.size();
}
});
card.addSpellAbility(ability);
}
//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Pestilence")) {
SpellAbility ability = new Ability(card, "B") {
@Override
public boolean canPlayAI() {
CardList human = new CardList(AllZone.Human_Play.getCards());
CardList computer = new CardList(AllZone.Computer_Play.getCards());
human = human.getType("Creature");
computer = computer.getType("Creature");
return AllZone.Computer_Life.getLife() > 2 && !(human.size() == 0 && 0 < computer.size());
}
@Override
public void resolve() {
//get all creatures
CardList list = new CardList();
list.addAll(AllZone.Human_Play.getCards());
list.addAll(AllZone.Computer_Play.getCards());
list = list.getType("Creature");
for(int i = 0; i < list.size(); i++) {
if(CardFactoryUtil.canDamage(card, list.get(i))) list.get(i).addDamage(1, card);
}
AllZone.Human_Life.subtractLife(1);
AllZone.Computer_Life.subtractLife(1);
}//resolve()
};//SpellAbility
ability.setDescription("B: Pestilence deals 1 damage to each creature and each player.");
ability.setStackDescription(card + " deals 1 damage to each creature and each player.");
card.clearSpellAbility();
card.addSpellAbility(new Spell_Permanent(card) {
private static final long serialVersionUID = -4163089323122672307L;
@Override
public boolean canPlayAI() {
//get all creatures
CardList list = new CardList();
list.addAll(AllZone.Human_Play.getCards());
list.addAll(AllZone.Computer_Play.getCards());
list = list.getType("Creature");
return 0 < list.size();
}
});
card.addSpellAbility(ability);
}
//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Bridge from Below")) {
SpellAbility spell = new Spell_Permanent(card) {
private static final long serialVersionUID = 7254358703158629514L;
@Override
public boolean canPlayAI() {
return false;
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}
//*************** END ************ END *************************
//*************** START *********** START **************************
else if(cardName.equals("Nevinyrral's Disk")) {
SpellAbility summoningSpell = new Spell_Permanent(card) {
private static final long serialVersionUID = -8859376851358601934L;
@Override
public boolean canPlayAI() {
boolean nevinyrralInPlay = false;
CardList inPlay = new CardList();
inPlay.addAll(AllZone.Computer_Play.getCards());
for(int i = 0; i < inPlay.size(); ++i) {
if(inPlay.getCard(i).getName().equals("Nevinyrral's Disk")) {
nevinyrralInPlay = true;
}
}
return !nevinyrralInPlay && (0 < CardFactoryUtil.AI_getHumanCreature(card, false).size());
}
};
card.clearSpellAbility();
card.addSpellAbility(summoningSpell);
card.addComesIntoPlayCommand(new Command() {
private static final long serialVersionUID = -2504426622672629123L;
public void execute() {
card.tap();
}
});
final SpellAbility ability = new Ability_Tap(card, "1") {
private static final long serialVersionUID = 4175577092552330100L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
all = filter(all);
for(int i = 0; i < all.size(); i++)
AllZone.GameAction.destroy(all.get(i));
}
private CardList filter(CardList list) {
return list.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isArtifact() || c.isCreature() || c.isEnchantment();
}
});
}//filter()
@Override
public boolean canPlayAI() {
CardList human = new CardList(AllZone.Human_Play.getCards());
CardList computer = new CardList(AllZone.Computer_Play.getCards());
human = human.getType("Creature");
computer = computer.getType("Creature");
//the computer will at least destroy 2 more human creatures
return AllZone.Phase.getPhase().equals(Constant.Phase.Main2) &&
(computer.size() < human.size() - 1 || AllZone.Computer_Life.getLife() < 7);
}
};//SpellAbility
card.addSpellAbility(ability);
ability.setDescription("1, tap: Destroy all artifacts, creatures, and enchantments.");
ability.setStackDescription("Destroy all artifacts, creatures, and enchantments.");
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Tanglebloom")) {
final SpellAbility a1 = new Ability_Tap(card, "1") {
private static final long serialVersionUID = -6395076857898740906L;
@Override
public boolean canPlayAI() {
return AllZone.Phase.getPhase().equals(Constant.Phase.Main2);
}
@Override
public void resolve() {
AllZone.GameAction.getPlayerLife(card.getController()).addLife(1);
}
};//SpellAbility
card.addSpellAbility(a1);
a1.setDescription("1, tap: You gain 1 life.");
a1.setStackDescription("Tanglebloom - " + card.getController() + " gains 1 life.");
a1.setBeforePayMana(new Input_PayManaCost(a1));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Conspiracy") || cardName.equals("Cover of Darkness")
|| cardName.equals("Door of Destinies") || cardName.equals("Engineered Plague")
|| cardName.equals("Shared Triumph") || cardName.equals("Belbe's Portal")
|| cardName.equals("Steely Resolve")) {
final String[] input = new String[1];
final String player = card.getController();
final SpellAbility ability = new Ability(card, "0") {
@Override
public void resolve() {
if(player.equals(Constant.Player.Human)) {
input[0] = JOptionPane.showInputDialog(null, "Which creature type?", "Pick type",
JOptionPane.QUESTION_MESSAGE);
if(input[0].equals("Legendary") || input[0].equals("Artifact")
|| input[0].equals("Enchantment") || input[0].equals("Shrine")
|| input[0].equals("Creature")) input[0] = "";
//TODO: some more input validation, case-sensitivity, etc.
input[0] = input[0].trim(); //this is to prevent "cheating", and selecting multiple creature types,eg "Goblin Soldier"
} else {
String chosenType = CardFactoryUtil.chooseCreatureTypeAI(card);
if(!chosenType.equals("")) input[0] = chosenType;
else input[0] = "Sliver"; //what to put here for the AI???
}
card.setChosenType(input[0]);
}
};//ability
Command intoPlay = new Command() {
private static final long serialVersionUID = 5634360316643996274L;
public void execute() {
ability.setStackDescription("When " + card.getName()
+ " comes into play, choose a creature type.");
AllZone.Stack.add(ability);
}
};
card.addComesIntoPlayCommand(intoPlay);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Sarpadian Empires, Vol. VII")) {
final String[] choices = {"Citizen", "Camarid", "Thrull", "Goblin", "Saproling"};
final String player = card.getController();
final SpellAbility ability = new Ability(card, "0") {
@Override
public void resolve() {
String type = "";
String imageName = "";
String color = "";
if(player.equals(Constant.Player.Computer)) {
type = "Thrull";
imageName = "B 1 1 Thrull";
color = "B";
} else if(player.equals(Constant.Player.Human)) {
Object q = AllZone.Display.getChoiceOptional("Select type of creature", choices);
if(q.equals("Citizen")) {
type = "Citizen";
imageName = "W 1 1 Citizen";
color = "W";
} else if(q.equals("Camarid")) {
type = "Camarid";
imageName = "U 1 1 Camarid";
color = "U";
} else if(q.equals("Thrull")) {
type = "Thrull";
imageName = "B 1 1 Thrull";
color = "B";
} else if(q.equals("Goblin")) {
type = "Goblin";
imageName = "R 1 1 Goblin";
color = "R";
} else if(q.equals("Saproling")) {
type = "Saproling";
imageName = "G 1 1 Saproling";
color = "G";
}
}
card.setChosenType(type);
final String t = type;
final String in = imageName;
final String col = color;
//card.setChosenType(input[0]);
final Ability_Tap a1 = new Ability_Tap(card, "3") {
private static final long serialVersionUID = -2114111483117171609L;
@Override
public void resolve() {
CardFactoryUtil.makeToken(t, in, card, col, new String[] {"Creature", t}, 1, 1,
new String[] {""});
}
};
// a1.setDescription("3, Tap: Put a 1/1 creature token of the chosen color and type onto the battlefield.");
a1.setStackDescription(card.getName() + " - " + card.getController() + " puts a 1/1" + t
+ " token into play");
card.addSpellAbility(a1);
}
};//ability
Command intoPlay = new Command() {
private static final long serialVersionUID = 7202704600935499188L;
public void execute() {
ability.setStackDescription("As Sarpadian Empires, Vol. VII enters the battlefield, choose white Citizen, blue Camarid, black Thrull, red Goblin, or green Saproling.");
AllZone.Stack.add(ability);
}
};
card.setText("As Sarpadian Empires, Vol. VII enters the battlefield, choose white Citizen, blue Camarid, black Thrull, red Goblin, or green Saproling.\r\n"
+ "3, Tap: Put a 1/1 creature token of the chosen color and type onto the battlefield.\r\n"
+ card.getText()); // In the slight chance that there may be a need to add a note to this card.
card.addComesIntoPlayCommand(intoPlay);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Timetwister")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 505983020365091226L;
@Override
public void resolve() {
discardDraw7(Constant.Player.Human);
discardDraw7(Constant.Player.Computer);
}//resolve()
void discardDraw7(String player) {
// Discard hand into graveyard
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, player);
Card[] c = hand.getCards();
for(int i = 0; i < c.length; i++)
AllZone.GameAction.discard(c[i]);
// Move graveyard into library
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, player);
PlayerZone library = AllZone.getZone(Constant.Zone.Library, player);
Card[] g = grave.getCards();
for(int i = 0; i < g.length; i++) {
grave.remove(g[i]);
library.add(g[i], 0);
}
// Shuffle library
AllZone.GameAction.shuffle(player);
// Draw seven cards
for(int i = 0; i < 7; i++)
AllZone.GameAction.drawCard(player);
if(card.getController().equals(player)) {
library.remove(card);
grave.add(card);
}
}
// Simple, If computer has two or less playable cards remaining in hand play Timetwister
@Override
public boolean canPlayAI() {
Card[] c = removeLand(AllZone.Computer_Hand.getCards());
return 2 >= c.length;
}
Card[] removeLand(Card[] in) {
CardList c = new CardList(in);
c = c.filter(new CardListFilter() {
public boolean addCard(Card c) {
return !c.isLand();
}
});
return c.toArray();
}//removeLand()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Dragon Roost")) {
final SpellAbility ability = new Ability(card, "5 R R") {
@Override
public void resolve() {
CardFactoryUtil.makeToken("Dragon", "R 5 5 Dragon", card, "R", new String[] {
"Creature", "Dragon"}, 5, 5, new String[] {"Flying"});
}//resolve()
};
ability.setDescription("5RR: Put a 5/5 red Dragon creature token with flying into play.");
ability.setStackDescription("Dragon Roost - Put a 5/5 red Dragon creature token with flying into play.");
card.addSpellAbility(ability);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("The Hive")) {
final SpellAbility ability = new Ability_Tap(card, "5") {
private static final long serialVersionUID = -1091111822316858416L;
@Override
public void resolve() {
CardFactoryUtil.makeToken("Wasp", "C 1 1 Wasp", card, "", new String[] {
"Artifact", "Creature", "Insect"}, 1, 1, new String[] {"Flying"});
}//resolve()
};
ability.setDescription("5, tap: Put a 1/1 Insect artifact creature token with flying named Wasp into play.");
ability.setStackDescription("The Hive - Put a 1/1 token with flying into play.");
card.addSpellAbility(ability);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Mobilization")) {
final SpellAbility ability = new Ability(card, "2 W") {
@Override
public void resolve() {
CardFactoryUtil.makeToken("Soldier", "W 1 1 Soldier", card, "W", new String[] {
"Creature", "Soldier"}, 1, 1, new String[] {""});
}//resolve()
};
ability.setDescription("2W: Put a 1/1 white Soldier creature token into play.");
ability.setStackDescription("Mobilization - Put a 1/1 Soldier token into play.");
card.addSpellAbility(ability);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Centaur Glade")) {
final SpellAbility ability = new Ability(card, "2 G G") {
@Override
public void resolve() {
CardFactoryUtil.makeToken("Centaur", "G 3 3 Centaur", card, "G", new String[] {
"Creature", "Centaur"}, 3, 3, new String[] {""});
}//resolve()
};
ability.setDescription("2GG: Put a 3/3 green Centaur creature token into play.");
ability.setStackDescription("Centaur Glade - Put a 3/3 token into play.");
card.addSpellAbility(ability);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Pongify")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -7657135492744577568L;
@Override
public boolean canPlayAI() {
return (getCreature().size() != 0) && (AllZone.Phase.getTurn() > 4);
}
@Override
public void chooseTargetAI() {
Card best = CardFactoryUtil.AI_getBestCreature(getCreature());
setTargetCard(best);
}
CardList getCreature() {
CardList list = CardFactoryUtil.AI_getHumanCreature(card, true);
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
return (3 < c.getNetAttack());
}
});
return list;
}//getCreature()
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
CardFactoryUtil.makeToken("Ape", "G 3 3 Ape", getTargetCard().getController(), "G",
new String[] {"Creature", "Ape"}, 3, 3, new String[] {""});
AllZone.GameAction.destroyNoRegeneration(getTargetCard());
}
}//resolve()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Devour in Shadow")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 215990562522519924L;
@Override
public boolean canPlayAI() {
return (getCreature().size() != 0) && (AllZone.Phase.getTurn() > 4);
}
@Override
public void chooseTargetAI() {
Card best = CardFactoryUtil.AI_getBestCreature(getCreature());
setTargetCard(best);
if(AllZone.Computer_Life.getLife() <= best.getNetDefense()) {
CardList human = CardFactoryUtil.AI_getHumanCreature(AllZone.Computer_Life.getLife() - 1,
card, true);
CardListUtil.sortAttack(human);
if(0 < human.size()) setTargetCard(human.get(0));
}
}
CardList getCreature() {
return CardFactoryUtil.AI_getHumanCreature(card, true);
}//getCreature()
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
AllZone.GameAction.destroyNoRegeneration(getTargetCard());
PlayerLife life = AllZone.GameAction.getPlayerLife(card.getController());
life.subtractLife(getTargetCard().getNetDefense());
}
}//resolve()
};
card.clearSpellAbility();
spell.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell));
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Oblivion Ring")) {
final CommandReturn getPerm = new CommandReturn() {
public Object execute() {
//get all creatures
CardList tempList = new CardList();
tempList.addAll(AllZone.Human_Play.getCards());
tempList.addAll(AllZone.Computer_Play.getCards());
CardList list = new CardList();
for(int i = 0; i < tempList.size(); i++) {
if(tempList.get(i).isPermanent() && !tempList.get(i).isLand()
&& CardFactoryUtil.canTarget(card, tempList.get(i))) list.add(tempList.get(i));
}
//remove "this card"
list.remove(card);
return list;
}
};//CommandReturn
final SpellAbility abilityComes = new Ability(card, "0") {
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
AllZone.GameAction.removeFromGame(getTargetCard());
}
}//resolve()
};
final Input inputComes = new Input() {
private static final long serialVersionUID = -3613946694360326887L;
@Override
public void showMessage() {
CardList choice = (CardList) getPerm.execute();
stopSetNext(CardFactoryUtil.input_targetSpecific(abilityComes, choice,
"Select target permanent to remove from the game", true, false));
ButtonUtil.disableAll();//to disable the Cancel button
}
};
Command commandComes = new Command() {
private static final long serialVersionUID = -6250376920501373535L;
public void execute() {
CardList perm = (CardList) getPerm.execute();
String s = card.getController();
if(perm.size() == 0) return;
else if(s.equals(Constant.Player.Human)) AllZone.InputControl.setInput(inputComes);
else //computer
{
Card target;
//try to target human creature
CardList human = CardFactoryUtil.AI_getHumanCreature(card, true);
target = CardFactoryUtil.AI_getBestCreature(human);//returns null if list is empty
// try to target human permanent
if(target == null) {
int convertedCost = 0;
CardList tempList = new CardList();
tempList.addAll(AllZone.Human_Play.getCards());
for(int i = 0; i < tempList.size(); i++) {
if(tempList.get(i).isPermanent()
&& !tempList.get(i).isLand()
&& CardFactoryUtil.canTarget(card, tempList.get(i))
&& (CardUtil.getConvertedManaCost(tempList.get(i).getManaCost()) > convertedCost)) {
target = tempList.get(i);
convertedCost = CardUtil.getConvertedManaCost(tempList.get(i).getManaCost());
}
}
}
//target something cheaper (manacost 0?) instead:
if(target == null) {
CardList humanPerms = new CardList();
humanPerms.addAll(AllZone.Human_Play.getCards());
humanPerms = humanPerms.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isPermanent() && !c.isLand() && CardFactoryUtil.canTarget(card, c);
}
});
if(humanPerms.size() > 0) target = humanPerms.get(0);
}
if(target == null) {
//must target computer creature
CardList computer = new CardList(AllZone.Computer_Play.getCards());
computer = computer.getType("Creature");
computer.remove(card);
computer.shuffle();
if(computer.size() != 0) target = computer.get(0);
else target = card;
}
abilityComes.setTargetCard(target);
AllZone.Stack.add(abilityComes);
}//else
}//execute()
};//CommandComes
Command commandLeavesPlay = new Command() {
private static final long serialVersionUID = 6997038208952910355L;
public void execute() {
Object o = abilityComes.getTargetCard();
if(o == null || ((Card) o).isToken() || !AllZone.GameAction.isCardRemovedFromGame((Card) o)) return;
SpellAbility ability = new Ability(card, "0") {
@Override
public void resolve() {
//copy card to reset card attributes like attack and defense
Card c = abilityComes.getTargetCard();
if(!c.isToken()) {
c = AllZone.CardFactory.dynamicCopyCard(c);
c.setController(c.getOwner());
PlayerZone play = AllZone.getZone(Constant.Zone.Play, c.getOwner());
play.add(c);
}
}//resolve()
};//SpellAbility
ability.setStackDescription("Oblivion Ring - returning permanent to play.");
AllZone.Stack.add(ability);
}//execute()
};//Command
card.addComesIntoPlayCommand(commandComes);
card.addLeavesPlayCommand(commandLeavesPlay);
card.clearSpellAbility();
card.addSpellAbility(new Spell_Permanent(card) {
private static final long serialVersionUID = -3250095291930182087L;
@Override
public boolean canPlayAI() {
Object o = getPerm.execute();
if(o == null) return false;
CardList cl = (CardList) getPerm.execute();
return (o != null) && cl.size() > 0 && AllZone.getZone(getSourceCard()).is(Constant.Zone.Hand);
}
});
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Oubliette")) {
final SpellAbility enchantment = new Spell(card) {
private static final long serialVersionUID = -6751177094537759827L;
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
AllZone.GameAction.removeFromGame(getTargetCard());
//put permanent into play
Card c = getSourceCard();
AllZone.getZone(Constant.Zone.Play, c.getController()).add(c);
}
}//resolve()
@Override
public boolean canPlayAI() {
//try to target human creature
CardList human = CardFactoryUtil.AI_getHumanCreature(card, true);
Card target = CardFactoryUtil.AI_getBestCreature(human);//returns null if list is empty
if(target == null) return false;
else {
setTargetCard(target);
return true;
}
}//canPlayAI()
};//SpellAbility enchantment
/*
@SuppressWarnings("unused") // target
final Input target = new Input()
{
private static final long serialVersionUID = -251660220889858176L;
//showMessage() is always the first method called
public void showMessage()
{
AllZone.Display.showMessage("Select creature to remove from the game (sorry no phasing yet).");
ButtonUtil.enableOnlyCancel();
}
public void selectButtonCancel() {stop();}
public void selectCard(Card c, PlayerZone zone)
{
if(!CardFactoryUtil.canTarget(enchantment, c)){
AllZone.Display.showMessage("Cannot target this card (Shroud? Protection?).");
}
else if(zone.is(Constant.Zone.Play) && c.isCreature())
{
enchantment.setTargetCard(c);
stopSetNext(new Input_PayManaCost(enchantment));
}
}
};//Input target
*/
Command commandLeavesPlay = new Command() {
private static final long serialVersionUID = -2535098005246027777L;
public void execute() {
Object o = enchantment.getTargetCard();
if(o == null || ((Card) o).isToken() || !AllZone.GameAction.isCardRemovedFromGame((Card) o)) return;
SpellAbility ability = new Ability(card, "0") {
@Override
public void resolve() {
//copy card to reset card attributes like attack and defense
Card c = enchantment.getTargetCard();
if(!c.isToken()) {
c = AllZone.CardFactory.copyCard(c);
c.setController(c.getOwner());
PlayerZone play = AllZone.getZone(Constant.Zone.Play, c.getOwner());
play.add(c);
}
}//resolve()
};//SpellAbility
ability.setStackDescription(card.getName() + " - returning creature to play");
AllZone.Stack.add(ability);
}//execute()
};//Command
card.addLeavesPlayCommand(commandLeavesPlay);
card.clearSpellAbility();
card.addSpellAbility(enchantment);
enchantment.setBeforePayMana(CardFactoryUtil.input_targetCreature(enchantment));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Test Destroy")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 6637283804612570910L;
@Override
public boolean canPlayAI() {
return false;
}
@Override
public void resolve() {
AllZone.GameAction.destroy(getTargetCard());
}//resolve()
};
card.clearSpellAbility();
spell.setBeforePayMana(CardFactoryUtil.input_targetType(spell, "All"));
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Take Possession")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -7359291736123492910L;
@Override
public boolean canPlayAI() {
return 0 < CardFactoryUtil.AI_getHumanCreature(card, true).size();
}
@Override
public void chooseTargetAI() {
Card best = CardFactoryUtil.AI_getBestCreature(CardFactoryUtil.AI_getHumanCreature(card, true));
setTargetCard(best);
}
@Override
public void resolve() {
Card c = getTargetCard();
c.setController(card.getController());
((PlayerZone_ComesIntoPlay) AllZone.Human_Play).setTriggers(false);
((PlayerZone_ComesIntoPlay) AllZone.Computer_Play).setTriggers(false);
PlayerZone from = AllZone.getZone(c);
PlayerZone to = AllZone.getZone(Constant.Zone.Play, card.getController());
from.remove(c);
to.add(c);
((PlayerZone_ComesIntoPlay) AllZone.Human_Play).setTriggers(true);
((PlayerZone_ComesIntoPlay) AllZone.Computer_Play).setTriggers(true);
}//resolve()
};
card.clearSpellAbility();
spell.setBeforePayMana(CardFactoryUtil.input_targetType(spell, "All"));
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Infest")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -4970294125917784048L;
@Override
public boolean canPlayAI() {
CardList human = new CardList(AllZone.Human_Play.getCards());
CardList computer = new CardList(AllZone.Computer_Play.getCards());
human = human.getType("Creature");
computer = computer.getType("Creature");
human = CardListUtil.filterToughness(human, 2);
computer = CardListUtil.filterToughness(computer, 2);
//the computer will at least destroy 2 more human creatures
return computer.size() < human.size() - 1;
}//canPlayAI()
@Override
public void resolve() {
//get all creatures
CardList list = new CardList();
list.addAll(AllZone.Human_Play.getCards());
list.addAll(AllZone.Computer_Play.getCards());
list = list.getType("Creature");
for(int i = 0; i < list.size(); i++)
list.get(i).addDamage(2, card);
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Molten Rain")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 8855786097956610090L;
@Override
public void resolve() {
Card c = getTargetCard();
if(AllZone.GameAction.isCardInPlay(c) && CardFactoryUtil.canTarget(card, c)) {
if(!c.getType().contains("Basic")) AllZone.GameAction.getPlayerLife(c.getController()).subtractLife(
2);
AllZone.GameAction.destroy(c);
}
}// resolve()
};// Spell
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setChooseTargetAI(CardFactoryUtil.AI_targetType("Land", AllZone.Human_Play));
spell.setBeforePayMana(CardFactoryUtil.input_targetType(spell, "Land"));
}// *************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Belbe's Portal")) {
final SpellAbility ability = new Ability_Tap(card, "3") {
private static final long serialVersionUID = 3790805878629855813L;
@Override
public boolean canPlayAI() {
return getCreature().size() != 0;
}
@Override
public void chooseTargetAI() {
card.tap();
Card target = CardFactoryUtil.AI_getBestCreature(getCreature());
setTargetCard(target);
}
CardList getCreature() {
CardList list = new CardList(AllZone.Computer_Hand.getCards());
list = list.getType(card.getChosenType());
return list;
}
@Override
public void resolve() {
Card c = getTargetCard();
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
if(AllZone.GameAction.isCardInZone(c, hand)) {
hand.remove(c);
play.add(c);
}
}
};//SpellAbility
card.addSpellAbility(ability);
ability.setDescription("3, tap: Put a creature card of the chosen type from your hand into play.");
final Command paid = new Command() {
private static final long serialVersionUID = 4258139342966165260L;
public void execute() {
AllZone.InputControl.resetInput();
AllZone.Stack.add(ability);
}
};
final Command unpaid = new Command() {
private static final long serialVersionUID = 5792270994683837097L;
public void execute() {
card.untap();
}
};
final Input target = new Input() {
private static final long serialVersionUID = -3180364352114242238L;
@Override
public void showMessage() {
ButtonUtil.enableOnlyCancel();
AllZone.Display.showMessage("Select creature from your hand to put into play");
}
@Override
public void selectCard(Card c, PlayerZone zone) {
if(c.isCreature() && zone.is(Constant.Zone.Hand, Constant.Player.Human)
&& c.getType().contains(card.getChosenType())) {
card.tap();
ability.setTargetCard(c);//since setTargetCard() changes stack description
ability.setStackDescription("Put into play " + c);
AllZone.InputControl.setInput(new Input_PayManaCost_Ability(ability.getManaCost(), paid,
unpaid));
}
}
@Override
public void selectButtonCancel() {
card.untap();
stop();
}
};//Input target
ability.setBeforePayMana(target);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Hex")) {
final Card[] target = new Card[6];
final int[] index = new int[1];
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -1880229743741157304L;
@Override
public boolean canPlayAI() {
CardList human = CardFactoryUtil.AI_getHumanCreature(card, true);
CardListUtil.sortAttack(human);
CardListUtil.sortFlying(human);
if(6 <= human.size()) {
for(int i = 0; i < 6; i++)
//should check to make sure none of these creatures have protection or cannot be the target of spells.
target[i] = human.get(i);
}
return 6 <= human.size();
}
@Override
public void resolve() {
for(int i = 0; i < target.length; i++)
if(AllZone.GameAction.isCardInPlay(target[i])
&& CardFactoryUtil.canTarget(card, target[i])) AllZone.GameAction.destroy(target[i]);
}//resolve()
};//SpellAbility
final Input input = new Input() {
private static final long serialVersionUID = 5792813689927185739L;
@Override
public void showMessage() {
int count = 6 - index[0];
AllZone.Display.showMessage("Select target " + count + " creatures to destroy");
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card c, PlayerZone zone) {
for(int i = 0; i < index[0]; i++) {
if(c.equals(target[i])) {
AllZone.Display.showMessage("You have already selected this target. You must select unique targets for each of the 6 creatures to destroy.");
return; //cannot target the same creature twice.
}
}
if(c.isCreature() && zone.is(Constant.Zone.Play)) {
target[index[0]] = c;
index[0]++;
showMessage();
if(index[0] == target.length) {
if(this.isFree()) {
this.setFree(false);
AllZone.Stack.add(spell);
stop();
} else stopSetNext(new Input_PayManaCost(spell));
}
}
}//selectCard()
};//Input
Input runtime = new Input() {
private static final long serialVersionUID = 3522833806455511494L;
@Override
public void showMessage() {
index[0] = 0;
stopSetNext(input);
}
};//Input
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(runtime);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Political Trickery")) {
final Card[] target = new Card[2];
final int[] index = new int[1];
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -3075569295823682336L;
@Override
public boolean canPlayAI() {
return false;
}
@Override
public void resolve() {
Card crd0 = target[0];
Card crd1 = target[1];
if(crd0 != null && crd1 != null) {
((PlayerZone_ComesIntoPlay) AllZone.Human_Play).setTriggers(false);
((PlayerZone_ComesIntoPlay) AllZone.Computer_Play).setTriggers(false);
PlayerZone from0 = AllZone.getZone(crd0);
from0.remove(crd0);
PlayerZone from1 = AllZone.getZone(crd1);
from1.remove(crd1);
crd0.setController(AllZone.GameAction.getOpponent(card.getController()));
crd1.setController(card.getController());
PlayerZone to0 = AllZone.getZone(Constant.Zone.Play,
AllZone.GameAction.getOpponent(card.getController()));
to0.add(crd0);
PlayerZone to1 = AllZone.getZone(Constant.Zone.Play, card.getController());
to1.add(crd1);
((PlayerZone_ComesIntoPlay) AllZone.Human_Play).setTriggers(true);
((PlayerZone_ComesIntoPlay) AllZone.Computer_Play).setTriggers(true);
}
}//resolve()
};//SpellAbility
final Input input = new Input() {
private static final long serialVersionUID = -1017253686774265770L;
@Override
public void showMessage() {
if(index[0] == 0) AllZone.Display.showMessage("Select target land you control.");
else AllZone.Display.showMessage("Select target land opponent controls.");
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card c, PlayerZone zone) {
//must target creature you control
if(index[0] == 0 && !c.getController().equals(card.getController())) return;
//must target creature you don't control
if(index[0] == 1 && c.getController().equals(card.getController())) return;
if(c.isLand() && zone.is(Constant.Zone.Play) && CardFactoryUtil.canTarget(card, c)) {
target[index[0]] = c;
index[0]++;
showMessage();
if(index[0] == target.length) {
if(this.isFree()) {
this.setFree(false);
AllZone.Stack.add(spell);
stop();
} else stopSetNext(new Input_PayManaCost(spell));
}
}
}//selectCard()
};//Input
Input runtime = new Input() {
private static final long serialVersionUID = 4003351872990899418L;
@Override
public void showMessage() {
index[0] = 0;
stopSetNext(input);
}
};//Input
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(runtime);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Peel from Reality")) {
final Card[] target = new Card[2];
final int[] index = new int[1];
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -5781099237509350795L;
@Override
public boolean canPlayAI() {
return false;
}
@Override
public void resolve() {
//bounce two creatures in target[]
for(int i = 0; i < target.length; i++) {
Card c = target[i];
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, c.getOwner());
if(AllZone.GameAction.isCardInPlay(c) && CardFactoryUtil.canTarget(card, c)) AllZone.GameAction.moveTo(
hand, c);
}
}//resolve()
};//SpellAbility
final Input input = new Input() {
private static final long serialVersionUID = -5897481915350104062L;
@Override
public void showMessage() {
if(index[0] == 0) AllZone.Display.showMessage("Select target creature you control to bounce return to their owners' hand");
else AllZone.Display.showMessage("Select target creature you don't control to return to their owners' hand");
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card c, PlayerZone zone) {
//must target creature you control
if(index[0] == 0 && !c.getController().equals(card.getController())) return;
//must target creature you don't control
if(index[0] == 1 && c.getController().equals(card.getController())) return;
if(c.isCreature() && zone.is(Constant.Zone.Play) && CardFactoryUtil.canTarget(card, c)) {
target[index[0]] = c;
index[0]++;
showMessage();
if(index[0] == target.length) {
if(this.isFree()) {
this.setFree(false);
AllZone.Stack.add(spell);
stop();
} else stopSetNext(new Input_PayManaCost(spell));
}
}
}//selectCard()
};//Input
Input runtime = new Input() {
private static final long serialVersionUID = 1194864613104644447L;
@Override
public void showMessage() {
index[0] = 0;
stopSetNext(input);
}
};//Input
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(runtime);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Ashes to Ashes")) {
final Card[] target = new Card[2];
final int[] index = new int[1];
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -6509598408022853029L;
@Override
public boolean canPlayAI() {
return 2 <= getNonArtifact().size() && 5 < AllZone.Computer_Life.getLife();
}
@Override
public void chooseTargetAI() {
CardList human = getNonArtifact();
CardListUtil.sortAttack(human);
target[0] = human.get(0);
target[1] = human.get(1);
}
CardList getNonArtifact() {
CardList list = CardFactoryUtil.AI_getHumanCreature(card, true);
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
return !c.isArtifact();
}
});
return list;
}//getNonArtifact()
@Override
public void resolve() {
for(int i = 0; i < target.length; i++) {
Card c = target[i];
PlayerZone remove = AllZone.getZone(Constant.Zone.Removed_From_Play, c.getOwner());
AllZone.GameAction.moveTo(remove, c);
}
PlayerLife life = AllZone.GameAction.getPlayerLife(card.getController());
life.subtractLife(5);
}//resolve()
};//SpellAbility
final Input input = new Input() {
private static final long serialVersionUID = -4114782677700487264L;
@Override
public void showMessage() {
if(index[0] == 0) AllZone.Display.showMessage("Select 1st target non-artifact creature to remove from the game");
else AllZone.Display.showMessage("Select 2nd target non-artifact creature to remove from the game");
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card c, PlayerZone zone) {
if(!c.isArtifact() && c.isCreature() && zone.is(Constant.Zone.Play)) {
target[index[0]] = c;
index[0]++;
showMessage();
if(index[0] == target.length) {
if(this.isFree()) {
this.setFree(false);
AllZone.Stack.add(spell);
stop();
} else stopSetNext(new Input_PayManaCost(spell));
}
}
}//selectCard()
};//Input
Input runtime = new Input() {
private static final long serialVersionUID = -3162536306318797516L;
@Override
public void showMessage() {
index[0] = 0;
stopSetNext(input);
}
};//Input
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(runtime);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Wings of Velis Vel")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -5744842090293912606L;
@Override
public boolean canPlayAI() {
CardList small = new CardList(AllZone.Computer_Play.getCards());
small = small.getType("Creature");
//try to make a good attacker
if(0 < small.size()) {
CardListUtil.sortAttackLowFirst(small);
setTargetCard(small.get(0));
return true && AllZone.Phase.getPhase().equals(Constant.Phase.Main1);
}
return false;
}//canPlayAI()
@Override
public void resolve() {
//in case ability is played twice
final int[] oldAttack = new int[1];
final int[] oldDefense = new int[1];
final Card card[] = new Card[1];
card[0] = getTargetCard();
oldAttack[0] = card[0].getBaseAttack();
oldDefense[0] = card[0].getBaseDefense();
card[0].setBaseAttack(4);
card[0].setBaseDefense(4);
card[0].addExtrinsicKeyword("Flying");
//EOT
final Command untilEOT = new Command() {
private static final long serialVersionUID = 7236360479349324099L;
public void execute() {
card[0].setBaseAttack(oldAttack[0]);
card[0].setBaseDefense(oldDefense[0]);
card[0].removeExtrinsicKeyword("Flying");
}
};
AllZone.EndOfTurn.addUntil(untilEOT);
}//resolve()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Lignify")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 5323770119451400755L;
@Override
public boolean canPlayAI() {
CardList c = CardFactoryUtil.AI_getHumanCreature(card, true);
CardListUtil.sortAttack(c);
CardListUtil.sortFlying(c);
if(c.isEmpty()) return false;
if(2 <= c.get(0).getNetAttack() && c.get(0).getKeyword().contains("Flying")) {
setTargetCard(c.get(0));
return true;
}
CardListUtil.sortAttack(c);
if(4 <= c.get(0).getNetAttack()) {
setTargetCard(c.get(0));
return true;
}
return false;
}//canPlayAI()
@Override
public void resolve() {
Card c = getTargetCard();
if(AllZone.GameAction.isCardInPlay(c) && CardFactoryUtil.canTarget(card, c)) {
c.setBaseAttack(0);
c.setBaseDefense(4);
c.setType(new ArrayList<String>());
c.addType("Creature");
c.addType("Treefolk");
c.setIntrinsicKeyword(new ArrayList<String>());
c.clearSpellAbility();
}
}//resolve()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("That Which Was Taken")) {
final SpellAbility ability = new Ability_Tap(card, "4") {
private static final long serialVersionUID = -8996435083734446340L;
@Override
public void resolve() {
Card c = getTargetCard();
if(AllZone.GameAction.isCardInPlay(c) && CardFactoryUtil.canTarget(card, c)) c.addExtrinsicKeyword("Indestructible");
}
@Override
public boolean canPlayAI() {
CardList creatures = getCreatures();
for(int i = 0; i < creatures.size(); i++) {
if(!creatures.get(i).getKeyword().contains("Indestructible")) {
return true;
}
}
return false;
}
@Override
public void chooseTargetAI() {
//Card c = CardFactoryUtil.AI_getBestCreature(getCreatures());
CardList a = getCreatures();
CardListUtil.sortAttack(a);
CardListUtil.sortFlying(a);
Card c = null;
for(int i = 0; i < a.size(); i++) {
if(!a.get(i).getKeyword().contains("Indestructible")) {
c = a.get(i);
break;
}
}
setTargetCard(c);
}
CardList getCreatures() {
CardList list = new CardList();
list.addAll(AllZone.Computer_Play.getCards());
return list.getType("Creature");
}
};//SpellAbility
Input target = new Input() {
private static final long serialVersionUID = 137806881250205274L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target permanent");
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card c, PlayerZone zone) {
if(zone.is(Constant.Zone.Play) && c != card)//cannot target self
{
ability.setTargetCard(c);
stopSetNext(new Input_PayManaCost(ability));
}
}
};//Input -- target
ability.setBeforePayMana(target);
ability.setDescription("4, tap: Tap a divinity counter on target permanent other than That Which Was Taken.");
card.addSpellAbility(ability);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Spectral Procession")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 6118842682065463016L;
@Override
public void resolve() {
for(int i = 0; i < 3; i++)
CardFactoryUtil.makeToken("Spirit", "W 1 1 Spirit", card, "W", new String[] {
"Creature", "Spirit"}, 1, 1, new String[] {"Flying"});
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Sacred Nectar")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -2280675656970845618L;
@Override
public boolean canPlay() {
setStackDescription(card.getName() + " - " + card.getController() + " gains 4 life.");
return super.canPlay();
}
@Override
public void resolve() {
PlayerLife life = AllZone.GameAction.getPlayerLife(card.getController());
life.addLife(4);
}
};
spell.setDescription("You gain 4 life.");
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Tremor")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 3451888160398198322L;
@Override
public boolean canPlayAI() {
CardList human = new CardList(AllZone.Human_Play.getCards());
CardList computer = new CardList(AllZone.Computer_Play.getCards());
human = human.filter(new CardListFilter() {
public boolean addCard(Card c) {
return !c.getKeyword().contains("Flying") && CardFactoryUtil.canDamage(card, c)
&& c.getNetDefense() == 1;
}
});
computer = computer.filter(new CardListFilter() {
public boolean addCard(Card c) {
return !c.getKeyword().contains("Flying") && CardFactoryUtil.canDamage(card, c)
&& c.getNetDefense() == 1;
}
});
// the computer will at least destroy 2 more human creatures
return computer.size() < human.size() - 1;
}
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
all = all.getType("Creature");
for(int i = 0; i < all.size(); i++)
if(!all.get(i).getKeyword().contains("Flying")
&& CardFactoryUtil.canDamage(card, all.get(i))) all.get(i).addDamage(1, card);
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Reviving Dose")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -3239301336328919121L;
@Override
public void resolve() {
PlayerLife life = AllZone.GameAction.getPlayerLife(card.getController());
life.addLife(3);
// AllZone.GameAction.drawCard(card.getController());
}
};
spell.setStackDescription(card.getName() + " - " + card.getController() + " gains 3 life.");
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Swords to Plowshares")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 4752934806606319269L;
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
//add life
String player = getTargetCard().getController();
PlayerLife life = AllZone.GameAction.getPlayerLife(player);
life.addLife(getTargetCard().getNetAttack());
//remove card from play
AllZone.GameAction.removeFromGame(getTargetCard());
}
}//resolve()
@Override
public boolean canPlayAI() {
CardList creature = new CardList(AllZone.Human_Play.getCards());
creature = creature.getType("Creature");
creature = creature.filter(new CardListFilter() {
public boolean addCard(Card c) {
return CardFactoryUtil.canTarget(card, c);
}
});
return creature.size() != 0 && (AllZone.Phase.getTurn() > 4);
}
@Override
public void chooseTargetAI() {
CardList play = new CardList(AllZone.Human_Play.getCards());
Card target = CardFactoryUtil.AI_getBestCreature(play, card);
if(target != null) setTargetCard(target);
}
};
spell.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Unmake")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -9194035528349589512L;
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
//remove card from play
AllZone.GameAction.removeFromGame(getTargetCard());
}
}//resolve()
@Override
public boolean canPlayAI() {
CardList creature = new CardList(AllZone.Human_Play.getCards());
creature = creature.getType("Creature");
creature = creature.filter(new CardListFilter() {
public boolean addCard(Card c) {
return CardFactoryUtil.canTarget(card, c);
}
});
return creature.size() != 0 && (AllZone.Phase.getTurn() > 4);
}
@Override
public void chooseTargetAI() {
CardList play = new CardList(AllZone.Human_Play.getCards());
Card target = CardFactoryUtil.AI_getBestCreature(play);
setTargetCard(target);
}
};
spell.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Crib Swap")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -4567382566960071562L;
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
CardFactoryUtil.makeToken("Shapeshifter", "C 1 1 Shapeshifter",
getTargetCard().getController(), "", new String[] {"Creature", "Shapeshifter"}, 1,
1, new String[] {"Changeling"});
//remove card from play
AllZone.GameAction.removeFromGame(getTargetCard());
}
}//resolve()
@Override
public boolean canPlayAI() {
CardList creature = new CardList(AllZone.Human_Play.getCards());
creature = creature.getType("Creature");
return creature.size() != 0 && (AllZone.Phase.getTurn() > 4);
}
@Override
public void chooseTargetAI() {
CardList play = new CardList(AllZone.Human_Play.getCards());
Card target = CardFactoryUtil.AI_getBestCreature(play);
setTargetCard(target);
}
};
spell.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Demonic Tutor") || cardName.equals("Diabolic Tutor")
|| cardName.equals("Grim Tutor")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 1481169060428051519L;
@Override
public void resolve() {
String player = card.getController();
if(player.equals(Constant.Player.Human)) humanResolve();
else computerResolve();
}
public void humanResolve() {
Object check = AllZone.Display.getChoiceOptional("Select card",
AllZone.Human_Library.getCards());
if(check != null) {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
AllZone.GameAction.moveTo(hand, (Card) check);
}
AllZone.GameAction.shuffle(Constant.Player.Human);
//lose 3 life
if(cardName.equals("Grim Tutor")) {
String player = Constant.Player.Human;
PlayerLife life = AllZone.GameAction.getPlayerLife(player);
life.subtractLife(3);
}
}
public void computerResolve() {
Card[] library = AllZone.Computer_Library.getCards();
CardList list = new CardList(library);
//pick best creature
Card c = CardFactoryUtil.AI_getBestCreature(list);
if(c == null) c = library[0];
//System.out.println("comptuer picked - " +c);
AllZone.Computer_Library.remove(c);
AllZone.Computer_Hand.add(c);
//lose 3 life
if(cardName.equals("Grim Tutor")) {
String player = Constant.Player.Computer;
PlayerLife life = AllZone.GameAction.getPlayerLife(player);
life.subtractLife(3);
}
}
@Override
public boolean canPlay() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
return library.getCards().length != 0
&& AllZone.Phase.getActivePlayer().equals(card.getController())
&& !AllZone.Phase.getPhase().equals("End of Turn") && super.canPlay();
}
@Override
public boolean canPlayAI() {
CardList creature = new CardList();
creature.addAll(AllZone.Computer_Library.getCards());
creature = creature.getType("Creature");
return creature.size() != 0;
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Entomb")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 4724906962713222211L;
@Override
public void resolve() {
String player = card.getController();
if(player.equals(Constant.Player.Human)) humanResolve();
else computerResolve();
}
public void humanResolve() {
Object check = AllZone.Display.getChoiceOptional("Select card",
AllZone.Human_Library.getCards());
if(check != null) {
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, card.getController());
AllZone.GameAction.moveTo(grave, (Card) check);
}
AllZone.GameAction.shuffle(Constant.Player.Human);
}
public void computerResolve() {
Card[] library = AllZone.Computer_Library.getCards();
CardList list = new CardList(library);
//pick best creature
Card c = CardFactoryUtil.AI_getBestCreature(list);
if(c == null) c = library[0];
//System.out.println("comptuer picked - " +c);
AllZone.Computer_Library.remove(c);
AllZone.Computer_Graveyard.add(c);
}
@Override
public boolean canPlay() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
return library.getCards().length != 0;
}
@Override
public boolean canPlayAI() {
CardList creature = new CardList();
creature.addAll(AllZone.Computer_Library.getCards());
creature = creature.getType("Creature");
return creature.size() != 0;
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Do or Die")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 8241241003478388362L;
@Override
public boolean canPlayAI() {
return 4 <= CardFactoryUtil.AI_getHumanCreature(card, true).size()
&& 4 < AllZone.Phase.getTurn();
}
@Override
public void resolve() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, getTargetPlayer());
CardList list = new CardList(play.getCards());
list = list.getType("Creature");
list.shuffle();
for(int i = 0; i < list.size() / 2; i++)
AllZone.GameAction.destroyNoRegeneration(list.get(i));
}
};//SpellAbility
spell.setChooseTargetAI(CardFactoryUtil.AI_targetHuman());
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
if(cardName.equals("Hymn to Tourach")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 42470566751344693L;
@Override
public boolean canPlayAI() {
return AllZone.Human_Hand.size() > 0;
}
@Override
public void resolve() {
String opponent = AllZone.GameAction.getOpponent(card.getController());
AllZone.GameAction.discardRandom(opponent);
AllZone.GameAction.discardRandom(opponent);
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Beacon of Destruction")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 6653675303299939465L;
@Override
public void resolve() {
if(getTargetCard() != null) {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
getTargetCard().addDamage(5, card);
done();
} else AllZone.GameAction.moveToGraveyard(card);
} else {
AllZone.GameAction.getPlayerLife(getTargetPlayer()).subtractLife(5);
done();
}
}//resolve()
void done() {
//shuffle card back into the library
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
library.add(card);
AllZone.GameAction.shuffle(card.getController());
}
};
spell.setChooseTargetAI(CardFactoryUtil.AI_targetHumanCreatureOrPlayer());
spell.setBeforePayMana(CardFactoryUtil.input_targetCreaturePlayer(spell, true, false));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Capsize")) {
final SpellAbility spell_one = new Spell(card) {
private static final long serialVersionUID = 7688777028599839669L;
@Override
public boolean canPlayAI() {
return false;
}
@Override
public void resolve() {
final Card[] target = new Card[1];
target[0] = getTargetCard();
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, target[0].getController());
if(AllZone.GameAction.isCardInPlay(target[0]) && CardFactoryUtil.canTarget(card, target[0])) {
if(!target[0].isToken()) AllZone.GameAction.moveTo(hand, target[0]);
else AllZone.GameAction.removeFromGame(target[0]);
}
}//resolve()
};//SpellAbility
final Card crd = card;
final SpellAbility spell_two = new Spell(card) {
private static final long serialVersionUID = -2399079881132655853L;
@Override
public boolean canPlayAI() {
CardList human = CardFactoryUtil.AI_getHumanCreature(card, true);
return 3 < AllZone.Phase.getTurn() && 0 < human.size();
}
@Override
public void chooseTargetAI() {
CardList human = CardFactoryUtil.AI_getHumanCreature(card, true);
setTargetCard(CardFactoryUtil.AI_getBestCreature(human));
}
@Override
public void resolve() {
final Card[] target = new Card[1];
target[0] = getTargetCard();
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, target[0].getOwner());
if(AllZone.GameAction.isCardInPlay(target[0]) && CardFactoryUtil.canTarget(card, target[0])) {
if(!target[0].isToken()) AllZone.GameAction.moveTo(hand, target[0]);
else AllZone.GameAction.removeFromGame(target[0]);
} else {
crd.clearReplaceMoveToGraveyardCommandList();
}
}//resolve()
};//SpellAbility
spell_two.setManaCost("4 U U");
spell_two.setAdditionalManaCost("3");
spell_one.setDescription("Return target permanent to its owner's hand.");
spell_two.setDescription("Buyback 3 - Pay 4 U U, put this card into your hand as it resolves.");
spell_two.setIsBuyBackAbility(true);
Input runtime1 = new Input() {
private static final long serialVersionUID = 6884105724632382299L;
@Override
public void showMessage() {
PlayerZone human = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
PlayerZone comp = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
CardList perms = new CardList();
perms.addAll(human.getCards());
perms.addAll(comp.getCards());
boolean free = false;
if(this.isFree()) free = true;
stopSetNext(CardFactoryUtil.input_targetSpecific(spell_one, perms, "Select target permanent.",
true, free));
}
};
Input runtime2 = new Input() {
private static final long serialVersionUID = 8564956495965504679L;
@Override
public void showMessage() {
PlayerZone human = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
PlayerZone comp = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
CardList perms = new CardList();
perms.addAll(human.getCards());
perms.addAll(comp.getCards());
boolean free = false;
if(this.isFree()) free = true;
stopSetNext(CardFactoryUtil.input_targetSpecific(spell_two, perms, "Select target permanent.",
true, free));
}
};
spell_one.setBeforePayMana(runtime1);
spell_two.setBeforePayMana(runtime2);
card.clearSpellAbility();
card.addSpellAbility(spell_one);
card.addSpellAbility(spell_two);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Whispers of the Muse")) {
final SpellAbility spell_one = new Spell(card) {
private static final long serialVersionUID = 8341386638247535343L;
@Override
public boolean canPlayAI() {
return false;
}
@Override
public void resolve() {
AllZone.GameAction.drawCard(card.getController());
}//resolve()
};//SpellAbility
final SpellAbility spell_two = new Spell(card) {
private static final long serialVersionUID = -131686114078716307L;
@Override
public void resolve() {
AllZone.GameAction.drawCard(card.getController());
done();
}//resolve()
void done() {
//return card to the hand
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
AllZone.GameAction.moveTo(hand, card);
}
};//SpellAbility
spell_two.setManaCost("5 U");
spell_two.setAdditionalManaCost("5");
spell_one.setDescription("Draw a card.");
spell_one.setStackDescription(cardName + " - " + card.getController() + " draws a card.");
spell_two.setDescription("Buyback 5 - Pay 5 U , put this card into your hand as it resolves.");
spell_two.setStackDescription(cardName + " - (Buyback) " + card.getController() + " draws a card.");
spell_two.setIsBuyBackAbility(true);
card.clearSpellAbility();
card.addSpellAbility(spell_one);
card.addSpellAbility(spell_two);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Elvish Fury")) {
final SpellAbility spell_one = new Spell(card) {
private static final long serialVersionUID = 3356401944678089378L;
@Override
public boolean canPlayAI() {
return false;
}
@Override
public void resolve() {
final Card[] target = new Card[1];
final Command untilEOT = new Command() {
private static final long serialVersionUID = 7120352016188545025L;
public void execute() {
if(AllZone.GameAction.isCardInPlay(target[0])) {
target[0].addTempAttackBoost(-2);
target[0].addTempDefenseBoost(-2);
}
}
};
target[0] = getTargetCard();
if(AllZone.GameAction.isCardInPlay(target[0]) && CardFactoryUtil.canTarget(card, target[0])) {
target[0].addTempAttackBoost(2);
target[0].addTempDefenseBoost(2);
AllZone.EndOfTurn.addUntil(untilEOT);
} else {
}
}//resolve()
};//SpellAbility
final Card crd = card;
final SpellAbility spell_two = new Spell(card) {
private static final long serialVersionUID = 3898017438147188882L;
@Override
public boolean canPlayAI() {
return getAttacker() != null;
}
@Override
public void chooseTargetAI() {
setTargetCard(getAttacker());
}
public Card getAttacker() {
//target creature that is going to attack
Combat c = ComputerUtil.getAttackers();
CardList list = new CardList(c.getAttackers());
CardListUtil.sortFlying(list);
Card[] att = list.toArray();
if(att.length != 0) return att[0];
else return null;
}//getAttacker()
@Override
public void resolve() {
final Card[] target = new Card[1];
final Command untilEOT = new Command() {
private static final long serialVersionUID = 280295105716586978L;
public void execute() {
if(AllZone.GameAction.isCardInPlay(target[0])) {
target[0].addTempAttackBoost(-2);
target[0].addTempDefenseBoost(-2);
}
}
};
target[0] = getTargetCard();
if(AllZone.GameAction.isCardInPlay(target[0]) && CardFactoryUtil.canTarget(card, target[0])) {
target[0].addTempAttackBoost(2);
target[0].addTempDefenseBoost(2);
AllZone.EndOfTurn.addUntil(untilEOT);
} else {
crd.clearReplaceMoveToGraveyardCommandList();
}
}//resolve()
};//SpellAbility
spell_two.setManaCost("4 G");
spell_two.setAdditionalManaCost("4");
spell_one.setDescription("Target creature gets +2/+2 until end of turn.");
spell_two.setDescription("Buyback 4 - Pay 4G, put this card into your hand as it resolves.");
spell_one.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell_one));
spell_two.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell_two));
spell_two.setIsBuyBackAbility(true);
card.clearSpellAbility();
card.addSpellAbility(spell_one);
card.addSpellAbility(spell_two);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Lab Rats")) {
final SpellAbility spell_one = new Spell(card) {
private static final long serialVersionUID = -8112024383172056976L;
@Override
public boolean canPlayAI() {
return false;
}
@Override
public void resolve() {
CardFactoryUtil.makeToken("Rat", "B 1 1 Rat", card, "B", new String[] {"Creature", "Rat"}, 1,
1, new String[] {""});
}//resolve()
};//SpellAbility
final SpellAbility spell_two = new Spell(card) {
private static final long serialVersionUID = -7503701530510847636L;
@Override
public void resolve() {
CardFactoryUtil.makeToken("Rat", "B 1 1 Rat", card, "B", new String[] {"Creature", "Rat"}, 1,
1, new String[] {""});
//return card to the hand
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
AllZone.GameAction.moveTo(hand, card);
}
@Override
public boolean canPlayAI() {
String phase = AllZone.Phase.getPhase();
return phase.equals(Constant.Phase.Main2);
}
};//SpellAbility
spell_one.setManaCost("B");
spell_two.setManaCost("4 B");
spell_two.setAdditionalManaCost("4");
spell_one.setDescription("Put a 1/1 black Rat token into play.");
spell_two.setDescription("Buyback 4 - Pay 4B, put this card into your hand as it resolves.");
spell_one.setStackDescription("Lab Rats - Put a 1/1 black Rat token into play");
spell_two.setStackDescription("Lab Rats - Buyback, Put a 1/1 black Rat token into play");
spell_two.setIsBuyBackAbility(true);
card.clearSpellAbility();
card.addSpellAbility(spell_one);
card.addSpellAbility(spell_two);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Sprout Swarm")) {
final SpellAbility spell_one = new Spell(card) {
private static final long serialVersionUID = -609007714604161377L;
@Override
public boolean canPlayAI() {
return false;
}
@Override
public void resolve() {
CardFactoryUtil.makeToken("Saproling", "G 1 1 Saproling", card, "G", new String[] {
"Creature", "Saproling"}, 1, 1, new String[] {""});
}//resolve()
};//SpellAbility
final SpellAbility spell_two = new Spell(card) {
private static final long serialVersionUID = -1387385820860395676L;
@Override
public void resolve() {
CardFactoryUtil.makeToken("Saproling", "G 1 1 Saproling", card, "G", new String[] {
"Creature", "Saproling"}, 1, 1, new String[] {""});
//return card to the hand
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
AllZone.GameAction.moveTo(hand, card);
}
};//SpellAbility
spell_one.setManaCost("1 G");
spell_two.setManaCost("4 G");
spell_two.setAdditionalManaCost("3");
spell_one.setDescription("Put a 1/1 green Saproling token into play.");
spell_two.setDescription("Buyback 3 - Pay 4G, put this card into your hand as it resolves.");
spell_one.setStackDescription("Sprout Swarm - Put a 1/1 green Saproling token into play");
spell_two.setStackDescription("Sprout Swarm - Buyback, Put a 1/1 green Saproling token into play");
spell_two.setIsBuyBackAbility(true);
card.clearSpellAbility();
card.addSpellAbility(spell_one);
card.addSpellAbility(spell_two);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Threaten") || cardName.equals("Act of Treason")) {
final PlayerZone[] orig = new PlayerZone[1];
final PlayerZone[] temp = new PlayerZone[1];
final String[] controllerEOT = new String[1];
final Card[] target = new Card[1];
final Command untilEOT = new Command() {
private static final long serialVersionUID = 5310901886760561889L;
public void execute() {
//if card isn't in play, do nothing
if(!AllZone.GameAction.isCardInPlay(target[0])) return;
target[0].setController(controllerEOT[0]);
((PlayerZone_ComesIntoPlay) AllZone.Human_Play).setTriggers(false);
((PlayerZone_ComesIntoPlay) AllZone.Computer_Play).setTriggers(false);
//moveTo() makes a new card, so you don't have to remove "Haste"
//AllZone.GameAction.moveTo(playEOT[0], target[0]);
temp[0].remove(target[0]);
orig[0].add(target[0]);
target[0].untap();
target[0].removeExtrinsicKeyword("Haste");
((PlayerZone_ComesIntoPlay) AllZone.Human_Play).setTriggers(true);
((PlayerZone_ComesIntoPlay) AllZone.Computer_Play).setTriggers(true);
}//execute()
};//Command
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -3447822168516135816L;
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
orig[0] = AllZone.getZone(getTargetCard());
controllerEOT[0] = getTargetCard().getController();
target[0] = getTargetCard();
//set the controller
getTargetCard().setController(card.getController());
((PlayerZone_ComesIntoPlay) AllZone.Human_Play).setTriggers(false);
((PlayerZone_ComesIntoPlay) AllZone.Computer_Play).setTriggers(false);
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
play.add(getTargetCard());
temp[0] = play;
orig[0].remove(getTargetCard());
((PlayerZone_ComesIntoPlay) AllZone.Human_Play).setTriggers(true);
((PlayerZone_ComesIntoPlay) AllZone.Computer_Play).setTriggers(true);
getTargetCard().untap();
getTargetCard().addExtrinsicKeyword("Haste");
AllZone.EndOfTurn.addUntil(untilEOT);
}//is card in play?
}//resolve()
@Override
public boolean canPlayAI() {
//only use this card if creatures power is greater than 2
CardList list = new CardList(AllZone.Human_Play.getCards());
for(int i = 0; i < list.size(); i++)
if(2 < list.get(i).getNetAttack()) return true;
return false;
}//canPlayAI()
@Override
public void chooseTargetAI() {
CardList list = new CardList(AllZone.Human_Play.getCards());
setTargetCard(CardFactoryUtil.AI_getBestCreature(list));
}
};//SpellAbility
spell.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Beacon of Unrest")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -7614131436905786565L;
@Override
public void resolve() {
Card c = getTargetCard();
PlayerZone grave = AllZone.getZone(c);
if(AllZone.GameAction.isCardInZone(c, grave) && (c.isArtifact() || c.isCreature())) {
//set the correct controller if needed
c.setController(card.getController());
//card changes zones
AllZone.getZone(c).remove(c);
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
play.add(c);
//shuffle card back into the library
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
library.add(card);
AllZone.GameAction.shuffle(card.getController());
}
}//resolve()
@Override
public boolean canPlay() {
return getCreaturesAndArtifacts().length != 0;
}
public Card[] getCreaturesAndArtifacts() {
CardList graveyardCards = new CardList();
graveyardCards.addAll(AllZone.Human_Graveyard.getCards());
graveyardCards.addAll(AllZone.Computer_Graveyard.getCards());
CardList graveyardCreaturesAndArtifacts = graveyardCards.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isArtifact() || c.isCreature();
}
});
return graveyardCreaturesAndArtifacts.toArray();
}
@Override
public void chooseTargetAI() {
Card c[] = getCreaturesAndArtifacts();
Card biggest = c[0];
for(int i = 0; i < c.length; i++)
if(biggest.getNetAttack() < c[i].getNetAttack()) biggest = c[i];
setTargetCard(biggest);
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
Input target = new Input() {
private static final long serialVersionUID = -83460850846474327L;
@Override
public void showMessage() {
Object check = AllZone.Display.getChoiceOptional("Select creature", getCreaturesAndArtifacts());
if(check != null) {
spell.setTargetCard((Card) check);
stopSetNext(new Input_PayManaCost(spell));
} else stop();
}//showMessage()
//duplicated from SpellAbility above ^^^^^^^^
public Card[] getCreaturesAndArtifacts() {
CardList graveyardCards = new CardList();
graveyardCards.addAll(AllZone.Human_Graveyard.getCards());
graveyardCards.addAll(AllZone.Computer_Graveyard.getCards());
CardList graveyardCreaturesAndArtifacts = graveyardCards.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isArtifact() || c.isCreature();
}
});
return graveyardCreaturesAndArtifacts.toArray();
}
};//Input
spell.setBeforePayMana(target);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Breath of Life") || cardName.equals("Resurrection")
|| cardName.equals("False Defeat") || cardName.equals("Zombify")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -5799646914112924814L;
@Override
public void resolve() {
Card c = getTargetCard();
PlayerZone grave = AllZone.getZone(c);
if(AllZone.GameAction.isCardInZone(c, grave)) {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, c.getController());
AllZone.GameAction.moveTo(play, c);
}
}//resolve()
@Override
public boolean canPlay() {
return getCreatures().length != 0;
}
public Card[] getCreatures() {
CardList creature = new CardList();
PlayerZone zone = AllZone.getZone(Constant.Zone.Graveyard, card.getController());
creature.addAll(zone.getCards());
creature = creature.getType("Creature");
return creature.toArray();
}
@Override
public void chooseTargetAI() {
Card c[] = getCreatures();
Card biggest = c[0];
for(int i = 0; i < c.length; i++)
if(biggest.getNetAttack() < c[i].getNetAttack()) biggest = c[i];
setTargetCard(biggest);
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
Input target = new Input() {
private static final long serialVersionUID = -3717723884199321767L;
@Override
public void showMessage() {
Object check = AllZone.Display.getChoiceOptional("Select creature", getCreatures());
if(check != null) {
spell.setTargetCard((Card) check);
stopSetNext(new Input_PayManaCost(spell));
} else stop();
}//showMessage()
public Card[] getCreatures() {
CardList creature = new CardList();
PlayerZone zone = AllZone.getZone(Constant.Zone.Graveyard, card.getController());
creature.addAll(zone.getCards());
creature = creature.getType("Creature");
return creature.toArray();
}
};//Input
spell.setBeforePayMana(target);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Animate Dead")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 182812167945075560L;
@Override
public void resolve() {
Card c = getTargetCard();
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
PlayerZone grave = AllZone.getZone(c);
if(AllZone.GameAction.isCardInZone(c, grave)) {
c.addSemiPermanentAttackBoost(-1);
c.setController(card.getController());
play.add(c);
grave.remove(c);
}
}//resolve()
@Override
public boolean canPlay() {
return getCreatures().length != 0;
}
public Card[] getCreatures() {
//get all creatures
CardList list = new CardList();
list.addAll(AllZone.Human_Graveyard.getCards());
list.addAll(AllZone.Computer_Graveyard.getCards());
list = list.getType("Creature");
return list.toArray();
}
@Override
public boolean canPlayAI() {
CardList all = new CardList(getCreatures());
if(all.isEmpty()) return false;
Card c = CardFactoryUtil.AI_getBestCreature(all);
if(2 < c.getNetAttack() && 2 < c.getNetDefense()) return true;
return false;
}
@Override
public void chooseTargetAI() {
Card c[] = getCreatures();
Card biggest = c[0];
for(int i = 0; i < c.length; i++)
if(biggest.getNetAttack() < c[i].getNetAttack()) biggest = c[i];
setTargetCard(biggest);
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
Input target = new Input() {
private static final long serialVersionUID = 9027742835781889044L;
@Override
public void showMessage() {
Object check = AllZone.Display.getChoiceOptional("Select creature", getCreatures());
if(check != null) {
spell.setTargetCard((Card) check);
stopSetNext(new Input_PayManaCost(spell));
} else stop();
}//showMessage()
public Card[] getCreatures() {
//get all creatures
CardList list = new CardList();
list.addAll(AllZone.Human_Graveyard.getCards());
list.addAll(AllZone.Computer_Graveyard.getCards());
list = list.getType("Creature");
return list.toArray();
}
};//Input
spell.setBeforePayMana(target);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Blinding Light")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -631672055247954361L;
@Override
public void resolve() {
CardList nonwhite = new CardList();
nonwhite.addAll(AllZone.Human_Play.getCards());
nonwhite.addAll(AllZone.Computer_Play.getCards());
nonwhite = nonwhite.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isCreature() && (!CardUtil.getColors(c).contains(Constant.Color.White));
}
});
for(int i = 0; i < nonwhite.size(); i++)
nonwhite.get(i).tap();
}//resolve()
@Override
public boolean canPlayAI() {
//the computer seems to play this card at stupid times
return false;
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Ensnare")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -5170378205496330425L;
@Override
public void resolve() {
CardList creats = new CardList();
creats.addAll(AllZone.Human_Play.getCards());
creats.addAll(AllZone.Computer_Play.getCards());
creats = creats.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isCreature();
}
});
for(int i = 0; i < creats.size(); i++)
creats.get(i).tap();
}//resolve()
@Override
public boolean canPlayAI() {
return false;
}
};
spell.setDescription("Tap all creatures.");
spell.setStackDescription(card.getName() + " - Tap all creatures");
final SpellAbility bounce = new Spell(card) {
private static final long serialVersionUID = 6331598238749406160L;
@Override
public void resolve() {
CardList creats = new CardList();
creats.addAll(AllZone.Human_Play.getCards());
creats.addAll(AllZone.Computer_Play.getCards());
creats = creats.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isCreature();
}
});
for(int i = 0; i < creats.size(); i++)
creats.get(i).tap();
}
@Override
public boolean canPlay() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList list = new CardList(play.getCards());
list = list.getType("Island");
return list.size() >= 2;
}
@Override
public boolean canPlayAI() {
return false;
}
};
bounce.setDescription("You may return two Islands you control to their owner's hand rather than pay Ensnare's mana cost.");
bounce.setStackDescription(card.getName() + " - Tap all creatures.");
bounce.setManaCost("0");
final Input bounceIslands = new Input() {
private static final long serialVersionUID = -8511915834608321343L;
int stop = 2;
int count = 0;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select an Island");
ButtonUtil.disableAll();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card c, PlayerZone zone) {
if(c.getType().contains("Island") && zone.is(Constant.Zone.Play)) {
AllZone.GameAction.moveToHand(c);
count++;
if(count == stop) {
AllZone.Stack.add(bounce);
stop();
}
}
}//selectCard()
};
bounce.setBeforePayMana(bounceIslands);
Command bounceIslandsAI = new Command() {
private static final long serialVersionUID = 6399831162328201755L;
public void execute() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
CardList list = new CardList(play.getCards());
list = list.getType("Island");
//TODO: sort by tapped
for(int i = 0; i < 2; i++) {
AllZone.GameAction.moveToHand(list.get(i));
}
}
};
bounce.setBeforePayManaAI(bounceIslandsAI);
card.clearSpellAbility();
card.addSpellAbility(bounce);
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Raise the Alarm")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 3022771853846089829L;
@Override
public void resolve() {
for(int i = 0; i < 2; i++)
CardFactoryUtil.makeToken("Soldier", "W 1 1 Soldier", card, "W", new String[] {
"Creature", "Soldier"}, 1, 1, new String[] {""});
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Dragon Fodder")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -6704097906643840324L;
@Override
public void resolve() {
for(int i = 0; i < 2; i++) {
CardFactoryUtil.makeToken("Goblin", "R 1 1 Goblin", card, "R", new String[] {
"Creature", "Goblin"}, 1, 1, new String[] {""});
}//for
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Empty the Warrens")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 1439643889038241969L;
@Override
public void resolve() {
int stormCount = 0;
//get storm count
CardList list = new CardList();
list.addAll(AllZone.Human_Graveyard.getCards());
list.addAll(AllZone.Computer_Graveyard.getCards());
list.addAll(AllZone.Human_Play.getCards());
list.addAll(AllZone.Computer_Play.getCards());
for(int i = 0; i < list.size(); i++)
if(list.get(i).getTurnInZone() == AllZone.Phase.getTurn()) stormCount++;
for(int i = 0; i < 2 * stormCount; i++)
CardFactoryUtil.makeToken("Goblin", "R 1 1 Goblin", card, "R", new String[] {
"Creature", "Goblin"}, 1, 1, new String[] {""});
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Feudkiller's Verdict")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -5532477141899236266L;
@Override
public void resolve() {
PlayerLife life = AllZone.GameAction.getPlayerLife(card.getController());
life.addLife(10);
String opponent = AllZone.GameAction.getOpponent(card.getController());
PlayerLife oppLife = AllZone.GameAction.getPlayerLife(opponent);
if(oppLife.getLife() < life.getLife()) makeToken();
}//resolve()
void makeToken() {
CardFactoryUtil.makeToken("Giant Warrior", "W 5 5 Giant Warrior", card, "W", new String[] {
"Creature", "Giant", "Warrior"}, 5, 5, new String[] {""});
}//makeToken()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Reach of Branches")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 2723115210677439611L;
@Override
public void resolve() {
CardFactoryUtil.makeToken("Treefolk Shaman", "G 2 5 Treefolk Shaman", card, "G", new String[] {
"Creature", "Treefolk", "Shaman"}, 2, 5, new String[] {""});
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Pyroclasm")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 8035123529251645470L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
all = all.getType("Creature");
for(int i = 0; i < all.size(); i++) {
if(CardFactoryUtil.canDamage(card, all.get(i))) all.get(i).addDamage(2, card);
}
}
@Override
public boolean canPlayAI() {
CardList human = new CardList(AllZone.Human_Play.getCards());
CardList computer = new CardList(AllZone.Computer_Play.getCards());
human = human.getType("Creature");
computer = computer.getType("Creature");
human = CardListUtil.filterToughness(human, 2);
computer = CardListUtil.filterToughness(computer, 2);
//the computer will at least destroy 2 more human creatures
return computer.size() < human.size() - 1;
}//canPlayAI()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Volcanic Fallout")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 8274309635261086286L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
all = all.getType("Creature");
for(int i = 0; i < all.size(); i++) {
if(CardFactoryUtil.canDamage(card, all.get(i))) all.get(i).addDamage(2, card);
}
PlayerLife compLife = AllZone.GameAction.getPlayerLife(Constant.Player.Computer);
compLife.subtractLife(2);
PlayerLife humLife = AllZone.GameAction.getPlayerLife(Constant.Player.Human);
humLife.subtractLife(2);
}
@Override
public boolean canPlayAI() {
CardList human = new CardList(AllZone.Human_Play.getCards());
CardList computer = new CardList(AllZone.Computer_Play.getCards());
human = human.getType("Creature");
computer = computer.getType("Creature");
human = CardListUtil.filterToughness(human, 2);
computer = CardListUtil.filterToughness(computer, 2);
PlayerLife compLife = AllZone.GameAction.getPlayerLife(Constant.Player.Computer);
//the computer will at least destroy 2 more human creatures
return computer.size() < human.size() - 1 && compLife.getLife() > 3;
}//canPlayAI()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Flamebreak")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -4224693616606508949L;
@Override
public boolean canPlayAI() {
return AllZone.Computer_Life.getLife() > 3;
}
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
all = all.getType("Creature");
for(int i = 0; i < all.size(); i++)
if(!all.get(i).getKeyword().contains("Flying")) {
if(CardFactoryUtil.canDamage(card, all.get(i))) {
all.get(i).setShield(0);
all.get(i).addDamage(3, card);
}
}
AllZone.Human_Life.subtractLife(3);
AllZone.Computer_Life.subtractLife(3);
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Renewed Faith") || cardName.equals("Rejuvenate")
|| cardName.equals("Dosan's Oldest Chant") || cardName.equals("Nourish")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -1133816506198725425L;
@Override
public boolean canPlay() {
setStackDescription(card.getName() + " - " + card.getController() + " gains 6 life.");
return super.canPlay();
}
@Override
public void resolve() {
PlayerLife life = AllZone.GameAction.getPlayerLife(card.getController());
life.addLife(6);
}
};
String desc = "You gain 6 life.";
if(cardName.equals("Renewed Faith")) desc = desc
+ "\r\nWhen you cycle Renewed Faith, you may gain 2 life.";
spell.setDescription(desc);
card.clearSpellAbility();
card.addSpellAbility(spell);
if(cardName.equals("Renewed Faith")) {
// card.addSpellAbility(CardFactoryUtil.ability_cycle(card, "1 W"));
card.addCycleCommand(new Command() {
private static final long serialVersionUID = 7699412574052780825L;
public void execute() {
PlayerLife life = AllZone.GameAction.getPlayerLife(card.getController());
life.addLife(2);
}
});
}
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("TestLife")) {
SpellAbility ability1 = new Ability_Activated(card, "1") {
private static final long serialVersionUID = -7597743923692184213L;
@Override
public void resolve() {
PlayerLife life = AllZone.GameAction.getPlayerLife(card.getController());
life.addLife(1);
}
};
ability1.setStackDescription(card.getController() + " gains 1 life");
ability1.setDescription("1: gain 1 life");
card.addSpellAbility(ability1);
SpellAbility ability2 = new Ability_Activated(card, "1") {
private static final long serialVersionUID = 1423759257249171223L;
@Override
public void resolve() {
PlayerLife life = AllZone.GameAction.getPlayerLife(card.getController());
life.subtractLife(1);
}
};
ability2.setStackDescription(card.getController() + " looses 1 life");
ability2.setDescription("1: loose 1 life");
card.addSpellAbility(ability2);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Life Burst")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 5653342880372240806L;
@Override
public void resolve() {
CardList count = new CardList();
count.addAll(AllZone.Human_Graveyard.getCards());
count.addAll(AllZone.Computer_Graveyard.getCards());
count = count.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.getName().equals("Life Burst");
}
});
PlayerLife life = AllZone.GameAction.getPlayerLife(getTargetPlayer());
life.addLife(4 + (4 * count.size()));
}
};
spell.setChooseTargetAI(CardFactoryUtil.AI_targetComputer());
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Accumulated Knowledge")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -7650377883588723237L;
@Override
public void resolve() {
CardList count = new CardList();
count.addAll(AllZone.Human_Graveyard.getCards());
count.addAll(AllZone.Computer_Graveyard.getCards());
count = count.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.getName().equals("Accumulated Knowledge");
}
});
for(int i = 0; i <= count.size(); i++) {
AllZone.GameAction.drawCard(card.getController());
}
}
};
spell.setDescription("Draw a card, then draw cards equal to the number of cards named Accumulated Knowledge in all graveyards.");
spell.setStackDescription(cardName
+ " - Draw a card, then draw cards equal to the number of cards named Accumulated Knowledge in all graveyards.");
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Wit's End")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 3829311830858468029L;
@Override
public void resolve() {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, getTargetPlayer());
Card c[] = hand.getCards();
for(int i = 0; i < c.length; i++)
AllZone.GameAction.discard(c[i]);
}
};
spell.setChooseTargetAI(CardFactoryUtil.AI_targetHuman());
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Cranial Extraction")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 8127696608769903507L;
@Override
@SuppressWarnings("unchecked")
// Comparator
public void resolve() {
String opponent = AllZone.GameAction.getOpponent(card.getController());
Card choice = null;
//check for no cards in library
PlayerZone library = AllZone.getZone(Constant.Zone.Library, opponent);
if(library.size() == 0) //this is not right, but leaving it in here for now.
return;
//human chooses
if(opponent.equals(Constant.Player.Computer)) {
CardList all = AllZone.CardFactory.getAllCards();
all.sort(new Comparator() {
public int compare(Object a1, Object b1) {
Card a = (Card) a1;
Card b = (Card) b1;
return a.getName().compareTo(b.getName());
}
});
choice = AllZone.Display.getChoice("Choose", removeLand(all.toArray()));
Card[] showLibrary = library.getCards();
Comparator com = new TableSorter(new CardList(showLibrary), 2, true);
Arrays.sort(showLibrary, com);
AllZone.Display.getChoiceOptional("Opponent's Library", showLibrary);
AllZone.GameAction.shuffle(opponent);
}//if
else//computer chooses
{
//the computer cheats by choosing a creature in the human players library or hand
CardList all = new CardList();
all.addAll(AllZone.Human_Hand.getCards());
all.addAll(AllZone.Human_Library.getCards());
CardList four = all.filter(new CardListFilter() {
public boolean addCard(Card c) {
if(c.isLand()) return false;
return 3 < CardUtil.getConvertedManaCost(c.getManaCost());
}
});
if(!four.isEmpty()) choice = CardUtil.getRandom(four.toArray());
else choice = CardUtil.getRandom(all.toArray());
}//else
remove(choice, opponent);
AllZone.GameAction.shuffle(opponent);
}//resolve()
void remove(Card c, String player) {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, player);
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, player);
PlayerZone library = AllZone.getZone(Constant.Zone.Library, player);
CardList all = new CardList();
all.addAll(hand.getCards());
all.addAll(grave.getCards());
all.addAll(library.getCards());
for(int i = 0; i < all.size(); i++)
if(all.get(i).getName().equals(c.getName())) {
if(player.equals(Constant.Player.Human)) {
AllZone.GameAction.moveTo(AllZone.Human_Removed, all.get(i));
} else {
AllZone.GameAction.moveTo(AllZone.Computer_Removed, all.get(i));
}
}
}//remove()
@Override
public boolean canPlayAI() {
Card[] c = removeLand(AllZone.Human_Library.getCards());
return 0 < c.length;
}
Card[] removeLand(Card[] in) {
CardList c = new CardList(in);
c = c.filter(new CardListFilter() {
public boolean addCard(Card c) {
return !c.isLand();
}
});
return c.toArray();
}//removeLand()
};//SpellAbility spell
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(new Input_PayManaCost(spell));
spell.setStackDescription(card.getName() + " - targeting opponent");
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Coercion")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 7200945225788294439L;
@Override
public void resolve() {
String opponent = AllZone.GameAction.getOpponent(card.getController());
Card choice = null;
//check for no cards in hand on resolve
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, opponent);
Card[] handChoices = removeLand(hand.getCards());
if(handChoices.length == 0) return;
//human chooses
if(opponent.equals(Constant.Player.Computer)) {
choice = AllZone.Display.getChoice("Choose", handChoices);
} else//computer chooses
{
choice = CardUtil.getRandom(handChoices);
}
AllZone.GameAction.discard(choice);
}//resolve()
@Override
public boolean canPlayAI() {
Card[] c = removeLand(AllZone.Human_Hand.getCards());
return 0 < c.length;
}
Card[] removeLand(Card[] in) {
return in;
}//removeLand()
};//SpellAbility spell
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(new Input_PayManaCost(spell));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Brainbite")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 6967309558624188256L;
@Override
public void resolve() {
String opponent = AllZone.GameAction.getOpponent(card.getController());
Card choice = null;
//check for no cards in hand on resolve
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, opponent);
Card[] handChoices = removeLand(hand.getCards());
if(handChoices.length == 0) {
// AllZone.GameAction.drawCard(card.getController());
return;
}
//human chooses
if(opponent.equals(Constant.Player.Computer)) {
choice = AllZone.Display.getChoice("Choose", handChoices);
} else//computer chooses
{
choice = CardUtil.getRandom(handChoices);
}
AllZone.GameAction.discard(choice);
AllZone.GameAction.drawCard(card.getController());
}//resolve()
@Override
public boolean canPlayAI() {
Card[] c = removeLand(AllZone.Human_Hand.getCards());
return 0 < c.length;
}
Card[] removeLand(Card[] in) {
return in;
}//removeLand()
};//SpellAbility spell
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(new Input_PayManaCost(spell));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Thoughtseize") || cardName.equals("Distress")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 5338238621454661783L;
@Override
public void resolve() {
if(cardName.equals("Thoughtseize")) AllZone.GameAction.getPlayerLife(card.getController()).subtractLife(
2);
Card choice = null;
//check for no cards in hand on resolve
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, getTargetPlayer());
CardList fullHand = new CardList(hand.getCards());
Card[] handChoices = removeLand(hand.getCards());
if(fullHand.size() > 0 && card.getController().equals(Constant.Player.Human)) AllZone.Display.getChoice(
"Revealing hand", fullHand.toArray());
if(handChoices.length == 0) return;
//human chooses
if(card.getController().equals(Constant.Player.Human)) {
choice = AllZone.Display.getChoice("Choose", handChoices);
} else//computer chooses
{
choice = CardUtil.getRandom(handChoices);
}
AllZone.GameAction.discard(choice);
}//resolve()
@Override
public boolean canPlayAI() {
Card[] c = removeLand(AllZone.Human_Hand.getCards());
return 0 < c.length;
}
Card[] removeLand(Card[] in) {
CardList c = new CardList(in);
c = c.filter(new CardListFilter() {
public boolean addCard(Card c) {
return !c.isLand();
}
});
return c.toArray();
}//removeLand()
};//SpellAbility spell
spell.setChooseTargetAI(CardFactoryUtil.AI_targetHuman());
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Echoing Decay")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 3154935854257358023L;
@Override
public boolean canPlayAI() {
CardList c = getCreature();
if(c.isEmpty()) return false;
else {
setTargetCard(c.get(0));
return true;
}
}//canPlayAI()
CardList getCreature() {
CardList out = new CardList();
CardList list = CardFactoryUtil.AI_getHumanCreature("Flying", card, true);
list.shuffle();
for(int i = 0; i < list.size(); i++)
if((list.get(i).getNetAttack() >= 2) && (list.get(i).getNetDefense() <= 2)) out.add(list.get(i));
//in case human player only has a few creatures in play, target anything
if(out.isEmpty() && 0 < CardFactoryUtil.AI_getHumanCreature(2, card, true).size()
&& 3 > CardFactoryUtil.AI_getHumanCreature(card, true).size()) {
out.addAll(CardFactoryUtil.AI_getHumanCreature(2, card, true).toArray());
CardListUtil.sortFlying(out);
}
return out;
}//getCreature()
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
final Card c = getTargetCard();
c.addTempAttackBoost(-2);
c.addTempDefenseBoost(-2);
AllZone.EndOfTurn.addUntil(new Command() {
private static final long serialVersionUID = 1327455269456577020L;
public void execute() {
c.addTempAttackBoost(2);
c.addTempDefenseBoost(2);
}
});
//get all creatures
CardList list = new CardList();
list.addAll(AllZone.Human_Play.getCards());
list.addAll(AllZone.Computer_Play.getCards());
list = list.getName(getTargetCard().getName());
list.remove(getTargetCard());
if(!getTargetCard().isFaceDown()) for(int i = 0; i < list.size(); i++) {
final Card crd = list.get(i);
crd.addTempAttackBoost(-2);
crd.addTempDefenseBoost(-2);
AllZone.EndOfTurn.addUntil(new Command() {
private static final long serialVersionUID = 5151337777143949221L;
public void execute() {
crd.addTempAttackBoost(2);
crd.addTempDefenseBoost(2);
}
});
//list.get(i).addDamage(2);
}
}//in play?
}//resolve()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Maelstrom Pulse")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -4050843868789582138L;
@Override
public boolean canPlayAI() {
CardList c = getCreature();
if(c.isEmpty()) return false;
else {
setTargetCard(c.get(0));
return true;
}
}//canPlayAI()
CardList getCreature() {
CardList out = new CardList();
CardList list = CardFactoryUtil.AI_getHumanCreature("Flying", card, true);
list.shuffle();
for(int i = 0; i < list.size(); i++)
if((list.get(i).getNetAttack() >= 2) && (list.get(i).getNetDefense() <= 2)) out.add(list.get(i));
//in case human player only has a few creatures in play, target anything
if(out.isEmpty() && 0 < CardFactoryUtil.AI_getHumanCreature(2, card, true).size()
&& 3 > CardFactoryUtil.AI_getHumanCreature(card, true).size()) {
out.addAll(CardFactoryUtil.AI_getHumanCreature(2, card, true).toArray());
CardListUtil.sortFlying(out);
}
return out;
}//getCreature()
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
AllZone.GameAction.destroy(getTargetCard());
if(!getTargetCard().isFaceDown()) {
//get all creatures
CardList list = new CardList();
list.addAll(AllZone.Human_Play.getCards());
list.addAll(AllZone.Computer_Play.getCards());
list = list.getName(getTargetCard().getName());
list.remove(getTargetCard());
if(!getTargetCard().isFaceDown()) for(int i = 0; i < list.size(); i++)
AllZone.GameAction.destroy(list.get(i));
}//is token?
}//in play?
}//resolve()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
Input target = new Input() {
private static final long serialVersionUID = -4947592326270275532L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target non-land permanent for " + spell.getSourceCard());
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card card, PlayerZone zone) {
if(zone.is(Constant.Zone.Play) && !card.isLand()) {
spell.setTargetCard(card);
if(this.isFree()) {
this.setFree(false);
AllZone.Stack.add(spell);
stop();
} else stopSetNext(new Input_PayManaCost(spell));
}
}
};//Input
spell.setBeforePayMana(target);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Sunlance")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -8327380630150660908L;
int damage = 3;
Card check;
@Override
public boolean canPlayAI() {
check = getFlying();
return check != null;
}
@Override
public void chooseTargetAI() {
Card c = getFlying();
if((c == null) || (!check.equals(c))) throw new RuntimeException(card
+ " error in chooseTargetAI() - Card c is " + c + ", Card check is " + check);
setTargetCard(c);
}//chooseTargetAI()
//uses "damage" variable
Card getFlying() {
CardList flying = CardFactoryUtil.AI_getHumanCreature("Flying", card, true);
for(int i = 0; i < flying.size(); i++)
if(flying.get(i).getNetDefense() <= damage
&& (!CardUtil.getColors(flying.get(i)).contains(Constant.Color.White))) {
return flying.get(i);
}
return null;
}
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
Card c = getTargetCard();
c.addDamage(damage, card);
}
}//resolve()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
//target
Input target = new Input() {
private static final long serialVersionUID = -579427555773493417L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target non-white creature for " + spell.getSourceCard());
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card card, PlayerZone zone) {
if((!CardUtil.getColors(card).contains(Constant.Color.White)) && card.isCreature()
&& zone.is(Constant.Zone.Play)) {
spell.setTargetCard(card);
if (this.isFree())
{
this.setFree(false);
AllZone.Stack.add(spell);
stop();
}
else
stopSetNext(new Input_PayManaCost(spell));
}
}
};//SpellAbility - target
spell.setBeforePayMana(target);
}//*************** END ************ END **************************
/*
//*************** START *********** START **************************
else if(cardName.equals("Saltblast"))
{
final SpellAbility spell = new Spell(card)
{
private static final long serialVersionUID = -8701870029034823295L;
Card check;
public boolean canPlayAI()
{
check = getFlying();
return check != null;
}
public void chooseTargetAI()
{
Card c = getFlying();
if((c == null) || (! check.equals(c)))
throw new RuntimeException(card +" error in chooseTargetAI() - Card c is " +c +", Card check is " +check);
setTargetCard(c);
}//chooseTargetAI()
//uses "damage" variable
Card getFlying()
{
CardList flying = CardFactoryUtil.AI_getHumanCreature("Flying", card, true);
for(int i = 0; i < flying.size(); i++)
if(!CardUtil.getColors(flying.get(i)).contains(Constant.Color.White))
{
return flying.get(i);
}
return null;
}
public void resolve()
{
if(AllZone.GameAction.isCardInPlay(getTargetCard()) && CardFactoryUtil.canTarget(card, getTargetCard()) )
{
Card c = getTargetCard();
if(AllZone.GameAction.isCardInPlay(c))
AllZone.GameAction.destroy(c);
}
}//resolve()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
//target
Input target = new Input()
{
private static final long serialVersionUID = 6040042391157137555L;
public void showMessage()
{
AllZone.Display.showMessage("Select target non-white permanent for " +spell.getSourceCard());
ButtonUtil.enableOnlyCancel();
}
public void selectButtonCancel() {stop();}
public void selectCard(Card card, PlayerZone zone)
{
if((!CardUtil.getColors(card).contains(Constant.Color.White)) &&
zone.is(Constant.Zone.Play))
{
spell.setTargetCard(card);
stopSetNext(new Input_PayManaCost(spell));
}
}
};//SpellAbility - target
spell.setBeforePayMana(target);
}//*************** END ************ END **************************
*/
//*************** START *********** START **************************
else if(cardName.equals("Firebolt")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -4100322462753117988L;
int damage = 2;
Card check;
@Override
public boolean canPlayAI() {
PlayerZone compHand = AllZone.getZone(Constant.Zone.Hand, Constant.Player.Computer);
CardList hand = new CardList(compHand.getCards());
if(AllZone.Human_Life.getLife() <= damage) return AllZone.GameAction.isCardInZone(card,
compHand);
if(hand.size() >= 8) return true && AllZone.GameAction.isCardInZone(card, compHand);
check = getFlying();
return check != null && AllZone.GameAction.isCardInZone(card, compHand);
}
@Override
public void chooseTargetAI() {
if(AllZone.Human_Life.getLife() <= damage) {
setTargetPlayer(Constant.Player.Human);
return;
}
Card c = getFlying();
if((c == null) || (!check.equals(c))) throw new RuntimeException(card
+ " error in chooseTargetAI() - Card c is " + c + ", Card check is " + check);
setTargetCard(c);
}//chooseTargetAI()
//uses "damage" variable
Card getFlying() {
CardList flying = CardFactoryUtil.AI_getHumanCreature("Flying", card, true);
for(int i = 0; i < flying.size(); i++)
if(flying.get(i).getNetDefense() <= damage) return flying.get(i);
return null;
}
@Override
public void resolve() {
if(getTargetCard() != null) {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
Card c = getTargetCard();
c.addDamage(damage, card);
}
} else AllZone.GameAction.getPlayerLife(getTargetPlayer()).subtractLife(damage);
}
};//SpellAbility
final SpellAbility flashback = new Spell(card) {
private static final long serialVersionUID = -4811352682106571233L;
int damage = 2;
Card check;
@Override
public boolean canPlay() {
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, card.getController());
String phase = AllZone.Phase.getPhase();
String activePlayer = AllZone.Phase.getActivePlayer();
return AllZone.GameAction.isCardInZone(card, grave)
&& ((phase.equals(Constant.Phase.Main1) || phase.equals(Constant.Phase.Main2))
&& card.getController().equals(activePlayer) && AllZone.Stack.size() == 0);
}
@Override
public boolean canPlayAI() {
if(AllZone.Human_Life.getLife() <= damage) return true;
check = getFlying();
return check != null;
}
@Override
public void chooseTargetAI() {
if(AllZone.Human_Life.getLife() <= damage) {
setTargetPlayer(Constant.Player.Human);
return;
}
Card c = getFlying();
if((c == null) || (!check.equals(c))) throw new RuntimeException(card
+ " error in chooseTargetAI() - Card c is " + c + ", Card check is " + check);
setTargetCard(c);
}//chooseTargetAI()
//uses "damage" variable
Card getFlying() {
CardList flying = CardFactoryUtil.AI_getHumanCreature("Flying", card, true);
for(int i = 0; i < flying.size(); i++)
if(flying.get(i).getNetDefense() <= damage) return flying.get(i);
return null;
}
@Override
public void resolve() {
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, card.getController());
PlayerZone removed = AllZone.getZone(Constant.Zone.Removed_From_Play, card.getController());
if(getTargetCard() != null) {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
Card c = getTargetCard();
c.addDamage(damage, card);
}
} else AllZone.GameAction.getPlayerLife(getTargetPlayer()).subtractLife(damage);
grave.remove(card);
removed.add(card);
}
};//flashback
flashback.setFlashBackAbility(true);
flashback.setManaCost("4 R");
flashback.setBeforePayMana(CardFactoryUtil.input_targetCreaturePlayer(flashback, true, false));
flashback.setDescription("Flashback: 4R");
card.clearSpellAbility();
card.addSpellAbility(spell);
card.addSpellAbility(flashback);
spell.setBeforePayMana(CardFactoryUtil.input_targetCreaturePlayer(spell, true, false));
card.setFlashback(true);
}//*************** END ************ END **************************
/*
//*************** START *********** START **************************
else if(cardName.equals("Spark Spray"))
{
final SpellAbility spell = new Spell(card)
{
private static final long serialVersionUID = 6619448976712515187L;
public void chooseTargetAI()
{
setStackDescription("Spark Spray cycling - Computer draws a card");
}//chooseTargetAI()
public void resolve()
{
if(card.getController().equals(Constant.Player.Computer))
{
AllZone.GameAction.drawCard(Constant.Player.Computer);
return;
}
if(getTargetCard() != null)
{
if(AllZone.GameAction.isCardInPlay(getTargetCard()) && CardFactoryUtil.canTarget(card, getTargetCard()) )
{
Card c = getTargetCard();
c.addDamage(1, card);
}
}
else
AllZone.GameAction.getPlayerLife(getTargetPlayer()).subtractLife(1);
}
};//SpellAbility
spell.setDescription("Spark Spray deals 1 damage to target creature or player.");
card.clearSpellAbility();
card.addSpellAbility(spell);
card.addSpellAbility(CardFactoryUtil.ability_cycle(card, "R"));
spell.setBeforePayMana(CardFactoryUtil.input_targetCreaturePlayer(spell,true));
}//*************** END ************ END **************************
*/
//*************** START *********** START **************************
else if(cardName.equals("Erratic Explosion")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -6003403347798646257L;
int damage = 3;
Card check;
@Override
public boolean canPlayAI() {
if(AllZone.Human_Life.getLife() <= damage) return true;
check = getFlying();
return check != null;
}
@Override
public void chooseTargetAI() {
if(AllZone.Human_Life.getLife() <= damage) {
setTargetPlayer(Constant.Player.Human);
return;
}
Card c = getFlying();
if((c == null) || (!check.equals(c))) throw new RuntimeException(card
+ " error in chooseTargetAI() - Card c is " + c + ", Card check is " + check);
setTargetCard(c);
}//chooseTargetAI()
//uses "damage" variable
Card getFlying() {
CardList flying = CardFactoryUtil.AI_getHumanCreature("Flying", card, true);
for(int i = 0; i < flying.size(); i++)
if(flying.get(i).getNetDefense() <= damage) return flying.get(i);
return null;
}
@Override
public void resolve() {
int damage = getDamage();
if(getTargetCard() != null) {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
javax.swing.JOptionPane.showMessageDialog(null, "Erratic Explosion causes " + damage
+ " to " + getTargetCard());
Card c = getTargetCard();
c.addDamage(damage, card);
}
} else {
javax.swing.JOptionPane.showMessageDialog(null, "Erratic Explosion causes " + damage
+ " to " + getTargetPlayer());
AllZone.GameAction.getPlayerLife(getTargetPlayer()).subtractLife(damage);
}
}
//randomly choose a nonland card
int getDamage() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
CardList notLand = new CardList(library.getCards());
notLand = notLand.filter(new CardListFilter() {
public boolean addCard(Card c) {
return !c.isLand();
}
});
notLand.shuffle();
if(notLand.isEmpty()) return 0;
Card card = notLand.get(0);
return CardUtil.getConvertedManaCost(card.getSpellAbility()[0]);
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(CardFactoryUtil.input_targetCreaturePlayer(spell, true, false));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Hidetsugu's Second Rite")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 176857775451818523L;
@Override
public void resolve() {
PlayerLife life = AllZone.GameAction.getPlayerLife(getTargetPlayer());
if(life.getLife() == 10) life.subtractLife(10);
}
@Override
public boolean canPlay() {
String opponent = AllZone.GameAction.getOpponent(card.getController());
PlayerLife p = AllZone.GameAction.getPlayerLife(opponent);
return p.getLife() == 10;
}
};
spell.setChooseTargetAI(CardFactoryUtil.AI_targetHuman());
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Soulscour")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -4554873222565897972L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
all = all.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isPermanent() && !c.isArtifact();
}
});
CardListUtil.sortByIndestructible(all);
CardListUtil.sortByDestroyEffect(all);
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
AllZone.GameAction.destroy(c);
}
}// resolve()
@Override
public boolean canPlayAI() {
CardList human = new CardList(AllZone.Human_Play.getCards());
CardList computer = new CardList(AllZone.Computer_Play.getCards());
human = human.getType("Creature");
computer = computer.getType("Creature");
// the computer will at least destroy 2 more human creatures
return computer.size() < human.size() - 1
|| (AllZone.Computer_Life.getLife() < 7 && !human.isEmpty());
}
};// SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}// *************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("March of Souls")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -1468254925312413359L;
@Override
public void resolve() {
change(AllZone.Human_Play, card.getController());
change(AllZone.Computer_Play, card.getController());
}
public void change(PlayerZone play, String owner) {
Card[] c = play.getCards();
for(int i = 0; i < c.length; i++) {
if(c[i].isCreature()) {
AllZone.GameAction.destroyNoRegeneration(c[i]);
CardFactoryUtil.makeToken("Spirit", "W 1 1 Spirit", c[i], "W", new String[] {
"Creature", "Spirit"}, 1, 1, new String[] {"Flying"});
}
}
}//change()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Wrath of God") || cardName.equals("Damnation")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -18728406578984546L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
all = all.getType("Creature");
CardListUtil.sortByIndestructible(all);
CardListUtil.sortByDestroyEffect(all);
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
System.out.println("WOG: " + c);
AllZone.GameAction.destroyNoRegeneration(c);
}
}// resolve()
@Override
public boolean canPlayAI() {
CardList human = new CardList(AllZone.Human_Play.getCards());
CardList computer = new CardList(AllZone.Computer_Play.getCards());
human = human.getType("Creature");
computer = computer.getType("Creature");
// the computer will at least destroy 2 more human creatures
return AllZone.Phase.getPhase().equals(Constant.Phase.Main2) &&
(computer.size() < human.size() - 1
|| (AllZone.Computer_Life.getLife() < 7 && !human.isEmpty()));
}
};// SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}// *************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Day of Judgment")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -2916641841124966207L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
if(c.isCreature()) AllZone.GameAction.destroy(c);
}
}// resolve()
@Override
public boolean canPlayAI() {
CardList human = new CardList(AllZone.Human_Play.getCards());
CardList computer = new CardList(AllZone.Computer_Play.getCards());
human = human.getType("Creature");
computer = computer.getType("Creature");
// the computer will at least destroy 2 more human creatures
return computer.size() < human.size() - 1
|| (AllZone.Computer_Life.getLife() < 7 && !human.isEmpty());
}
};// SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}// *************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Planar Cleansing")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -4233719265268955876L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
if(c.isPermanent() && !c.isLand()) AllZone.GameAction.destroy(c);
}
}// resolve()
@Override
public boolean canPlayAI() {
CardList human = new CardList(AllZone.Human_Play.getCards());
CardList computer = new CardList(AllZone.Computer_Play.getCards());
human = human.getType("Creature");
computer = computer.getType("Creature");
// the computer will at least destroy 2 more human creatures
return computer.size() < human.size() - 1
|| (AllZone.Computer_Life.getLife() < 7 && !human.isEmpty());
}
};// SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}// *************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Tranquility") || cardName.equals("Tempest of Light")
|| cardName.equals("Cleanfall") || cardName.equals("Hush")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 3087098751201624354L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
all = all.getType("Enchantment");
CardListUtil.sortByIndestructible(all);
CardListUtil.sortByDestroyEffect(all);
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
AllZone.GameAction.destroy(c);
}
}// resolve()
@Override
public boolean canPlayAI() {
CardList human = new CardList(AllZone.Human_Play.getCards());
CardList computer = new CardList(AllZone.Computer_Play.getCards());
human = human.getType("Enchantment");
computer = computer.getType("Enchantment");
if(human.size() == 0) return false;
// the computer will at least destroy 2 more human enchantments
return computer.size() < human.size() - 1
|| (AllZone.Computer_Life.getLife() < 7 && !human.isEmpty());
}
};// SpellAbility
spell.setDescription("Destroy all enchantments.");
spell.setStackDescription(card.getName() + " - destroy all enchantments.");
card.clearSpellAbility();
card.addSpellAbility(spell);
}// *************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Incendiary Command")) {
//not sure what to call variables, so I just made up something
final String[] m_player = new String[1];
final Card[] m_land = new Card[1];
final ArrayList<String> userChoice = new ArrayList<String>();
final String[] cardChoice = {
"Incendiary Command deals 4 damage to target player",
"Incendiary Command deals 2 damage to each creature", "Destroy target nonbasic land",
"Each player discards all cards in his or her hand, then draws that many cards"};
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 9178547049760990376L;
@Override
public void resolve() {
// System.out.println(userChoice);
// System.out.println(m_land[0]);
// System.out.println(m_player[0]);
//"Incendiary Command deals 4 damage to target player",
if(userChoice.contains(cardChoice[0])) AllZone.GameAction.getPlayerLife(m_player[0]).subtractLife(
4);
//"Incendiary Command deals 2 damage to each creature",
if(userChoice.contains(cardChoice[1])) {
//get all creatures
CardList list = new CardList();
list.addAll(AllZone.Human_Play.getCards());
list.addAll(AllZone.Computer_Play.getCards());
list = list.getType("Creature");
for(int i = 0; i < list.size(); i++) {
if(CardFactoryUtil.canDamage(card, list.get(i))) list.get(i).addDamage(2, card);
}
}
//"Destroy target nonbasic land",
if(userChoice.contains(cardChoice[2])) AllZone.GameAction.destroy(m_land[0]);
//"Each player discards all cards in his or her hand, then draws that many cards"
if(userChoice.contains(cardChoice[3])) {
discardDraw(Constant.Player.Computer);
discardDraw(Constant.Player.Human);
}
}//resolve()
void discardDraw(String player) {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, player);
int n = hand.size();
//technically should let the user discard one card at a time
//in case graveyard order matters
for(int i = 0; i < n; i++)
AllZone.GameAction.discardRandom(player);
for(int i = 0; i < n; i++)
AllZone.GameAction.drawCard(player);
}
@Override
public boolean canPlayAI() {
return false;
}
};//SpellAbility
final Command setStackDescription = new Command() {
private static final long serialVersionUID = -4833850318955216009L;
public void execute() {
ArrayList<String> a = new ArrayList<String>();
if(userChoice.contains(cardChoice[0])) a.add("deals 4 damage to " + m_player[0]);
if(userChoice.contains(cardChoice[1])) a.add("deals 2 damage to each creature");
if(userChoice.contains(cardChoice[2])) a.add("destroy " + m_land[0]);
if(userChoice.contains(cardChoice[3])) a.add("each player discards all cards in his or her hand, then draws that many cards");
String s = a.get(0) + ", " + a.get(1);
spell.setStackDescription(card.getName() + " - " + s);
}
};//Command
final Input targetLand = new Input() {
private static final long serialVersionUID = 1485276539154359495L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target nonbasic land");
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card c, PlayerZone zone) {
if(c.isLand() && zone.is(Constant.Zone.Play) && !c.getType().contains("Basic")) {
m_land[0] = c;
setStackDescription.execute();
stopSetNext(new Input_PayManaCost(spell));
}//if
}//selectCard()
};//Input targetLand
final Input targetPlayer = new Input() {
private static final long serialVersionUID = -2636869617248434242L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target player");
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectPlayer(String player) {
m_player[0] = player;
setStackDescription.execute();
//if user needs to target nonbasic land
if(userChoice.contains(cardChoice[2])) stopSetNext(targetLand);
else {
stopSetNext(new Input_PayManaCost(spell));
}
}//selectPlayer()
};//Input targetPlayer
Input chooseTwoInput = new Input() {
private static final long serialVersionUID = 5625588008756700226L;
@Override
public void showMessage() {
//reset variables
m_player[0] = null;
m_land[0] = null;
userChoice.clear();
ArrayList<String> display = new ArrayList<String>();
//get all
CardList list = new CardList();
list.addAll(AllZone.Human_Play.getCards());
list.addAll(AllZone.Computer_Play.getCards());
CardList land = list.getType("Land");
CardList basicLand = list.getType("Basic");
display.add("Incendiary Command deals 4 damage to target player");
display.add("Incendiary Command deals 2 damage to each creature");
if(land.size() != basicLand.size()) display.add("Destroy target nonbasic land");
display.add("Each player discards all cards in his or her hand, then draws that many cards");
ArrayList<String> a = chooseTwo(display);
//everything stops here if user cancelled
if(a == null) {
stop();
return;
}
userChoice.addAll(a);
if(userChoice.contains(cardChoice[0])) stopSetNext(targetPlayer);
else if(userChoice.contains(cardChoice[2])) stopSetNext(targetLand);
else {
setStackDescription.execute();
stopSetNext(new Input_PayManaCost(spell));
}
}//showMessage()
ArrayList<String> chooseTwo(ArrayList<String> choices) {
ArrayList<String> out = new ArrayList<String>();
Object o = AllZone.Display.getChoiceOptional("Choose Two", choices.toArray());
if(o == null) return null;
out.add((String) o);
choices.remove(out.get(0));
o = AllZone.Display.getChoiceOptional("Choose Two", choices.toArray());
if(o == null) return null;
out.add((String) o);
return out;
}//chooseTwo()
};//Input chooseTwoInput
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(chooseTwoInput);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Boil") || cardName.equals("Boiling Seas")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -5951776248246552958L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
if(c.getType().contains("Island")) AllZone.GameAction.destroy(c);
}
}//resolve()
@Override
public boolean canPlayAI() {
CardList list = new CardList(AllZone.Human_Play.getCards());
list = list.getType("Island");
return 3 < list.size();
}
};//SpellAbility
spell.setStackDescription(card.getName() + " - destroy all Islands.");
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Plague Wind")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 6008660207658995400L;
@Override
public void resolve() {
String opponent = AllZone.GameAction.getOpponent(card.getController());
PlayerZone play = AllZone.getZone(Constant.Zone.Play, opponent);
CardList all = new CardList(play.getCards());
all = all.getType("Creature");
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
if(c.isCreature()) AllZone.GameAction.destroyNoRegeneration(c);
}
}//resolve()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Overwhelming Forces")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -7165356050118574287L;
@Override
public void resolve() {
String opponent = AllZone.GameAction.getOpponent(card.getController());
PlayerZone play = AllZone.getZone(Constant.Zone.Play, opponent);
CardList all = new CardList(play.getCards());
all = all.getType("Creature");
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
if(c.isCreature()) AllZone.GameAction.destroy(c);
AllZone.GameAction.drawCard(card.getController());
}
}//resolve()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Path of Anger's Flame")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -4070937328002003491L;
@Override
public boolean canPlayAI() {
return getAttacker() != null;
}
public Card getAttacker() {
//target creature that is going to attack
Combat c = ComputerUtil.getAttackers();
Card[] att = c.getAttackers();
if(att.length != 0) return att[0];
else return null;
}//getAttacker()
@Override
public void resolve() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList start = new CardList(play.getCards());
final CardList list = start.getType("Creature");
for(int i = 0; i < list.size(); i++)
list.get(i).addTempAttackBoost(2);
play.updateObservers();
Command untilEOT = new Command() {
private static final long serialVersionUID = 6078548097470388679L;
public void execute() {
for(int i = 0; i < list.size(); i++)
if(AllZone.GameAction.isCardInPlay(list.get(i))) list.get(i).addTempAttackBoost(-2);
}
};
AllZone.EndOfTurn.addUntil(untilEOT);
}//resolve()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Kjeldoran War Cry")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -7384618531690849205L;
@Override
public boolean canPlayAI() {
return getAttacker() != null;
}
public Card getAttacker() {
//target creature that is going to attack
Combat c = ComputerUtil.getAttackers();
Card[] att = c.getAttackers();
if(att.length != 0) return att[0];
else return null;
}//getAttacker()
@Override
public void resolve() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList start = new CardList(play.getCards());
final CardList list = start.getType("Creature");
final int boost = countCards();
for(int i = 0; i < list.size(); i++) {
list.get(i).addTempAttackBoost(boost);
list.get(i).addTempDefenseBoost(boost);
}
play.updateObservers();
Command untilEOT = new Command() {
private static final long serialVersionUID = -2803160667440730370L;
public void execute() {
for(int i = 0; i < list.size(); i++)
if(AllZone.GameAction.isCardInPlay(list.get(i))) {
list.get(i).addTempAttackBoost(-boost);
list.get(i).addTempDefenseBoost(-boost);
}
}
};
AllZone.EndOfTurn.addUntil(untilEOT);
}//resolve()
int countCards() {
CardList all = new CardList();
all.addAll(AllZone.Human_Graveyard.getCards());
all.addAll(AllZone.Computer_Graveyard.getCards());
all = all.getName("Kjeldoran War Cry");
return all.size() + 1;
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Akroma's Vengeance") || cardName.equals("Devastation")
|| cardName.equals("Jokulhaups") || cardName.equals("Purify") || cardName.equals("Shatterstorm")
|| cardName.equals("Obliterate")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -7384618531690849205L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
CardListUtil.sortByIndestructible(all);
CardListUtil.sortByDestroyEffect(all);
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
if(cardName.equals("Akroma's Vengeance")
&& (c.isCreature() || c.isArtifact() || c.isEnchantment())) // Destroy Enchantment rather than Land
AllZone.GameAction.destroy(c); // Can regenerate
if(cardName.equals("Devastation") && (c.isCreature() || c.isLand())) AllZone.GameAction.destroy(c); // Can regenerate
if((cardName.equals("Jokulhaups") || cardName.equals("Obliterate"))
&& (c.isCreature() || c.isArtifact() || c.isLand())) AllZone.GameAction.destroyNoRegeneration(c); // CAN'T regenerate
if(cardName.equals("Purify") && (c.isArtifact() || c.isEnchantment())) AllZone.GameAction.destroy(c); // Can regenerate
if(cardName.equals("Shatterstorm") && (c.isArtifact())) AllZone.GameAction.destroyNoRegeneration(c); // CAN'T regenerate
}
}//resolve()
};//SpellAbility
if(cardName.equals("Akroma's Vengeance")) {
spell.setStackDescription("Akroma's Vengeance - Destroy all artifacts, creatures, and enchantments."); // add stack description
spell.setDescription("Destroy all artifacts, creatures, and enchantments."); // add spell detail description
}
card.clearSpellAbility();
card.addSpellAbility(spell);
if(cardName.equals("Akroma's Vengeance")) //add cycling
card.addSpellAbility(CardFactoryUtil.ability_cycle(card, "3"));
if(cardName.equals("Obliterate")) card.setText("Obliterate can't be countered. \r\n" + card.getText());
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Wheel of Fortune")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -7707418370887790709L;
@Override
public void resolve() {
discardDraw7(Constant.Player.Human);
discardDraw7(Constant.Player.Computer);
}//resolve()
void discardDraw7(String player) {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, player);
Card[] c = hand.getCards();
for(int i = 0; i < c.length; i++)
AllZone.GameAction.discard(c[i]);
for(int i = 0; i < 7; i++)
AllZone.GameAction.drawCard(player);
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Armageddon") || cardName.equals("Ravages of War")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 432601263297207029L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
if(c.isLand()) AllZone.GameAction.destroy(c);
}
}//resolve()
@Override
public boolean canPlayAI() {
int human = countPower(AllZone.Human_Play);
int computer = countPower(AllZone.Computer_Play);
return human < computer || MyRandom.percentTrue(10);
}
public int countPower(PlayerZone play) {
CardList list = new CardList(play.getCards());
list = list.getType("Creature");
int power = 0;
for(int i = 0; i < list.size(); i++)
power += list.get(i).getNetAttack();
return power;
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Remove Soul") || cardName.equals("False Summoning")
|| cardName.equals("Essence Scatter") || cardName.equals("Preemptive Strike")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 4685055135070191326L;
@Override
public void resolve() {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
//is spell?, did opponent play it?, is this a creature spell?
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& sa.getSourceCard().getType().contains("Creature")
&& CardFactoryUtil.isCounterable(sa.getSourceCard());
}//canPlay()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Spell Pierce")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 4685055135070191326L;
@Override
public void resolve() {
String manaCost = "2";
Ability ability = new Ability(card, manaCost) {
@Override
public void resolve() {
;
}
};
final Command unpaidCommand = new Command() {
private static final long serialVersionUID = 8094833091127334678L;
public void execute() {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
}
};
if(card.getController().equals(Constant.Player.Computer)) {
AllZone.InputControl.setInput(new Input_PayManaCost_Ability(card + "\r\n",
ability.getManaCost(), Command.Blank, unpaidCommand));
} else {
if(ComputerUtil.canPayCost(ability)) ComputerUtil.playNoStack(ability);
else {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
}
}
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
//is spell?, did opponent play it?, is this a creature spell?
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& !sa.getSourceCard().getType().contains("Creature")
&& CardFactoryUtil.isCounterable(sa.getSourceCard());
}//canPlay()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Counterspell") || cardName.equals("Cancel") || cardName.equals("Last Word")
|| cardName.equals("Traumatic Visions") || cardName.equals("Stifle")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -2489268054171391552L;
@Override
public void resolve() {
SpellAbility sa = AllZone.Stack.pop();
if(!cardName.equals("Stifle")) AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
if(cardName.equals("Stifle")) return !sa.isSpell()
&& CardFactoryUtil.isCounterable(sa.getSourceCard());
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& CardFactoryUtil.isCounterable(sa.getSourceCard());
}
};
card.clearSpellAbility();
String desc = "";
if(cardName.equals("Last Word")) {
desc = "Last Word can't be countered by spells or abilities.\r\n";
}
if(cardName.equals("Stifle")) {
spell.setDescription(desc + "Counter target triggered or activated ability.");
spell.setStackDescription(card.getName() + " - Counters target triggered or activated ability.");
} else {
spell.setDescription(desc + "Counter target spell.");
spell.setStackDescription(card.getName() + " - Counters target spell.");
}
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Mana Leak") || cardName.equals("Convolute") || cardName.equals("Daze")
|| cardName.equals("Force Spike") || cardName.equals("Runeboggle")
|| cardName.equals("Spell Snip") || cardName.equals("Mana Tithe")
|| cardName.equals("Miscalculation")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 6139754377230333678L;
@Override
public void resolve() {
String manaCost = "1";
if(cardName.equals("Miscalculation")) manaCost = "2";
else if(cardName.equals("Mana Leak")) manaCost = "3";
else if(cardName.equals("Convolute")) manaCost = "4";
Ability ability = new Ability(card, manaCost) {
@Override
public void resolve() {
;
}
};
final Command unpaidCommand = new Command() {
private static final long serialVersionUID = 8094833091127334678L;
public void execute() {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
}
};
if(card.getController().equals(Constant.Player.Computer)) {
AllZone.InputControl.setInput(new Input_PayManaCost_Ability(card + "\r\n",
ability.getManaCost(), Command.Blank, unpaidCommand));
} else {
if(ComputerUtil.canPayCost(ability)) ComputerUtil.playNoStack(ability);
else {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
}
}
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& CardFactoryUtil.isCounterable(sa.getSourceCard());
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
if(cardName.equals("Daze")) {
spell.setDescription("Counter target spell unless its controller pays 1.");
spell.setStackDescription(card.getName() + " - Counter target spell unless its controller pays 1.");
final SpellAbility bounce = new Spell(card) {
private static final long serialVersionUID = -8310299673731730438L;
@Override
public void resolve() {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList list = new CardList(play.getCards());
list = list.getType("Island");
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& CardFactoryUtil.isCounterable(sa.getSourceCard()) && list.size() >= 1;
}
@Override
public boolean canPlayAI() {
return false;
}
};
bounce.setDescription("You may return an Island you control to their owner's hand rather than pay Daze's mana cost.");
bounce.setStackDescription(card.getName()
+ " - Counter target spell unless its controller pays 1.");
bounce.setManaCost("0");
final Input bounceIslands = new Input() {
private static final long serialVersionUID = 7624182730685889456L;
int stop = 1;
int count = 0;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select an Island");
ButtonUtil.disableAll();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card c, PlayerZone zone) {
if(c.getType().contains("Island") && zone.is(Constant.Zone.Play)) {
AllZone.GameAction.moveToHand(c);
count++;
if(count == stop) {
AllZone.Stack.add(bounce);
stop();
}
}
}//selectCard()
};
bounce.setBeforePayMana(bounceIslands);
card.addSpellAbility(bounce);
}//if Daze
else // This is Chris' Evil hack to get the Cycling cards to give us a choose window with text for the SpellAbility
{
spell.setDescription(card.getText());
card.setText("");
}
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Remand")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 7259402997927108504L;
@Override
public void resolve() {
//counter spell, return it to owner's hand
SpellAbility sa = AllZone.Stack.pop();
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, sa.getSourceCard().getOwner());
AllZone.GameAction.moveTo(hand, sa.getSourceCard());
//draw card
// AllZone.GameAction.drawCard(card.getController());
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& CardFactoryUtil.isCounterable(sa.getSourceCard());
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Regress")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 4207725827500789300L;
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
if(getTargetCard().isToken()) AllZone.getZone(getTargetCard()).remove(getTargetCard());
else {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, getTargetCard().getOwner());
AllZone.GameAction.moveTo(hand, getTargetCard());
}
}
}//resolve()
@Override
public void chooseTargetAI() {
PlayerZone hPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList hum = new CardList(hPlay.getCards());
Card best = CardFactoryUtil.AI_getMostExpensivePermanent(hum, card, true);
if(best != null) setTargetCard(best);
}
@Override
public boolean canPlayAI() {
PlayerZone hPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList hum = new CardList(hPlay.getCards());
return hum.size() > 0;
}
};
//spell.setChooseTargetAI(CardFactoryUtil.AI_targetType("All", AllZone.Human_Play));
spell.setBeforePayMana(CardFactoryUtil.input_targetType(spell, "All"));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Echoing Truth")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 563933533543239220L;
@Override
public boolean canPlayAI() {
CardList human = CardFactoryUtil.AI_getHumanCreature(card, true);
return 4 < AllZone.Phase.getTurn() && 0 < human.size();
}
@Override
public void chooseTargetAI() {
CardList human = CardFactoryUtil.AI_getHumanCreature(card, true);
setTargetCard(CardFactoryUtil.AI_getBestCreature(human));
}
@Override
public void resolve() {
//if target card is not in play, just quit
if(!AllZone.GameAction.isCardInPlay(getTargetCard())
|| !CardFactoryUtil.canTarget(card, getTargetCard())) return;
//get all permanents
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
CardList sameName = all.getName(getTargetCard().getName());
if(!getTargetCard().isFaceDown()) {
//bounce all permanents with the same name
for(int i = 0; i < sameName.size(); i++) {
if(sameName.get(i).isToken()) AllZone.GameAction.removeFromGame(sameName.get(i));
else {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, sameName.get(i).getOwner());
AllZone.GameAction.moveTo(hand, sameName.get(i));
}
}//for
}//if (!isFaceDown())
else {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, getTargetCard().getOwner());
AllZone.GameAction.moveTo(hand, getTargetCard());
}
}//resolve()
};//SpellAbility
Input target = new Input() {
private static final long serialVersionUID = -3978705328511825933L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target non-land permanent for " + spell.getSourceCard());
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card card, PlayerZone zone) {
if(!card.isLand() && zone.is(Constant.Zone.Play) && CardFactoryUtil.canTarget(spell, card)) {
spell.setTargetCard(card);
stopSetNext(new Input_PayManaCost(spell));
}
}
};//Input
spell.setBeforePayMana(target);
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Repulse")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 7586791617021788730L;
@Override
public boolean canPlayAI() {
CardList human = CardFactoryUtil.AI_getHumanCreature(card, true);
return 3 < AllZone.Phase.getTurn() && 0 < human.size();
}
@Override
public void chooseTargetAI() {
CardList human = CardFactoryUtil.AI_getHumanCreature(card, true);
setTargetCard(CardFactoryUtil.AI_getBestCreature(human));
}
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
if(getTargetCard().isToken()) AllZone.getZone(getTargetCard()).remove(getTargetCard());
else {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, getTargetCard().getOwner());
AllZone.GameAction.moveTo(hand, getTargetCard());
}
// AllZone.GameAction.drawCard(card.getController());
}//if
}//resolve()
};//SpellAbility
Input target = new Input() {
private static final long serialVersionUID = -4976281514575975012L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target creature for " + spell.getSourceCard());
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card card, PlayerZone zone) {
if(!CardFactoryUtil.canTarget(spell, card)) {
AllZone.Display.showMessage("Cannot target this card (Shroud? Protection?).");
}
else if(card.isCreature() && zone.is(Constant.Zone.Play)) {
spell.setTargetCard(card);
stopSetNext(new Input_PayManaCost(spell));
}
}
};//Input
spell.setBeforePayMana(target);
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Unsummon")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -4920446621228732642L;
@Override
public boolean canPlayAI() {
CardList human = CardFactoryUtil.AI_getHumanCreature(card, true);
return 2 < AllZone.Phase.getTurn() && 0 < human.size();
}
@Override
public void chooseTargetAI() {
CardList human = CardFactoryUtil.AI_getHumanCreature(card, true);
setTargetCard(CardFactoryUtil.AI_getBestCreature(human));
}
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
if(getTargetCard().isToken()) AllZone.getZone(getTargetCard()).remove(getTargetCard());
else {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, getTargetCard().getOwner());
AllZone.GameAction.moveTo(hand, getTargetCard());
}
}//if
}//resolve()
};//SpellAbility
Input target = new Input() {
private static final long serialVersionUID = -7657949950004365660L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target creature for " + spell.getSourceCard());
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card card, PlayerZone zone) {
if(!CardFactoryUtil.canTarget(spell, card)) {
AllZone.Display.showMessage("Cannot target this card (Shroud? Protection?).");
}
else if(card.isCreature() && zone.is(Constant.Zone.Play)) {
spell.setTargetCard(card);
stopSetNext(new Input_PayManaCost(spell));
}
}
};//Input
spell.setBeforePayMana(target);
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Impulse")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -6793636573741251978L;
@Override
public boolean canPlayAI() {
return false;
}
@Override
public void resolve() {
CardList top = new CardList();
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
Card c;
int j = 4;
if(library.size() < 4) j = library.size();
for(int i = 0; i < j; i++) {
c = library.get(0);
library.remove(0);
top.add(c);
}
if(top.size() >= 1) {
//let user get choice
Card chosen = AllZone.Display.getChoice("Choose a card to put into your hand",
top.toArray());
top.remove(chosen);
//put card in hand
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
hand.add(chosen);
//add cards to bottom of library
for(int i = 0; i < top.size(); i++)
library.add(top.get(i));
}
}//resolve()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Bribery")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -4267653042039058744L;
@Override
public void resolve() {
String player = card.getController();
if(player.equals(Constant.Player.Human)) humanResolve();
else computerResolve();
}
public void humanResolve() {
//choose creature from opponents library to put into play
//shuffle opponent's library
String opponent = AllZone.GameAction.getOpponent(card.getController());
PlayerZone library = AllZone.getZone(Constant.Zone.Library, opponent);
CardList choices = new CardList(library.getCards());
choices = choices.getType("Creature");
Object o = AllZone.Display.getChoiceOptional("Choose a creature", choices.toArray());
if(o != null) resolve((Card) o);
}
public void computerResolve() {
CardList all = new CardList(AllZone.Human_Library.getCards());
all = all.filter(new CardListFilter(){
public boolean addCard(Card c)
{
return c.isCreature() && !c.getName().equals("Ball Lightning") && !c.getName().equals("Groundbreaker");
}
});
CardList flying = all.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.getKeyword().contains("Flying");
}
});
//get biggest flying creature
Card biggest = null;
if(flying.size() != 0) {
biggest = flying.get(0);
for(int i = 0; i < flying.size(); i++)
if(biggest.getNetAttack() < flying.get(i).getNetAttack()) biggest = flying.get(i);
}
//if flying creature is small, get biggest non-flying creature
if(all.size() != 0 && (biggest == null || biggest.getNetAttack() < 3)) {
biggest = all.get(0);
for(int i = 0; i < all.size(); i++)
if(biggest.getNetAttack() < all.get(i).getNetAttack()) biggest = all.get(i);
}
if(biggest != null) resolve(biggest);
}//computerResolve()
public void resolve(Card selectedCard) {
String opponent = AllZone.GameAction.getOpponent(card.getController());
PlayerZone library = AllZone.getZone(Constant.Zone.Library, opponent);
Card c = selectedCard;
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
//need to set controller before adding it to "play"
c.setController(card.getController());
c.setSickness(true);
library.remove(c);
play.add(c);
AllZone.GameAction.shuffle(opponent);
}//resolve()
};
spell.setBeforePayMana(new Input_PayManaCost(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Amnesia")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -5456164079438881319L;
@Override
public void resolve() {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, getTargetPlayer());
Card[] c = hand.getCards();
for(int i = 0; i < c.length; i++)
if(!c[i].isLand()) AllZone.GameAction.discard(c[i]);
}
};
spell.setChooseTargetAI(CardFactoryUtil.AI_targetHuman());
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Evacuation") || cardName.equals("Rebuild")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -6305494177352031326L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
if(cardName.equals("Rebuild")) all = all.getType("Artifact");
else all = all.getType("Creature");
for(int i = 0; i < all.size(); i++) {
//if is token, remove token from play, else return creature to hand
if(all.get(i).isToken()) getPlay(all.get(i)).remove(all.get(i));
else AllZone.GameAction.moveTo(getHand(all.get(i)), all.get(i));
}
}//resolve()
PlayerZone getPlay(Card c) {
return AllZone.getZone(Constant.Zone.Play, c.getController());
}
PlayerZone getHand(Card c) {
return AllZone.getZone(Constant.Zone.Hand, c.getOwner());
}
};
if(cardName.equals("Rebuild")) {
spell.setDescription("Return all artifacts to their owners' hands.");
spell.setStackDescription(card.getName() + " - return all artifacts to their owners' hands.");
}
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Deep Analysis")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 6317660847906461825L;
@Override
public void resolve() {
AllZone.GameAction.drawCard(card.getController());
AllZone.GameAction.drawCard(card.getController());
}
@Override
public boolean canPlayAI() {
return AllZone.Computer_Hand.getCards().length <= 6;
}
};
spell.setDescription("Target player draws two cards.");
spell.setStackDescription(card.getName() + " - " + card.getController() + " draws two cards.");
card.clearSpellAbility();
card.addSpellAbility(spell);
card.addSpellAbility(CardFactoryUtil.ability_Flashback(card, "1 U", "3"));
card.setFlashback(true);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Allied Strategies")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 2730790148899002194L;
@Override
public void resolve() {
int n = countLandTypes();
for(int i = 0; i < n; i++)
AllZone.GameAction.drawCard(getTargetPlayer());
}
int countLandTypes() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, getTargetPlayer());
CardList land = new CardList(play.getCards());
String basic[] = {"Forest", "Plains", "Mountain", "Island", "Swamp"};
int count = 0;
for(int i = 0; i < basic.length; i++) {
CardList c = land.getType(basic[i]);
if(!c.isEmpty()) count++;
}
return count;
}//countLandTypes()
@Override
public boolean canPlayAI() {
return AllZone.Computer_Hand.getCards().length <= 5;
}
};
spell.setChooseTargetAI(CardFactoryUtil.AI_targetComputer());
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Opt")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 6002051826637535590L;
@Override
public void resolve() {
String player = card.getController();
if(player.equals(Constant.Player.Human)) humanResolve();
else computerResolve();
}
public void computerResolve() {
//if top card of library is a land, put it on bottom of library
if(AllZone.Computer_Library.getCards().length != 0) {
Card top = AllZone.Computer_Library.get(0);
if(top.isLand()) {
AllZone.Computer_Library.remove(top);
AllZone.Computer_Library.add(top);
}
}
// AllZone.GameAction.drawCard(card.getController());
}//computerResolve()
public void humanResolve() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
//see if any cards are in library
if(library.getCards().length != 0) {
Card top = library.get(0);
Object o = top;
while(o instanceof Card)
o = AllZone.Display.getChoice("Do you want draw this card?", new Object[] {
top, "Yes", "No"});
if(o.toString().equals("No")) {
library.remove(top);
library.add(top);
}
}//if
// AllZone.GameAction.drawCard(card.getController());
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Needle Storm")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 1477280027897731860L;
@Override
public void resolve() {
CardList list = new CardList();
list.addAll(AllZone.Human_Play.getCards());
list.addAll(AllZone.Computer_Play.getCards());
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isCreature() && c.getKeyword().contains("Flying")
&& CardFactoryUtil.canDamage(card, c);
}
});
for(int i = 0; i < list.size(); i++)
list.get(i).addDamage(4, card);
}//resolve()
@Override
public boolean canPlayAI() {
return CardFactoryUtil.AI_getHumanCreature("Flying", card, false).size() != 0;
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Wandering Stream")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 8777120667537357240L;
@Override
public void resolve() {
PlayerLife life = AllZone.GameAction.getPlayerLife(card.getController());
life.addLife(countLandTypes() * 2);
}//resolve()
int countLandTypes() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList land = new CardList(play.getCards());
String basic[] = {"Forest", "Plains", "Mountain", "Island", "Swamp"};
int count = 0;
for(int i = 0; i < basic.length; i++) {
CardList c = land.getType(basic[i]);
if(!c.isEmpty()) count++;
}
return count;
}//countLandTypes()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Worldly Tutor") || cardName.equals("Sylvan Tutor")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 6624899562868794463L;
@Override
public boolean canPlayAI() {
return 6 < AllZone.Phase.getTurn();
}
@Override
public void resolve() {
String player = card.getController();
if(player.equals(Constant.Player.Human)) humanResolve();
else computerResolve();
}
public void computerResolve() {
CardList creature = new CardList(AllZone.Computer_Library.getCards());
creature = creature.getType("Creature");
if(creature.size() != 0) {
Card c = creature.get(0);
AllZone.GameAction.shuffle(card.getController());
//move to top of library
AllZone.Computer_Library.remove(c);
AllZone.Computer_Library.add(c, 0);
CardList list = new CardList();
list.add(c);
AllZone.Display.getChoiceOptional("Computer picked:", list.toArray());
}
}//computerResolve()
public void humanResolve() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
CardList list = new CardList(library.getCards());
list = list.getType("Creature");
if(list.size() != 0) {
Object o = AllZone.Display.getChoiceOptional("Select a creature", list.toArray());
AllZone.GameAction.shuffle(card.getController());
if(o != null) {
//put creature on top of library
library.remove(o);
library.add((Card) o, 0);
}
}//if
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Enlightened Tutor")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 2281623056004772379L;
@Override
public boolean canPlayAI() {
return 4 < AllZone.Phase.getTurn();
}
@Override
public void resolve() {
String player = card.getController();
if(player.equals(Constant.Player.Human)) humanResolve();
else computerResolve();
}
public void computerResolve() {
CardList list = new CardList(AllZone.Computer_Library.getCards());
CardList encharts = new CardList();
for(int i = 0; i < list.size(); i++) {
if(list.get(i).getType().contains("Artifact")
|| list.get(i).getType().contains("Enchantment")) encharts.add(list.get(i));
}
if(encharts.size() != 0) {
//comp will just grab the first one it finds
Card c = encharts.get(0);
AllZone.GameAction.shuffle(card.getController());
//move to top of library
AllZone.Computer_Library.remove(c);
AllZone.Computer_Library.add(c, 0);
CardList l = new CardList();
l.add(c);
AllZone.Display.getChoiceOptional("Computer picked:", l.toArray());
}
}//computerResolve()
public void humanResolve() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
CardList list = new CardList(library.getCards());
CardList encharts = new CardList();
for(int i = 0; i < list.size(); i++) {
if(list.get(i).getType().contains("Artifact")
|| list.get(i).getType().contains("Enchantment")) encharts.add(list.get(i));
}
if(encharts.size() != 0) {
Object o = AllZone.Display.getChoiceOptional("Select an artifact or enchantment",
encharts.toArray());
AllZone.GameAction.shuffle(card.getController());
if(o != null) {
//put card on top of library
library.remove(o);
library.add((Card) o, 0);
}
}//if
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Mystical Tutor")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 2281623056004772379L;
@Override
public boolean canPlayAI() {
return 4 < AllZone.Phase.getTurn();
}
@Override
public void resolve() {
String player = card.getController();
if(player.equals(Constant.Player.Human)) humanResolve();
else computerResolve();
}
public void computerResolve() {
CardList list = new CardList(AllZone.Computer_Library.getCards());
CardList instantsAndSorceries = new CardList();
for(int i = 0; i < list.size(); i++) {
if(list.get(i).getType().contains("Instant") || list.get(i).getType().contains("Sorcery")) instantsAndSorceries.add(list.get(i));
}
if(instantsAndSorceries.size() != 0) {
//comp will just grab the first one it finds
Card c = instantsAndSorceries.get(0);
AllZone.GameAction.shuffle(card.getController());
//move to top of library
AllZone.Computer_Library.remove(c);
AllZone.Computer_Library.add(c, 0);
CardList l = new CardList();
l.add(c);
AllZone.Display.getChoiceOptional("Computer picked:", l.toArray());
}
}//computerResolve()
public void humanResolve() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
CardList list = new CardList(library.getCards());
CardList instantsAndSorceries = new CardList();
for(int i = 0; i < list.size(); i++) {
if(list.get(i).getType().contains("Instant") || list.get(i).getType().contains("Sorcery")) instantsAndSorceries.add(list.get(i));
}
if(instantsAndSorceries.size() != 0) {
Object o = AllZone.Display.getChoiceOptional("Select an instant or sorcery",
instantsAndSorceries.toArray());
AllZone.GameAction.shuffle(card.getController());
if(o != null) {
//put card on top of library
library.remove(o);
library.add((Card) o, 0);
}
}//if
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Pulse of the Tangle")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 523613120207836692L;
@Override
public void resolve() {
CardFactoryUtil.makeToken("Beast", "G 3 3 Beast", card, "G",
new String[] {"Creature", "Beast"}, 3, 3, new String[] {""});
//return card to hand if necessary
String opponent = AllZone.GameAction.getOpponent(card.getController());
PlayerZone oppPlay = AllZone.getZone(Constant.Zone.Play, opponent);
PlayerZone myPlay = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList oppList = new CardList(oppPlay.getCards());
CardList myList = new CardList(myPlay.getCards());
oppList = oppList.getType("Creature");
myList = myList.getType("Creature");
//if true, return card to hand
if(myList.size() < oppList.size()) {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
hand.add(card);
} else AllZone.GameAction.moveToGraveyard(card);
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Think Twice")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 2571730013113893086L;
@Override
public void resolve() {
AllZone.GameAction.drawCard(card.getController());
}//resolve()
};
card.clearSpellAbility();
card.setFlashback(true);
card.addSpellAbility(spell);
card.addSpellAbility(CardFactoryUtil.ability_Flashback(card, "2 U", "0"));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Call of the Herd")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 1959302998030377554L;
@Override
public void resolve() {
CardFactoryUtil.makeToken("Elephant", "G 3 3 Elephant", card, "G", new String[] {
"Creature", "Elephant"}, 3, 3, new String[] {""});
}//resolve()
};
spell.setDescription("Put a 3/3 green Elephant creature token into play.");
spell.setStackDescription(card.getController()
+ " puts a 3/3 green Elephant creature token into play.");
card.setFlashback(true);
card.clearSpellAbility();
card.addSpellAbility(spell);
card.addSpellAbility(CardFactoryUtil.ability_Flashback(card, "3 G", "0"));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Elephant Ambush")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 1808366787563573082L;
@Override
public void resolve() {
CardFactoryUtil.makeToken("Elephant", "G 3 3 Elephant", card, "G", new String[] {
"Creature", "Elephant"}, 3, 3, new String[] {""});
}//resolve()
};
spell.setDescription("Put a 3/3 green Elephant creature token into play.");
spell.setStackDescription(card.getController()
+ " puts a 3/3 green Elephant creature token into play.");
card.setFlashback(true);
card.clearSpellAbility();
card.addSpellAbility(spell);
card.addSpellAbility(CardFactoryUtil.ability_Flashback(card, "6 G G", "0"));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Chatter of the Squirrel")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 3787460988525779623L;
@Override
public void resolve() {
CardFactoryUtil.makeToken("Squirrel", "G 1 1 Squirrel", card, "G", new String[] {
"Creature", "Squirrel"}, 1, 1, new String[] {""});
}
};
spell.setDescription("Put a 1/1 green Squirrel creature token into play.");
spell.setStackDescription(card.getController()
+ " puts a 1/1 green Squirrel creature token into play.");
card.setFlashback(true);
card.clearSpellAbility();
card.addSpellAbility(spell);
card.addSpellAbility(CardFactoryUtil.ability_Flashback(card, "1 G", "0"));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Acorn Harvest")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 4779507778950336252L;
@Override
public void resolve() {
makeToken();
makeToken();
}
public void makeToken() {
CardFactoryUtil.makeToken("Squirrel", "G 1 1 Squirrel", card, "G", new String[] {
"Creature", "Squirrel"}, 1, 1, new String[] {""});
}//resolve()
};
spell.setDescription("Put two 1/1 green Squirrel creature tokens into play.");
spell.setStackDescription(card.getController()
+ " puts two 1/1 green Squirrel creature tokens into play.");
card.setFlashback(true);
card.clearSpellAbility();
card.addSpellAbility(spell);
card.addSpellAbility(CardFactoryUtil.ability_Flashback(card, "1 G", "3"));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Beast Attack")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 381753184772980686L;
@Override
public void resolve() {
makeToken();
}
//for some reason, without this the AI can keep casting Beast Attack over and over.
@Override
public boolean canPlayAI() {
return !AllZone.GameAction.isCardInGrave(card);
}
public void makeToken() {
CardFactoryUtil.makeToken("Beast", "G 4 4 Beast", card, "G",
new String[] {"Creature", "Beast"}, 4, 4, new String[] {""});
}//resolve()
};
spell.setDescription("Put a 4/4 green Beast creature token into play.");
spell.setStackDescription(card.getController() + " put a 4/4 green Beast creature token into play.");
card.setFlashback(true);
card.clearSpellAbility();
card.addSpellAbility(spell);
card.addSpellAbility(CardFactoryUtil.ability_Flashback(card, "2 G G G", "0"));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Roar of the Wurm")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -7861877439125080643L;
@Override
public void resolve() {
CardFactoryUtil.makeToken("Wurm", "G 6 6 Wurm", card, "G", new String[] {"Creature", "Wurm"},
6, 6, new String[] {""});
}
};
spell.setDescription("Put a 6/6 green Wurm creature token into play.");
spell.setStackDescription(card.getController() + " put a 6/6 green Wurm creature token into play.");
card.setFlashback(true);
card.clearSpellAbility();
card.addSpellAbility(spell);
card.addSpellAbility(CardFactoryUtil.ability_Flashback(card, "3 G", "0"));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Crush of Wurms")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 3917531146741977318L;
@Override
public void resolve() {
makeToken();
makeToken();
makeToken();
}
public void makeToken() {
CardFactoryUtil.makeToken("Wurm", "G 6 6 Wurm", card, "G", new String[] {"Creature", "Wurm"},
6, 6, new String[] {""});
}//resolve()
};
spell.setDescription("Put three 6/6 green Wurm creature tokens into play.");
spell.setStackDescription(card.getController()
+ " Put three 6/6 green Wurm creature tokens into play.");
card.setFlashback(true);
card.clearSpellAbility();
card.addSpellAbility(spell);
card.addSpellAbility(CardFactoryUtil.ability_Flashback(card, "9 G G G", "0"));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Grizzly Fate")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 731860438110589738L;
@Override
public void resolve() {
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, card.getController());
CardList list = new CardList(grave.getCards());
makeToken();
makeToken();
if(list.size() >= 7) {
makeToken();
makeToken();
}
}
public void makeToken() {
CardFactoryUtil.makeToken("Bear", "G 2 2 Bear", card, "G", new String[] {"Creature", "Bear"},
2, 2, new String[] {""});
}//resolve()
};
spell.setDescription("Put two 2/2 green Bear creature tokens into play. Threshold - Put four 2/2 green Bear creature tokens into play instead if seven or more cards are in your graveyard. ");
spell.setStackDescription(card.getController() + " Puts 2/2 green Bear tokens into play.");
card.setFlashback(true);
card.clearSpellAbility();
card.addSpellAbility(spell);
card.addSpellAbility(CardFactoryUtil.ability_Flashback(card, "5 G G", "0"));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Sprout")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 1299216756153970592L;
@Override
public void resolve() {
CardFactoryUtil.makeToken("Saproling", "G 1 1 Saproling", card, "G", new String[] {
"Creature", "Saproling"}, 1, 1, new String[] {""});
}
};
spell.setDescription("Put a 1/1 green Saproling creature token into play.");
spell.setStackDescription(card.getController()
+ " put a 1/1 green Saproling creature token into play.");
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Delirium Skeins")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 7901561313373975648L;
@Override
public void resolve() {
for(int i = 0; i < 3; i++)
AllZone.GameAction.discardRandom(Constant.Player.Computer);
AllZone.InputControl.setInput(CardFactoryUtil.input_discard(3));
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Wrap in Vigor")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -4235465815975050436L;
@Override
public boolean canPlayAI() {
return getAttacker() != null;
}
public Card getAttacker() {
//target creature that is going to attack
Combat c = ComputerUtil.getAttackers();
Card[] att = c.getAttackers();
if(att.length != 0) return att[0];
else return null;
}//getAttacker()
@Override
public void resolve() {
final Card[] c = AllZone.getZone(Constant.Zone.Play, card.getController()).getCards();
for(int i = 0; i < c.length; i++)
if(c[i].isCreature()) c[i].addShield();
AllZone.EndOfTurn.addUntil(new Command() {
private static final long serialVersionUID = -3946800525315027053L;
public void execute() {
for(int i = 0; i < c.length; i++)
c[i].resetShield();
}
});
}//resolve()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Smother")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 6479035316340603704L;
@Override
public boolean canPlayAI() {
CardList c = CardFactoryUtil.AI_getHumanCreature(true, 3, card, true);
CardListUtil.sortAttack(c);
CardListUtil.sortFlying(c);
if(c.isEmpty()) return false;
else {
setTargetCard(c.get(0));
return true;
}
}//canPlayAI()
@Override
public void resolve() {
Card c = getTargetCard();
if(AllZone.GameAction.isCardInPlay(c)
&& CardUtil.getConvertedManaCost(card.getManaCost()) <= 3
&& CardFactoryUtil.canTarget(card, getTargetCard())) AllZone.GameAction.destroyNoRegeneration(c);
}//resolve()
};//SpellAbility
Input target = new Input() {
private static final long serialVersionUID = 1877945605889747187L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target creature for " + card.getName()
+ " - creature must have a converted manacost of 3 or less");
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card card, PlayerZone zone) {
if(!CardFactoryUtil.canTarget(spell, card)) {
AllZone.Display.showMessage("Cannot target this card (Shroud? Protection?).");
}
if(card.isCreature() && zone.is(Constant.Zone.Play)
&& CardUtil.getConvertedManaCost(card.getManaCost()) <= 3) {
spell.setTargetCard(card);
stopSetNext(new Input_PayManaCost(spell));
}
}
};//Input
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(target);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Strangling Soot")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -3598479453933951865L;
@Override
public boolean canPlayAI() {
CardList c = CardFactoryUtil.AI_getHumanCreature(3, card, true);
CardListUtil.sortAttack(c);
CardListUtil.sortFlying(c);
if(c.isEmpty()) return false;
else {
setTargetCard(c.get(0));
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, Constant.Player.Computer);
return AllZone.GameAction.isCardInZone(card, hand);
}
}//canPlayAI()
@Override
public void resolve() {
Card c = getTargetCard();
if(AllZone.GameAction.isCardInPlay(c) && c.getNetDefense() <= 3
&& CardFactoryUtil.canTarget(card, getTargetCard())) AllZone.GameAction.destroy(c);
}//resolve()
};//SpellAbility
final SpellAbility flashback = new Spell(card) {
private static final long serialVersionUID = -4009531242109129036L;
@Override
public boolean canPlay() {
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, card.getController());
return AllZone.GameAction.isCardInZone(card, grave);
}
@Override
public boolean canPlayAI() {
CardList c = CardFactoryUtil.AI_getHumanCreature(3, card, true);
CardListUtil.sortAttack(c);
CardListUtil.sortFlying(c);
if(c.isEmpty()) return false;
else {
setTargetCard(c.get(0));
return true;
}
}//canPlayAI()
@Override
public void resolve() {
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, card.getController());
PlayerZone removed = AllZone.getZone(Constant.Zone.Removed_From_Play, card.getController());
Card c = getTargetCard();
if(AllZone.GameAction.isCardInPlay(c) && c.getNetDefense() <= 3
&& CardFactoryUtil.canTarget(card, getTargetCard())) AllZone.GameAction.destroy(c);
grave.remove(card);
removed.add(card);
}//resolve()
};//flashback
Input targetFB = new Input() {
private static final long serialVersionUID = -5469698194749752297L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target creature for " + card.getName()
+ " - creature must have a toughness of 3 or less");
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card card, PlayerZone zone) {
if(!CardFactoryUtil.canTarget(flashback, card)) {
AllZone.Display.showMessage("Cannot target this card (Shroud? Protection?).");
}
if(card.isCreature() && zone.is(Constant.Zone.Play) && card.getNetDefense() <= 3) {
flashback.setTargetCard(card);
stopSetNext(new Input_PayManaCost(flashback));
}
}
};//Input
flashback.setFlashBackAbility(true);
flashback.setManaCost("5 R");
flashback.setBeforePayMana(targetFB);
flashback.setDescription("Flashback: 5 R");
Input target = new Input() {
private static final long serialVersionUID = -198153850086215235L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target creature for " + card.getName()
+ " - creature must have a toughness of 3 or less");
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card card, PlayerZone zone) {
if(!CardFactoryUtil.canTarget(spell, card)) {
AllZone.Display.showMessage("Cannot target this card (Shroud? Protection?).");
}
if(card.isCreature() && zone.is(Constant.Zone.Play) && card.getNetDefense() <= 3) {
spell.setTargetCard(card);
stopSetNext(new Input_PayManaCost(spell));
}
}
};//Input
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(target);
card.addSpellAbility(flashback);
card.setFlashback(true);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Ichor Slick")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -273970706213674570L;
@Override
public boolean canPlayAI() {
CardList c = CardFactoryUtil.AI_getHumanCreature(3, card, true);
CardListUtil.sortAttack(c);
CardListUtil.sortFlying(c);
if(c.isEmpty()) return false;
else {
setTargetCard(c.get(0));
return true;
}
}//canPlayAI()
@Override
public void resolve() {
final Card[] target = new Card[1];
final Command untilEOT = new Command() {
private static final long serialVersionUID = -1615047325868708734L;
public void execute() {
if(AllZone.GameAction.isCardInPlay(target[0])) {
target[0].addTempAttackBoost(3);
target[0].addTempDefenseBoost(3);
}
}
};
target[0] = getTargetCard();
if(AllZone.GameAction.isCardInPlay(target[0]) && CardFactoryUtil.canTarget(card, target[0])) {
target[0].addTempAttackBoost(-3);
target[0].addTempDefenseBoost(-3);
AllZone.EndOfTurn.addUntil(untilEOT);
}
}//resolve()
};//SpellAbility
Input target = new Input() {
private static final long serialVersionUID = -7381927922574152604L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target creature for " + card.getName());
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card card, PlayerZone zone) {
if(!CardFactoryUtil.canTarget(spell, card)) {
AllZone.Display.showMessage("Cannot target this card (Shroud? Protection?).");
} else if(card.isCreature() && zone.is(Constant.Zone.Play)) {
spell.setTargetCard(card);
stopSetNext(new Input_PayManaCost(spell));
}
}
};//Input
spell.setDescription("Target creature gets -3/-3 until end of turn");
card.clearSpellAbility();
card.addSpellAbility(spell);
card.addSpellAbility(CardFactoryUtil.ability_cycle(card, "2"));
spell.setBeforePayMana(target);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Funeral Charm")) {
//discard
final SpellAbility spell_one = new Spell(card) {
private static final long serialVersionUID = 8273875515630095127L;
@Override
public boolean canPlayAI() {
setTargetPlayer(Constant.Player.Human);
return MyRandom.random.nextBoolean();
}
@Override
public void resolve() {
if(Constant.Player.Computer.equals(getTargetPlayer())) AllZone.GameAction.discardRandom(getTargetPlayer());
else AllZone.InputControl.setInput(CardFactoryUtil.input_discard());
}//resolve()
};//SpellAbility
spell_one.setDescription("Target player discards a card.");
spell_one.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell_one));
//creature gets +2/-1
final SpellAbility spell_two = new Spell(card) {
private static final long serialVersionUID = -4554812851052322555L;
@Override
public boolean canPlayAI() {
CardList list = new CardList(ComputerUtil.getAttackers().getAttackers());
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
return 1 < c.getNetDefense();
}
});
list.shuffle();
if(list.size() > 0) setTargetCard(list.get(0));
return (list.size() > 0) && MyRandom.random.nextBoolean();
}
@Override
public void resolve() {
final Card c = getTargetCard();
if(AllZone.GameAction.isCardInPlay(c) && CardFactoryUtil.canTarget(card, c)) {
c.addTempAttackBoost(2);
c.addTempDefenseBoost(-1);
Command until = new Command() {
private static final long serialVersionUID = 4674846621452044251L;
public void execute() {
c.addTempAttackBoost(-2);
c.addTempDefenseBoost(1);
}
};//Command
AllZone.EndOfTurn.addUntil(until);
}//if card in play?
}//resolve()
};//SpellAbility
spell_two.setDescription("Target creature gets +2/-1 until end of turn.");
spell_two.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell_two));
card.clearSpellAbility();
card.addSpellAbility(spell_one);
card.addSpellAbility(spell_two);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Regrowth")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -1771016287736735113L;
@Override
public void resolve() {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
PlayerZone graveyard = AllZone.getZone(Constant.Zone.Graveyard, card.getController());
if(AllZone.GameAction.isCardInZone(getTargetCard(), graveyard)) {
graveyard.remove(getTargetCard());
hand.add(getTargetCard());
}
}//resolve()
@Override
public boolean canPlay() {
PlayerZone graveyard = AllZone.getZone(Constant.Zone.Graveyard, card.getController());
return graveyard.getCards().length != 0 && super.canPlay();
}
};
Input runtime = new Input() {
private static final long serialVersionUID = 3687454413838053102L;
@Override
public void showMessage() {
PlayerZone graveyard = AllZone.getZone(Constant.Zone.Graveyard, card.getController());
Object o = AllZone.Display.getChoiceOptional("Select target card", graveyard.getCards());
if(o == null) stop();
else {
spell.setStackDescription("Return " + o + " to its owner's hand");
spell.setTargetCard((Card) o);
stopSetNext(new Input_PayManaCost(spell));
}
}//showMessage()
};
spell.setChooseTargetAI(CardFactoryUtil.AI_targetType("All", AllZone.Computer_Graveyard));
spell.setBeforePayMana(runtime);
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Commune with Nature")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -7652317332073733242L;
@Override
public boolean canPlayAI() {
return false;
}
@Override
public void resolve() {
String player = card.getController();
if(player.equals(Constant.Player.Human)) humanResolve();
else computerResolve();
}
public void computerResolve() {
//get top 5 cards of library
CardList top = new CardList();
int limit = AllZone.Computer_Library.getCards().length;
for(int i = 0; i < 5 && i < limit; i++) {
top.add(AllZone.Computer_Library.get(0));
AllZone.Computer_Library.remove(0);
}
//put creature card in hand, if there is one
CardList creature = top.getType("Creature");
if(creature.size() != 0) {
AllZone.Computer_Hand.add(creature.get(0));
top.remove(creature.get(0));
}
//put cards on bottom of library
for(int i = 0; i < top.size(); i++)
AllZone.Computer_Library.add(top.get(i));
}//computerResolve()
public void humanResolve() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
CardList list = new CardList();
for(int i = 0; i < 5 && i < library.getCards().length; i++)
list.add(library.get(i));
//optional, select a creature
Object o = AllZone.Display.getChoiceOptional("Select a creature", list.toArray());
if(o != null && ((Card) o).isCreature()) {
AllZone.GameAction.moveTo(hand, (Card) o);
list.remove((Card) o);
}
//put remaining cards on the bottom of the library
for(int i = 0; i < list.size(); i++) {
library.remove(list.get(i));
library.add(list.get(i));
}
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Kodama's Reach")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -3361422153566629825L;
@Override
public void resolve() {
String player = card.getController();
if(player.equals(Constant.Player.Human)) humanResolve();
else computerResolve();
}
public void computerResolve() {
CardList land = new CardList(AllZone.Computer_Library.getCards());
land = land.getType("Basic");
//just to make the computer a little less predictable
land.shuffle();
//3 branches: 1-no land in deck, 2-one land in deck, 3-two or more land in deck
if(land.size() != 0) {
//branch 2 - at least 1 land in library
Card tapped = land.remove(0);
tapped.tap();
AllZone.Computer_Play.add(tapped);
AllZone.Computer_Library.remove(tapped);
//branch 3
if(land.size() != 0) {
Card toHand = land.remove(0);
AllZone.Computer_Hand.add(toHand);
AllZone.Computer_Library.remove(toHand);
}
}
}//computerResolve()
public void humanResolve() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
CardList list = new CardList(library.getCards());
list = list.getType("Basic");
//3 branches: 1-no land in deck, 2-one land in deck, 3-two or more land in deck
//branch 1
if(list.size() == 0) return;
//branch 2
Object o = AllZone.Display.getChoiceOptional("Put into play tapped", list.toArray());
if(o != null) {
Card c = (Card) o;
c.tap();
list.remove(c);
library.remove(c);
play.add(c);
if(list.size() == 0) return;
o = AllZone.Display.getChoiceOptional("Put into your hand", list.toArray());
if(o != null) {
//branch 3
library.remove(o);
hand.add(o);
}
AllZone.GameAction.shuffle(card.getController());
}//if
}//resolve()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Yawgmoth's Bargain")) {
final SpellAbility ability = new Ability(card, "0") {
@Override
public void resolve() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
if(library.size() != 0) {
Card c = library.get(0);
library.remove(0);
hand.add(c);
}
}
@Override
public boolean canPlayAI() {
return false;
}
};//SpellAbility
ability.setDescription("Pay 1 life: Draw a card.");
ability.setStackDescription(card.getName() + " - Pay 1 life: Draw a card.");
card.addSpellAbility(ability);
//instead of paying mana, pay life and add to stack
//Input showMessage() is always the first method called
Input payLife = new Input() {
private static final long serialVersionUID = 8660593629867722192L;
@Override
public void showMessage() {
AllZone.GameAction.getPlayerLife(card.getController()).subtractLife(1);
//this order is very important, do not change
stop();
AllZone.Stack.push(ability);
}
};//Input
ability.setBeforePayMana(payLife);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Necropotence")) {
final CardList necroCards = new CardList();
final Command necro = new Command() {
private static final long serialVersionUID = 4511445425867383336L;
public void execute() {
if(AllZone.GameAction.isCardInPlay(card)) {
//put cards removed by Necropotence into player's hand
if(necroCards.size() > 0) {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
for(int i = 0; i < necroCards.size(); i++) {
hand.add(necroCards.get(i));
}
necroCards.clear();
}
}
}
};
final SpellAbility ability = new Ability(card, "0") {
@Override
public void resolve() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
if(library.size() != 0) {
Card c = library.get(0);
library.remove(0);
necroCards.add(c); //add card to necro so that it goes into hand at end of turn
AllZone.EndOfTurn.addAt(necro);
}
}
@Override
public boolean canPlayAI() {
return false;
}
};//SpellAbility
ability.setDescription("1 life: Set aside the top card of your library face down. At the end of your turn, put that card into your hand.");
ability.setStackDescription(card.getName()
+ " - 1 life: Set aside the top card of your library face down. At the end of your turn, put that card into your hand.");
card.addSpellAbility(ability);
//instead of paying mana, pay life and add to stack
//Input showMessage() is always the first method called
Input payLife = new Input() {
private static final long serialVersionUID = -3846772748411690084L;
@Override
public void showMessage() {
AllZone.GameAction.getPlayerLife(card.getController()).subtractLife(1);
//this order is very important, do not change
stop();
AllZone.Stack.push(ability);
}
};//Input
ability.setBeforePayMana(payLife);
}//*************** END ************ END **************************
//*************** START *********** START **************************
if(cardName.equals("Storm Herd")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 1578037279604088948L;
@Override
public void resolve() {
int life = AllZone.GameAction.getPlayerLife(card.getController()).getLife();
for(int i = 0; i < life; i++)
CardFactoryUtil.makeToken("Pegasus", "W 1 1 Pegasus", card, "W", new String[] {
"Creature", "Pegasus"}, 1, 1, new String[] {"Flying"});
}//resolve()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
if(cardName.equals("Festival of Trokin")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 1140489859175764227L;
@Override
public boolean canPlay() {
setStackDescription(card.getName() + " - " + card.getController() + " gains "
+ calculateLife() + " life.");
return super.canPlay();
}
@Override
public boolean canPlayAI() {
CardList creatureList = new CardList(AllZone.Computer_Play.getCards());
creatureList = creatureList.getType("Creature");
return creatureList.size() > 0;
}
int calculateLife() {
PlayerZone zone = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList creatureList = new CardList(zone.getCards());
creatureList = creatureList.getType("Creature");
return 2 * creatureList.size();
}
@Override
public void resolve() {
AllZone.GameAction.getPlayerLife(card.getController()).addLife(calculateLife());
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Absorb")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -2007620906017942538L;
@Override
public void resolve() {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
PlayerLife life = AllZone.GameAction.getPlayerLife(card.getController());
life.addLife(3);
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& CardFactoryUtil.isCounterable(sa.getSourceCard());
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Undermine")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -4999966043862729936L;
@Override
public void resolve() {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
String opponent = AllZone.GameAction.getOpponent(card.getController());
AllZone.GameAction.getPlayerLife(opponent).subtractLife(3);
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& CardFactoryUtil.isCounterable(sa.getSourceCard());
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Punish Ignorance")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 6845184687406705133L;
@Override
public void resolve() {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
String opponent = AllZone.GameAction.getOpponent(card.getController());
AllZone.GameAction.getPlayerLife(opponent).subtractLife(3);
String player = card.getController();
AllZone.GameAction.getPlayerLife(player).addLife(3);
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& CardFactoryUtil.isCounterable(sa.getSourceCard());
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Exclude")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -5615796501064636046L;
@Override
public void resolve() {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
// AllZone.GameAction.drawCard(card.getController());
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
//is spell?, did opponent play it?, is this a creature spell?
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& sa.getSourceCard().getType().contains("Creature")
&& CardFactoryUtil.isCounterable(sa.getSourceCard());
}//canPlay()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Eladamri's Call")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -6495398165357932918L;
@Override
public void resolve() {
String player = card.getController();
if(player.equals(Constant.Player.Human)) humanResolve();
else computerResolve();
}
public void humanResolve() {
CardList creatures = new CardList(AllZone.Human_Library.getCards());
creatures = creatures.getType("Creature");
Object check = AllZone.Display.getChoiceOptional("Select creature", creatures.toArray());
if(check != null) {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
AllZone.GameAction.moveTo(hand, (Card) check);
}
AllZone.GameAction.shuffle(Constant.Player.Human);
}
public void computerResolve() {
Card[] library = AllZone.Computer_Library.getCards();
CardList list = new CardList(library);
list = list.getType("Creature");
if(list.size() > 0) {
//pick best creature
Card c = CardFactoryUtil.AI_getBestCreature(list);
if(c == null) c = list.get(0);
AllZone.Computer_Library.remove(c);
AllZone.Computer_Hand.add(c);
CardList cl = new CardList();
cl.add(c);
AllZone.Display.getChoiceOptional("Computer picked:", cl.toArray());
}
}
@Override
public boolean canPlay() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
return library.getCards().length != 0;
}
@Override
public boolean canPlayAI() {
CardList creature = new CardList();
creature.addAll(AllZone.Computer_Library.getCards());
creature = creature.getType("Creature");
return creature.size() != 0;
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Dismiss")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -7959473218345045760L;
@Override
public void resolve() {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
// AllZone.GameAction.drawCard(card.getController());
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& CardFactoryUtil.isCounterable(sa.getSourceCard());
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Global Ruin")) {
final CardList target = new CardList();
//need to use arrays so we can declare them final and still set the values in the input and runtime classes. This is a hack.
final int[] index = new int[1];
final int[] countBase = new int[1];
final Vector<String> humanBasic = new Vector<String>();
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 5739127258598357186L;
@Override
public boolean canPlayAI() {
return false;
//should check if computer has land in hand, or if computer has more basic land types than human.
}
@Override
public void resolve() {
//add computer's lands to target
//int computerCountBase = 0;
//Vector<?> computerBasic = new Vector();
//figure out which basic land types the computer has
CardList land = new CardList(AllZone.Computer_Play.getCards());
String basic[] = {"Forest", "Plains", "Mountain", "Island", "Swamp"};
for(int i = 0; i < basic.length; i++) {
CardList cl = land.getType(basic[i]);
if(!cl.isEmpty()) {
//remove one land of this basic type from this list
//the computer AI should really jump in here and select the land which is the best.
//to determine the best look at which lands have enchantments, which lands are tapped
cl.remove(cl.get(0));
//add the rest of the lands of this basic type to the target list, this is the list which will be sacrificed.
target.addAll(cl.toArray());
}
}
//when this spell resolves all basic lands which were not selected are sacrificed.
for(int i = 0; i < target.size(); i++)
if(AllZone.GameAction.isCardInPlay(target.get(i))) AllZone.GameAction.sacrifice(target.get(i));
}//resolve()
};//SpellAbility
final Input input = new Input() {
private static final long serialVersionUID = 1739423591445361917L;
private int count;
@Override
public void showMessage() { //count is the current index we are on.
//countBase[0] is the total number of basic land types the human has
//index[0] is the number to offset the index by
count = countBase[0] - index[0] - 1; //subtract by one since humanBasic is 0 indexed.
if(count < 0) {
//need to reset the variables in case they cancel this spell and it stays in hand.
humanBasic.clear();
countBase[0] = 0;
index[0] = 0;
stop();
} else {
AllZone.Display.showMessage("Select target " + humanBasic.get(count)
+ " land to not sacrifice");
ButtonUtil.enableOnlyCancel();
}
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card c, PlayerZone zone) {
if(c.isLand() && zone.is(Constant.Zone.Play)
&& c.getController().equals(Constant.Player.Human)
&& c.getName().equals(humanBasic.get(count))) {
//get all other basic[count] lands human player controls and add them to target
PlayerZone humanPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList land = new CardList(humanPlay.getCards());
CardList cl = land.getType(humanBasic.get(count));
cl.remove(c);
target.addAll(cl.toArray());
index[0]++;
showMessage();
if(index[0] >= humanBasic.size()) stopSetNext(new Input_PayManaCost(spell));
}
}//selectCard()
};//Input
Input runtime = new Input() {
private static final long serialVersionUID = -122635387376995855L;
@Override
public void showMessage() {
countBase[0] = 0;
//figure out which basic land types the human has
//put those in an set to use later
CardList land = new CardList(AllZone.Human_Play.getCards());
String basic[] = {"Forest", "Plains", "Mountain", "Island", "Swamp"};
for(int i = 0; i < basic.length; i++) {
CardList c = land.getType(basic[i]);
if(!c.isEmpty()) {
humanBasic.add(basic[i]);
countBase[0]++;
}
}
if(countBase[0] == 0) {
//human has no basic land, so don't prompt to select one.
stop();
} else {
index[0] = 0;
target.clear();
stopSetNext(input);
}
}
};//Input
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(runtime);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Gerrard's Verdict")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 4734024742326763385L;
@Override
public boolean canPlayAI() {
PlayerZone humanHand = AllZone.getZone(Constant.Zone.Hand, Constant.Player.Human);
if(humanHand.size() >= 2) return true;
else return false;
}
@Override
public void resolve() {
String player = card.getController();
if(player.equals(Constant.Player.Human)) humanResolve();
else computerResolve();
}
public void humanResolve() {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, Constant.Player.Computer);
CardList list = new CardList(hand.getCards());
list.shuffle();
if(list.size() == 0) return;
Card c1 = list.get(0);
list.remove(c1);
/*
AllZone.Computer_Graveyard.add(c1);
AllZone.Computer_Hand.remove(c1);
*/
AllZone.GameAction.discard(c1);
if(list.size() == 0) return;
Card c2 = list.get(0);
list.remove(c2);
/*
AllZone.Computer_Graveyard.add(c2);
AllZone.Computer_Hand.remove(c2);
*/
AllZone.GameAction.discard(c2);
if(c1.getType().contains("Land")) {
PlayerLife life = AllZone.GameAction.getPlayerLife(Constant.Player.Human);
life.addLife(3);
}
if(c2.getType().contains("Land")) {
PlayerLife life = AllZone.GameAction.getPlayerLife(Constant.Player.Human);
life.addLife(3);
}
}//resolve()
public void computerResolve() {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, Constant.Player.Human);
CardList list = new CardList(hand.getCards());
if(list.size() > 0) {
Object o = AllZone.Display.getChoiceOptional("First card to discard", list.toArray());
Card c = (Card) o;
list.remove(c);
/*
hand.remove(c);
grave.add(c);
*/
AllZone.GameAction.discard(c);
if(c.getType().contains("Land")) {
PlayerLife life = AllZone.GameAction.getPlayerLife(Constant.Player.Computer);
life.addLife(3);
}
if(list.size() > 0) {
Object o2 = AllZone.Display.getChoiceOptional("Second card to discard", list.toArray());
Card c2 = (Card) o2;
list.remove(c2);
/*
hand.remove(c2);
grave.add(c2);
*/
AllZone.GameAction.discard(c2);
if(c2.getType().contains("Land")) {
PlayerLife life = AllZone.GameAction.getPlayerLife(Constant.Player.Computer);
life.addLife(3);
}
}
}
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Temporal Spring")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 2649912511833536966L;
@Override
public boolean canPlayAI() {
CardList human = CardFactoryUtil.AI_getHumanCreature(card, true);
return 3 < AllZone.Phase.getTurn() && 0 < human.size();
}
@Override
public void chooseTargetAI() {
CardList human = CardFactoryUtil.AI_getHumanCreature(card, true);
setTargetCard(CardFactoryUtil.AI_getBestCreature(human));
}
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
if(getTargetCard().isToken()) AllZone.getZone(getTargetCard()).remove(getTargetCard());
else {
AllZone.GameAction.moveToTopOfLibrary(getTargetCard());
}
}//if
}//resolve()
};//SpellAbility
Input target = new Input() {
private static final long serialVersionUID = 3852696858086356864L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target permanent for " + spell.getSourceCard());
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card c, PlayerZone zone) {
if(!CardFactoryUtil.canTarget(spell, c)) {
AllZone.Display.showMessage("Cannot target this card (Shroud? Protection?).");
} else if(zone.is(Constant.Zone.Play)) {
spell.setTargetCard(c);
stopSetNext(new Input_PayManaCost(spell));
}
}
};//Input
spell.setBeforePayMana(target);
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Boomerang") || cardName.equals("Eye of Nowhere")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 5383879224433456795L;
@Override
public boolean canPlayAI() {
CardList human = CardFactoryUtil.AI_getHumanCreature(card, true);
return 3 < AllZone.Phase.getTurn() && 0 < human.size();
}
@Override
public void chooseTargetAI() {
CardList human = CardFactoryUtil.AI_getHumanCreature(card, true);
setTargetCard(CardFactoryUtil.AI_getBestCreature(human));
}
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
if(getTargetCard().isToken()) AllZone.getZone(getTargetCard()).remove(getTargetCard());
else {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, getTargetCard().getOwner());
AllZone.GameAction.moveTo(hand, getTargetCard());
}
//System.out.println("target card has a converted manacost of: " +CardUtil.getConvertedManaCost(targetManaCost));
}//if
}//resolve()
};//SpellAbility
Input target = new Input() {
private static final long serialVersionUID = 7717499561403038165L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target permanent for " + spell.getSourceCard());
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card c, PlayerZone zone) {
if(!CardFactoryUtil.canTarget(spell, c)) {
AllZone.Display.showMessage("Cannot target this card (Shroud? Protection?).");
} else if(zone.is(Constant.Zone.Play)) {
spell.setTargetCard(c);
stopSetNext(new Input_PayManaCost(spell));
}
}
};//Input
spell.setBeforePayMana(target);
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Culling Sun")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 2169815434022673011L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
int convertedManaCost = CardUtil.getConvertedManaCost(c.getManaCost());
if(c.isCreature() && (convertedManaCost <= 3)) AllZone.GameAction.destroy(c);
}
}//resolve()
@Override
public boolean canPlayAI() {
CardList human = new CardList(AllZone.Human_Play.getCards());
CardList computer = new CardList(AllZone.Computer_Play.getCards());
human = human.getType("Creature");
computer = computer.getType("Creature");
//the computer will at least destroy 2 more human creatures
return computer.size() < human.size() - 1
|| (AllZone.Computer_Life.getLife() < 7 && !human.isEmpty());
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Retribution of the Meek")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 4989080454206680708L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
int power = c.getNetAttack();
if(c.isCreature() && (power >= 4)) AllZone.GameAction.destroyNoRegeneration(c);
}
}//resolve()
@Override
public boolean canPlayAI() {
CardList human = new CardList(AllZone.Human_Play.getCards());
CardList computer = new CardList(AllZone.Computer_Play.getCards());
human = human.getType("Creature");
computer = computer.getType("Creature");
human = human.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.getNetAttack() >= 4;
}
});
human = human.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.getNetAttack() >= 4;
}
});
//the computer will at least destroy 2 more human creatures
return computer.size() < human.size() - 1
|| (AllZone.Computer_Life.getLife() < 7 && !human.isEmpty());
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Mass Calcify")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -3985301372801316515L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
//int convertedManaCost = CardUtil.getConvertedManaCost(c.getManaCost());
if(c.isCreature() && !CardUtil.getColors(c).contains(Constant.Color.White)) AllZone.GameAction.destroy(c);
}
}//resolve()
@Override
public boolean canPlayAI() {
CardList human = new CardList(AllZone.Human_Play.getCards());
CardList computer = new CardList(AllZone.Computer_Play.getCards());
human = human.getType("Creature");
computer = computer.getType("Creature");
//the computer will at least destroy 2 more human creatures
return computer.size() < human.size() - 1
|| (AllZone.Computer_Life.getLife() < 7 && !human.isEmpty());
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Cleanse")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 6329910910925881386L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
if(c.isCreature() && CardUtil.getColors(c).contains(Constant.Color.Black)) AllZone.GameAction.destroy(c);
}
}//resolve()
@Override
public boolean canPlayAI() {
CardList hum = new CardList(AllZone.Human_Play.getCards());
CardList comp = new CardList(AllZone.Computer_Play.getCards());
hum = hum.getType("Creature");
comp = comp.getType("Creature");
CardList human = new CardList();
CardList computer = new CardList();
for(int i = 0; i < hum.size(); i++) {
Card c = hum.getCard(i);
if(CardUtil.getColors(c).contains(Constant.Color.Black)) {
human.add(c);
}
}
for(int i = 0; i < comp.size(); i++) {
Card c = comp.getCard(i);
if(CardUtil.getColors(c).contains(Constant.Color.Black)) {
computer.add(c);
}
}
//the computer will at least destroy 2 more human creatures
return computer.size() < human.size() - 1;
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Nature's Ruin")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -2465672405076170648L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
if(c.isCreature() && CardUtil.getColors(c).contains(Constant.Color.Green)) AllZone.GameAction.destroy(c);
}
}//resolve()
@Override
public boolean canPlayAI() {
CardList hum = new CardList(AllZone.Human_Play.getCards());
CardList comp = new CardList(AllZone.Computer_Play.getCards());
hum = hum.getType("Creature");
comp = comp.getType("Creature");
CardList human = new CardList();
CardList computer = new CardList();
for(int i = 0; i < hum.size(); i++) {
Card c = hum.getCard(i);
if(CardUtil.getColors(c).contains(Constant.Color.Green)) {
human.add(c);
}
}
for(int i = 0; i < comp.size(); i++) {
Card c = comp.getCard(i);
if(CardUtil.getColors(c).contains(Constant.Color.Green)) {
computer.add(c);
}
}
//the computer will at least destroy 2 more human creatures
return computer.size() < human.size() - 1;
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Perish")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -9022470313385775867L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
if(c.isCreature() && CardUtil.getColors(c).contains(Constant.Color.Green)) AllZone.GameAction.destroyNoRegeneration(c);
}
}//resolve()
@Override
public boolean canPlayAI() {
CardList hum = new CardList(AllZone.Human_Play.getCards());
CardList comp = new CardList(AllZone.Computer_Play.getCards());
hum = hum.getType("Creature");
comp = comp.getType("Creature");
CardList human = new CardList();
CardList computer = new CardList();
for(int i = 0; i < hum.size(); i++) {
Card c = hum.getCard(i);
if(CardUtil.getColors(c).contains(Constant.Color.Green)) {
human.add(c);
}
}
for(int i = 0; i < comp.size(); i++) {
Card c = comp.getCard(i);
if(CardUtil.getColors(c).contains(Constant.Color.Green)) {
computer.add(c);
}
}
//the computer will at least destroy 2 more human creatures
return computer.size() < human.size() - 1;
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Virtue's Ruin")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -4805304550512861722L;
@Override
public void resolve() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
for(int i = 0; i < all.size(); i++) {
Card c = all.get(i);
if(c.isCreature() && CardUtil.getColors(c).contains(Constant.Color.White)) AllZone.GameAction.destroy(c);
}
}//resolve()
@Override
public boolean canPlayAI() {
CardList hum = new CardList(AllZone.Human_Play.getCards());
CardList comp = new CardList(AllZone.Computer_Play.getCards());
hum = hum.getType("Creature");
comp = comp.getType("Creature");
CardList human = new CardList();
CardList computer = new CardList();
for(int i = 0; i < hum.size(); i++) {
Card c = hum.getCard(i);
if(CardUtil.getColors(c).contains(Constant.Color.White)) {
human.add(c);
}
}
for(int i = 0; i < comp.size(); i++) {
Card c = comp.getCard(i);
if(CardUtil.getColors(c).contains(Constant.Color.White)) {
computer.add(c);
}
}
//the computer will at least destroy 2 more human creatures
return computer.size() < human.size() - 1;
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Overwhelming Intellect")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -8825219868732813877L;
@Override
public void resolve() {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
int convertedManaCost = CardUtil.getConvertedManaCost(sa.getSourceCard().getManaCost());
for(int i = 0; i < convertedManaCost; i++) {
AllZone.GameAction.drawCard(card.getController());
}
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& sa.getSourceCard().getType().contains("Creature")
&& CardFactoryUtil.isCounterable(sa.getSourceCard());
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Duress")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 2180416205027322268L;
@Override
public void resolve() {
Card choice = null;
//check for no cards in hand on resolve
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, getTargetPlayer());
CardList cards = new CardList(hand.getCards());
CardList nonCreatureCards = new CardList();
for(int i = 0; i < cards.size(); i++) {
if(!cards.get(i).getType().contains("Creature")
&& !cards.get(i).getType().contains("Land")) //remove land + creats
{
//System.out.println("Duress: " + cards.get(i).getType());
//cards.remove(i);
nonCreatureCards.add(cards.get(i));
}
}
if(cards.size() == 0) return;
//human chooses
if(card.getController().equals(Constant.Player.Human)) {
AllZone.Display.getChoice("Revealing hand", cards.toArray());
if(nonCreatureCards.size() == 0) return;
choice = AllZone.Display.getChoice("Choose", nonCreatureCards.toArray());
} else//computer chooses
{
if(nonCreatureCards.size() == 0) return;
choice = CardUtil.getRandom(nonCreatureCards.toArray());
}
AllZone.GameAction.discard(choice);
}//resolve()
@Override
public boolean canPlayAI() {
Card[] c = removeLandAndCreats(AllZone.Human_Hand.getCards());
return 0 < c.length;
}
Card[] removeLandAndCreats(Card[] in) {
CardList c = new CardList(in);
c = c.filter(new CardListFilter() {
public boolean addCard(Card c) {
//return !c.isLand();
if(!c.isLand() && !c.isCreature()) return true;
else return false;
}
});
return c.toArray();
}//removeLand()
};//SpellAbility spell
spell.setChooseTargetAI(CardFactoryUtil.AI_targetHuman());
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Ostracize")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -8919895406095857866L;
@Override
public void resolve() {
Card choice = null;
//check for no cards in hand on resolve
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, getTargetPlayer());
CardList cards = new CardList(hand.getCards());
CardList creatureCards = new CardList();
for(int i = 0; i < cards.size(); i++) {
if(cards.get(i).getType().contains("Creature")) {
//System.out.println("ostracize: " + cards.get(i).getType());
creatureCards.add(cards.get(i));
}
}
if(cards.size() == 0) return;
//human chooses
if(card.getController().equals(Constant.Player.Human)) {
AllZone.Display.getChoice("Revealing hand", cards.toArray());
if(creatureCards.size() == 0) return;
choice = AllZone.Display.getChoice("Choose", creatureCards.toArray());
} else//computer chooses
{
if(creatureCards.size() == 0) return;
choice = CardUtil.getRandom(creatureCards.toArray());
}
AllZone.GameAction.discard(choice);
}//resolve()
@Override
public boolean canPlayAI() {
Card[] c = removeNonCreats(AllZone.Human_Hand.getCards());
return 0 < c.length;
}
Card[] removeNonCreats(Card[] in) {
CardList c = new CardList(in);
c = c.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isCreature();
}
});
return c.toArray();
}//removeLand()
};//SpellAbility spell
spell.setChooseTargetAI(CardFactoryUtil.AI_targetHuman());
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Hoofprints of the Stag")) {
Command intoPlay = new Command() {
private static final long serialVersionUID = -7275454992618058248L;
public boolean firstTime = true;
public void execute() {
if(firstTime) {
card.setCounter(Counters.HOOFPRINT, 0);
}
firstTime = false;
}
};
card.addComesIntoPlayCommand(intoPlay);
final SpellAbility a2 = new Ability(card, "2 W") {
@Override
public void resolve() {
card.subtractCounter(Counters.HOOFPRINT, 4);
CardFactoryUtil.makeToken("Elemental", "W 4 4 Elemental", card, "W", new String[] {
"Creature", "Elemental"}, 4, 4, new String[] {"Flying"});
}
@Override
public boolean canPlay() {
SpellAbility sa;
for(int i = 0; i < AllZone.Stack.size(); i++) {
sa = AllZone.Stack.peek(i);
if(sa.getSourceCard().equals(card)) return false;
}
return card.getCounters(Counters.HOOFPRINT) >= 4
&& AllZone.getZone(card).is(Constant.Zone.Play)
&& AllZone.Phase.getActivePlayer().equals(card.getController())
&& !AllZone.Phase.getPhase().equals("End of Turn");
}//canPlay()
@Override
public boolean canPlayAI() {
return true;
}
};//spellAbility
a2.setDescription("2 W, Remove four hoofprint counters from Hoofprints of the Stag: Put a 4/4 white Elemental creature token with flying into play. Play this ability only during your turn.");
a2.setStackDescription(card.getName()
+ " - put a 4/4 white Elemental creature token with flying into play.");
card.addSpellAbility(a2);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Goblin Trenches")) {
final String player = card.getController();
final SpellAbility ability = new Ability(card, "2") {
@Override
public boolean canPlay() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, player);
CardList lands = new CardList();
lands.addAll(play.getCards());
lands = lands.getType("Land");
if(lands.size() >= 1 && AllZone.GameAction.isCardInPlay(card)) return true;
else return false;
}
@Override
public void chooseTargetAI() {
Card c = getTappedLand(); //first, try to get a tapped land to sac
if(c != null) {
setTargetCard(c);
} else {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, player);
CardList lands = new CardList();
lands.addAll(play.getCards());
lands = lands.getType("Land");
c = lands.get(0);
setTargetCard(c);
}
}
public Card getTappedLand() {
//target creature that is going to attack
PlayerZone play = AllZone.getZone(Constant.Zone.Play, player);
CardList lands = new CardList();
lands.addAll(play.getCards());
lands = lands.getType("Land");
for(int i = 0; i < lands.size(); i++) {
if(lands.get(i).isTapped()) return lands.get(i);
}
return null;
}//getAttacker()
@Override
public boolean canPlayAI() {
String phase = AllZone.Phase.getPhase();
return phase.equals(Constant.Phase.Main2);
}
@Override
public void resolve() {
Card c = getTargetCard();
if(AllZone.GameAction.isCardInPlay(c)) {
AllZone.GameAction.sacrifice(c);
makeToken();
makeToken();
}
}//resolve
public void makeToken() {
CardFactoryUtil.makeToken("Goblin Soldier", "RW 1 1 Goblin Soldier", card, "RW", new String[] {
"Creature", "Goblin", "Soldier"}, 1, 1, new String[] {""});
}
};
Input runtime = new Input() {
private static final long serialVersionUID = -7823269301012427007L;
@Override
public void showMessage() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, player);
CardList lands = new CardList();
lands.addAll(play.getCards());
lands = lands.getType("Land");
stopSetNext(CardFactoryUtil.input_targetSpecific(ability, lands, "Select a land to sacrifice",
false, false));
}//showMessage()
};//Input
card.addSpellAbility(ability);
ability.setDescription("2, Sacrifice a land: Put two 1/1 red and white Goblin Soldier creature tokens into play.");
ability.setStackDescription(card.getName()
+ " - put two 1/1 red and white Goblin Soldier creature tokens into play.");
ability.setBeforePayMana(runtime);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Hatching Plans")) {
final Ability ability = new Ability(card, "0") {
@Override
public void resolve() {
AllZone.GameAction.drawCard(card.getController());
AllZone.GameAction.drawCard(card.getController());
AllZone.GameAction.drawCard(card.getController());
}
};
Command draw3Cards = new Command() {
private static final long serialVersionUID = -4919203791300685078L;
public void execute() {
ability.setStackDescription(card.getName() + " - draw three cards.");
AllZone.Stack.add(ability);
}
};
card.addDestroyCommand(draw3Cards);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Sleight of Hand")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 5608200094037045828L;
@Override
public boolean canPlay() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
if(library.size() >= 1 && super.canPlay()) return true;
else return false;
}
@Override
public void resolve() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
CardList lib = new CardList(library.getCards());
CardList topTwo = new CardList();
if(lib.size() == 1) {
AllZone.GameAction.drawCard(card.getController());
} else {
if(card.getController().equals(Constant.Player.Human)) {
topTwo.add(lib.get(0));
topTwo.add(lib.get(1));
Object o = AllZone.Display.getChoiceOptional("Select card to put in hand: ",
topTwo.toArray());
Card c1 = (Card) o;
topTwo.remove(c1);
library.remove(c1);
hand.add(c1);
Card c2 = topTwo.get(0);
library.remove(c2);
library.add(c2);
} else //computer
{
Card c1 = lib.get(0);
library.remove(c1);
lib.remove(c1);
hand.add(c1);
Card c2 = lib.get(0);
library.remove(c2);
lib.remove(c2);
library.add(c2); //put on bottom
}
}
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Banishing Knack")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 6518824567946786581L;
@Override
public boolean canPlayAI() {
return false;
}
@Override
public void resolve() {
final Card creature = getTargetCard();
final Ability_Tap tBanish = new Ability_Tap(creature) {
private static final long serialVersionUID = -1008113001678623984L;
@Override
public boolean canPlayAI() {
return false;
}
@Override
public void resolve() {
setStackDescription(creature + " - Return" + getTargetCard() + "to its owner's hand");
final Card[] target = new Card[1];
target[0] = getTargetCard();
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, target[0].getOwner());
if(AllZone.GameAction.isCardInPlay(target[0])
&& CardFactoryUtil.canTarget(creature, target[0])) {
AllZone.GameAction.moveTo(hand, target[0]);
}
}//resolve()
};//tBanish;
tBanish.setDescription("T: Return target nonland permanent to its owner's hand.");
creature.addSpellAbility(tBanish);
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
all = all.filter(new CardListFilter() {
public boolean addCard(Card c) {
return (!c.isLand() && CardFactoryUtil.canTarget(creature, c));
}
});
tBanish.setBeforePayMana(CardFactoryUtil.input_targetSpecific(tBanish, all,
"Return target nonland permanent to its owner's hand.", true, false));
AllZone.EndOfTurn.addUntil(new Command() {
private static final long serialVersionUID = -7819140065166374666L;
public void execute() {
creature.removeSpellAbility(tBanish);
}
});
}
};//SpellAbility
spell.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setDescription("Until end of turn, target creature gains \"T: Return target nonland permanent to its owner's hand.\"");
spell.setStackDescription("Target creature gains \"T: Return target nonland permanent to its owner's hand.\"");
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Dragon Blood")) {
Ability_Tap ability = new Ability_Tap(card, "3") {
private static final long serialVersionUID = -8095802059752537764L;
@Override
public void resolve() {
if(getTargetCard() != null && getTargetCard().isCreature()
&& CardFactoryUtil.canTarget(card, getTargetCard())) getTargetCard().addCounter(
Counters.P1P1, 1);
}
@Override
public boolean canPlayAI() {
CardList list = new CardList(AllZone.Computer_Play.getCards());
list = list.getType("Creature");
if(list.size() > 0) {
setTargetCard(CardFactoryUtil.AI_getBestCreature(list));
return (getTargetCard() != null);
}
return false;
}
};
ability.setBeforePayMana(CardFactoryUtil.input_targetCreature(ability));
ability.setDescription("3, T: Put a +1/+1 counter on target creature.");
ability.setStackDescription(card + ": put a +1/+1 counter on target Creature.");
card.addSpellAbility(ability);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Reminisce")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 505983020365091226L;
@Override
public void resolve() {
String player = getTargetPlayer();
// Move graveyard into library
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, player);
PlayerZone library = AllZone.getZone(Constant.Zone.Library, player);
Card[] g = grave.getCards();
for(int i = 0; i < g.length; i++) {
grave.remove(g[i]);
library.add(g[i], 0);
}
// Shuffle library
AllZone.GameAction.shuffle(player);;
}
@Override
public boolean canPlayAI()//97% of the time shuffling your grave into your library is a good thing
{
setTargetPlayer(Constant.Player.Computer);
return true;
}
};//SpellAbility
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("AEther Vial")) {
//final int[] converted = null;
final Ability_Tap ability = new Ability_Tap(card, "0") {
private static final long serialVersionUID = 1854859213307704018L;
@Override
public boolean canPlay() {
return card.getCounters(Counters.CHARGE) > 0;
}
@Override
public void resolve() {
String player = card.getController();
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, player);
PlayerZone play = AllZone.getZone(Constant.Zone.Play, player);
//converted[0] = card.getCounters(Counters.CHARGE);
//System.out.println("converted: " + converted[0]);
CardList list = new CardList(hand.getCards());
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
return CardUtil.getConvertedManaCost(c.getManaCost()) == card.getCounters(Counters.CHARGE)
&& c.isCreature();
}
});
if(list.size() > 0) {
if(player.equals(Constant.Player.Human)) {
Object o = AllZone.Display.getChoiceOptional("Pick creature to put into play",
list.toArray());
if(o != null) {
Card c = (Card) o;
hand.remove(c);
play.add(c);
}
} else {
Card c = list.get(0);
if(AllZone.GameAction.isCardInZone(c, hand)) {
hand.remove(c);
play.add(c);
}
}
}
}
};
ability.setDescription("Tap: You may put a creature card with converted mana cost equal to the number of charge counters on AEther Vial from your hand into play.");
ability.setStackDescription(card.getName()
+ " - put creature card with converted mana cost equal to the number of charge counters into play.");
card.addSpellAbility(ability);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("AEther Spellbomb")) {
final Ability ability = new Ability(card, "U") {
@Override
public boolean canPlay() {
return AllZone.GameAction.isCardInPlay(card) && !AllZone.Stack.getSourceCards().contains(card);
}
@Override
public boolean canPlayAI() {
CardList humanPlay = new CardList(AllZone.Human_Play.getCards());
humanPlay = humanPlay.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isCreature() && CardFactoryUtil.canTarget(card, c);
}
});
if(humanPlay.size() > 0) setTargetCard(CardFactoryUtil.AI_getBestCreature(humanPlay));
return ((AllZone.Computer_Hand.size() > 2) && (getTargetCard() != null));
}
@Override
public void resolve() {
final Card[] target = new Card[1];
target[0] = getTargetCard();
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, target[0].getOwner());
if(AllZone.GameAction.isCardInPlay(target[0]) && CardFactoryUtil.canTarget(card, target[0])) {
if(!target[0].isToken()) AllZone.GameAction.moveTo(hand, target[0]);
else AllZone.getZone(target[0]).remove(target[0]);
}
AllZone.GameAction.sacrifice(getSourceCard());
}//resolve()
};//SpellAbility
ability.setDescription("U, Sacrifice AEther Spellbomb: Return target creature to its owner's hand.");
card.addSpellAbility(ability);
ability.setBeforePayMana(CardFactoryUtil.input_targetCreature(ability));
}
//*************** START *********** START **************************
else if(cardName.equals("Lifespark Spellbomb")) {
final SpellAbility ability = new Ability_Activated(card, "G") {
private static final long serialVersionUID = -5744842090293912606L;
@Override
public boolean canPlay() {
return AllZone.GameAction.isCardInPlay(card) && !AllZone.Stack.getSourceCards().contains(card);
}
@Override
public boolean canPlayAI() {
CardList land = new CardList(AllZone.Computer_Play.getCards());
land = land.getType("Land");
CardList basic = land.getType("Basic");
if(basic.size() < 3) return false;
Card[] basic_1 = basic.toArray();
for(Card var:basic_1)
if(var.isTapped()) basic.remove(var);
basic.shuffle();
if(basic.size() == 0) return false;
if(basic.get(0) != null) {
setTargetCard(basic.get(0));
return true;
}
return false;
}//canPlayAI()
@Override
public void resolve() {
//in case ability is played twice
final int[] oldAttack = new int[1];
final int[] oldDefense = new int[1];
final Card card[] = new Card[1];
card[0] = getTargetCard();
oldAttack[0] = card[0].getBaseAttack();
oldDefense[0] = card[0].getBaseDefense();
card[0].setBaseAttack(3);
card[0].setBaseDefense(3);
card[0].addType("Creature");
//EOT
final Command untilEOT = new Command() {
private static final long serialVersionUID = 7236360479349324099L;
public void execute() {
card[0].setBaseAttack(oldAttack[0]);
card[0].setBaseDefense(oldDefense[0]);
card[0].removeType("Creature");
}
};
AllZone.EndOfTurn.addUntil(untilEOT);
AllZone.GameAction.sacrifice(getSourceCard());
}//resolve()
};//SpellAbility
card.addSpellAbility(ability);
ability.setDescription("G, Sacrifice Lifespark Spellbomb: Target land becomes a 3/3 Creature until end of turn. It is still a land.");
ability.setBeforePayMana(CardFactoryUtil.input_targetType(ability, "Land"));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Pyrite Spellbomb")) {
final SpellAbility ability = new Ability_Activated(card, "R") {
private static final long serialVersionUID = 1L;
@Override
public boolean canPlay() {
return AllZone.GameAction.isCardInPlay(card) && !AllZone.Stack.getSourceCards().contains(card);
}
@Override
public boolean canPlayAI() {
Random r = new Random();
if(r.nextFloat() <= Math.pow(.6667, card.getAbilityUsed())) return true;
else return false;
}
@Override
public void chooseTargetAI() {
CardList list = CardFactoryUtil.AI_getHumanCreature(2, card, true);
list.shuffle();
if(list.isEmpty() || AllZone.Human_Life.getLife() < 5 + 2) setTargetPlayer(Constant.Player.Human);
else setTargetCard(list.get(0));
}//chooseTargetAI
@Override
public void resolve() {
if(getTargetCard() != null) {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) getTargetCard().addDamage(2,
card);
} else AllZone.GameAction.getPlayerLife(getTargetPlayer()).subtractLife(2);
AllZone.GameAction.sacrifice(getSourceCard());
}//resolve()
};//Ability_Activated
ability.setBeforePayMana(CardFactoryUtil.input_targetCreaturePlayer(ability, true, false));
ability.setDescription("R, Sacrifice Pyrite Spellbomb: Pyrite Spellbomb deals 2 damage to target creature or player.");
card.addSpellAbility(ability);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Sunbeam Spellbomb")) {
final Ability ability = new Ability(card, "W") {
@Override
public boolean canPlay() {
return AllZone.GameAction.isCardInPlay(card) && !AllZone.Stack.getSourceCards().contains(card);
}
@Override
public boolean canPlayAI() {
return (AllZone.GameAction.getPlayerLife(Constant.Player.Computer).getLife() < 7);
}
@Override
public void resolve() {
AllZone.GameAction.getPlayerLife(card.getController()).addLife(5);
AllZone.GameAction.sacrifice(getSourceCard());
}//resolve()
};//SpellAbility
ability.setStackDescription("You gain 5 life");
ability.setStackDescription(card.getName() + " - " + card.getController() + " gains 5 life.");
card.addSpellAbility(ability);
} //*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Necrogen Spellbomb")) {
final Ability ability = new Ability(card, "B") {
@Override
public boolean canPlay() {
return AllZone.GameAction.isCardInPlay(card) && !AllZone.Stack.getSourceCards().contains(card);
}
@Override
public boolean canPlayAI() {
setTargetPlayer(Constant.Player.Human);
return (MyRandom.random.nextBoolean() && AllZone.Human_Hand.size() > 0);
}
@Override
public void resolve() {
String s = getTargetPlayer();
setStackDescription("Necrogen Spellbomb - " + s + " discards a card");
if(Constant.Player.Computer.equals(getTargetPlayer())) AllZone.GameAction.discardRandom(getTargetPlayer());
else AllZone.InputControl.setInput(CardFactoryUtil.input_discard());
AllZone.GameAction.sacrifice(getSourceCard());
}//resolve()
};//SpellAbility
ability.setDescription("B, Sacrifice Necrogen Spellbomb: Target player discards a card");
ability.setBeforePayMana(CardFactoryUtil.input_targetPlayer(ability));
card.addSpellAbility(ability);
} //*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Sensei's Divining Top")) {
//ability2: Draw card, and put divining top on top of library
final SpellAbility ability2 = new Ability_Tap(card, "0") {
private static final long serialVersionUID = -2523015092351744208L;
@Override
public void resolve() {
String player = card.getController();
String owner = card.getOwner();
PlayerZone play = AllZone.getZone(Constant.Zone.Play, player);
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, owner);
AllZone.GameAction.drawCard(player);
play.remove(card);
lib.add(card, 0); //move divining top to top of library
card.untap();
}
@Override
public boolean canPlayAI() {
return false;
}
@Override
public boolean canPlay() {
if(AllZone.getZone(card).is(Constant.Zone.Play)) return true;
else return false;
}//canPlay()
};//SpellAbility ability2
ability2.setBeforePayMana(new Input() {
private static final long serialVersionUID = -4773496833654414458L;
@Override
public void showMessage() {
AllZone.Stack.push(ability2);
stop();
}//showMessage()
});
//ability (rearrange top 3 cards) :
final SpellAbility ability1 = new Ability(card, "1") {
@Override
public void resolve() {
String player = card.getController();
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, player);
if(lib.size() < 3) return;
CardList topThree = new CardList();
//show top 3 cards:
topThree.add(lib.get(0));
topThree.add(lib.get(1));
topThree.add(lib.get(2));
for(int i = 1; i <= 3; i++) {
String Title = "Put on top: ";
if(i == 2) Title = "Put second from top: ";
if(i == 3) Title = "Put third from top: ";
Object o = AllZone.Display.getChoiceOptional(Title, topThree.toArray());
if(o == null) break;
Card c_1 = (Card) o;
topThree.remove(c_1);
lib.remove(c_1);
lib.add(c_1, i - 1);
}
}
@Override
public boolean canPlayAI() {
return false;
}
@Override
public boolean canPlay() {
if(AllZone.getZone(card).is(Constant.Zone.Play)) return true;
else return false;
}//canPlay()
};//SpellAbility ability1
ability1.setDescription("1: Look at the top three cards of your library, then put them back in any order.");
ability1.setStackDescription("Sensei's Divining Top - rearrange top 3 cards");
card.addSpellAbility(ability1);
ability1.setBeforePayMana(new Input_PayManaCost(ability1));
ability2.setDescription("tap: Draw a card, then put Sensei's Divining Top on top of its owner's library.");
ability2.setStackDescription("Sensei's Divining Top - draw a card, then put back on owner's library");
ability2.setBeforePayMana(new Input_NoCost_TapAbility((Ability_Tap) ability2));
card.addSpellAbility(ability2);
}
//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Vampiric Tutor") || cardName.equals("Cruel Tutor")
|| cardName.equals("Imperial Seal")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 8922434714488681861L;
@Override
public boolean canPlayAI() {
PlayerLife compLife = AllZone.GameAction.getPlayerLife("Computer");
int life = compLife.getLife();
if(4 < AllZone.Phase.getTurn() && AllZone.Computer_Library.size() > 0 && life >= 4) return true;
else return false;
}
@Override
public void resolve() {
String player = card.getController();
if(player.equals(Constant.Player.Human)) humanResolve();
else computerResolve();
}
public void computerResolve() {
//TODO: somehow select a good non-creature card for AI
CardList creature = new CardList(AllZone.Computer_Library.getCards());
creature = creature.getType("Creature");
if(creature.size() != 0) {
Card c = CardFactoryUtil.AI_getBestCreature(creature);
if(c == null) {
creature.shuffle();
c = creature.get(0);
}
AllZone.GameAction.shuffle(card.getController());
//move to top of library
AllZone.Computer_Library.remove(c);
AllZone.Computer_Library.add(c, 0);
//lose 2 life
String player = Constant.Player.Computer;
PlayerLife life = AllZone.GameAction.getPlayerLife(player);
life.subtractLife(2);
}
}//computerResolve()
public void humanResolve() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
CardList list = new CardList(library.getCards());
if(list.size() != 0) {
Object o = AllZone.Display.getChoiceOptional("Select a card", list.toArray());
AllZone.GameAction.shuffle(card.getController());
if(o != null) {
//put card on top of library
library.remove(o);
library.add((Card) o, 0);
}
//lose 2 life
String player = Constant.Player.Human;
PlayerLife life = AllZone.GameAction.getPlayerLife(player);
life.subtractLife(2);
}//if
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Counterbalance")) {
String player = card.getController();
final SpellAbility ability = new Ability(card, "0") {
@Override
public void resolve() {
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, card.getController());
Card topCard = lib.get(0);
SpellAbility sa = AllZone.Stack.peek();
int convertedManaTopCard = CardUtil.getConvertedManaCost(topCard.getManaCost());
int convertedManaSpell = CardUtil.getConvertedManaCost(sa.getSourceCard().getManaCost());
CardList showTop = new CardList();
showTop.add(topCard);
AllZone.Display.getChoiceOptional("Revealed top card: ", showTop.toArray());
if(convertedManaTopCard == convertedManaSpell) {
AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
}
}
@Override
public boolean canPlayAI() {
return false;
}
@Override
public boolean canPlay() {
String player = card.getController();
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, player);
if(AllZone.Stack.size() == 0 || lib.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
if(AllZone.getZone(card).is(Constant.Zone.Play) && sa.isSpell()
&& opponent.equals(sa.getSourceCard().getController())
&& CardFactoryUtil.isCounterable(sa.getSourceCard())) return true;
else return false;
}//canPlay()
};//SpellAbility ability
ability.setStackDescription("Counterbalance - " + player
+ " reveals top card and counters spell if it has the same converted manacost");
ability.setBeforePayMana(new Input_PayManaCost(ability));
card.addSpellAbility(ability);
}
//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Aluren")) {
final Ability ability1 = new Ability(card, "0") {
@Override
public void resolve() {
//String player = card.getController();
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, Constant.Player.Human);
PlayerZone play = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
if(hand.size() == 0) return;
CardList creatures = new CardList();
for(int i = 0; i < hand.size(); i++) {
if(hand.get(i).getType().contains("Creature")
&& CardUtil.getConvertedManaCost(hand.get(i).getManaCost()) <= 3) creatures.add(hand.get(i));
}
if(creatures.size() == 0) return;
Object o = AllZone.Display.getChoiceOptional("Select target creature to play",
creatures.toArray());
if(o != null) {
Card c = (Card) o;
hand.remove(c);
play.add(c);
c.setSickness(true);
}
}
@Override
public boolean canPlayAI() {
return false;
}
@Override
public boolean canPlay() {
if(AllZone.getZone(card).is(Constant.Zone.Play)) return true;
else return false;
}//canPlay()
};//SpellAbility ability1
ability1.setDescription("Any player may play creature cards with converted mana cost 3 or less without paying their mana cost any time he or she could play an instant.");
ability1.setStackDescription("Aluren - Play creature with converted manacost 3 or less for free.");
card.addSpellAbility(ability1);
ability1.setBeforePayMana(new Input_PayManaCost(ability1));
}
//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Intuition")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 8282597086298330698L;
@Override
public void resolve() {
String player = card.getController();
if(player.equals(Constant.Player.Human)) humanResolve();
else computerResolve();
}
public void humanResolve() {
CardList libraryList = new CardList(AllZone.Human_Library.getCards());
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
CardList selectedCards = new CardList();
Object o = AllZone.Display.getChoiceOptional("Select first card", libraryList.toArray());
if(o != null) {
Card c1 = (Card) o;
libraryList.remove(c1);
selectedCards.add(c1);
} else {
return;
}
o = AllZone.Display.getChoiceOptional("Select second card", libraryList.toArray());
if(o != null) {
Card c2 = (Card) o;
libraryList.remove(c2);
selectedCards.add(c2);
} else {
return;
}
o = AllZone.Display.getChoiceOptional("Select third card", libraryList.toArray());
if(o != null) {
Card c3 = (Card) o;
libraryList.remove(c3);
selectedCards.add(c3);
} else {
return;
}
Card choice = selectedCards.get(MyRandom.random.nextInt(2)); //comp randomly selects one of the three cards
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, card.getController());
library.remove(choice);
hand.add(choice);
selectedCards.remove(choice);
Card toGrave1 = selectedCards.get(0);
Card toGrave2 = selectedCards.get(1);
library.remove(toGrave1);
library.remove(toGrave2);
selectedCards.remove(toGrave2);
selectedCards.remove(toGrave2);
grave.add(toGrave1);
grave.add(toGrave2);
AllZone.GameAction.shuffle(Constant.Player.Human);
}
public void computerResolve() {
Card[] library = AllZone.Computer_Library.getCards();
CardList list = new CardList(library);
CardList selectedCards = new CardList();
//pick best creature
Card c = CardFactoryUtil.AI_getBestCreature(list);
if(c == null) {
c = library[0];
}
list.remove(c);
selectedCards.add(c);
c = CardFactoryUtil.AI_getBestCreature(list);
if(c == null) {
c = library[0];
}
list.remove(c);
selectedCards.add(c);
c = CardFactoryUtil.AI_getBestCreature(list);
if(c == null) {
c = library[0];
}
list.remove(c);
selectedCards.add(c);
Object o = AllZone.Display.getChoiceOptional("Select card to give to computer",
selectedCards.toArray());
Card choice = (Card) o;
selectedCards.remove(choice);
AllZone.Computer_Library.remove(choice);
AllZone.Computer_Hand.add(choice);
AllZone.Computer_Library.remove(selectedCards.get(0));
AllZone.Computer_Library.remove(selectedCards.get(1));
AllZone.Computer_Graveyard.add(selectedCards.get(0));
AllZone.Computer_Graveyard.add(selectedCards.get(1));
}
@Override
public boolean canPlay() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
return library.getCards().length >= 3;
}
@Override
public boolean canPlayAI() {
CardList creature = new CardList();
creature.addAll(AllZone.Computer_Library.getCards());
creature = creature.getType("Creature");
return creature.size() != 0;
}
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Invincible Hymn")) {
final String player = card.getController();
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -827136493013927725L;
@Override
public void resolve() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
CardList libCards = new CardList(library.getCards());
int lifeGain = libCards.size();
System.out.println("lifeGain: " + lifeGain);
PlayerLife life = AllZone.GameAction.getPlayerLife(player);
life.setLife(lifeGain);
System.out.println("life.getLife(): " + life.getLife());
}
@Override
public boolean canPlayAI() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
CardList libCards = new CardList(library.getCards());
int lifeGain = libCards.size();
PlayerLife compLife = AllZone.GameAction.getPlayerLife(Constant.Player.Computer);
if(lifeGain > compLife.getLife()) return true;
else return false;
}
};//spell
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Gift of Estates")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -4997834790204261916L;
@Override
public boolean canPlay() {
String oppPlayer = AllZone.GameAction.getOpponent(card.getController());
PlayerZone selfZone = AllZone.getZone(Constant.Zone.Play, card.getController());
PlayerZone oppZone = AllZone.getZone(Constant.Zone.Play, oppPlayer);
CardList self = new CardList(selfZone.getCards());
CardList opp = new CardList(oppZone.getCards());
self = self.getType("Land");
opp = opp.getType("Land");
return (self.size() < opp.size()) && super.canPlay();
}//canPlay()
@Override
public void resolve() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
CardList plains = new CardList(library.getCards());
plains = plains.getType("Plains");
for(int i = 0; i < 3 && i < plains.size(); i++)
AllZone.GameAction.moveTo(hand, plains.get(i));
}//resolve()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Tithe")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 1504792204526793942L;
public boolean oppMoreLand() {
String oppPlayer = AllZone.GameAction.getOpponent(card.getController());
PlayerZone selfZone = AllZone.getZone(Constant.Zone.Play, card.getController());
PlayerZone oppZone = AllZone.getZone(Constant.Zone.Play, oppPlayer);
CardList self = new CardList(selfZone.getCards());
CardList opp = new CardList(oppZone.getCards());
self = self.getType("Land");
opp = opp.getType("Land");
return (self.size() < opp.size()) && super.canPlay();
}//oppoMoreLand()
@Override
public void resolve() {
PlayerZone library = AllZone.getZone(Constant.Zone.Library, card.getController());
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
CardList plains = new CardList(library.getCards());
plains = plains.getType("Plains");
if(0 < plains.size()) AllZone.GameAction.moveTo(hand, plains.get(0));
if(oppMoreLand() && 1 < plains.size()) AllZone.GameAction.moveTo(hand, plains.get(1));
}//resolve()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Survival of the Fittest")) {
SpellAbility ability = new Ability(card, "G") {
@Override
public void resolve() {
String player = card.getController();
if(player.equals(Constant.Player.Human)) humanResolve();
else computerResolve();
}//resolve()
public void humanResolve() {
CardList handCreatures = new CardList(AllZone.Human_Hand.getCards());
handCreatures = handCreatures.getType("Creature");
if(handCreatures.size() == 0) return;
Object discard = AllZone.Display.getChoiceOptional("Select Creature to discard",
handCreatures.toArray());
if(discard != null) {
CardList creatures = new CardList(AllZone.Human_Library.getCards());
creatures = creatures.getType("Creature");
if(creatures.size() != 0) {
Object check = AllZone.Display.getChoiceOptional("Select Creature",
creatures.toArray());
if(check != null) {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
AllZone.GameAction.moveTo(hand, (Card) check);
}
AllZone.GameAction.shuffle(Constant.Player.Human);
}
AllZone.GameAction.discard((Card) discard);
}
}
public void computerResolve() {
//TODO
}
@Override
public boolean canPlayAI() {
return false;
}
};//SpellAbility
//card.clearSpellAbility();
ability.setDescription("G: Discard a creature card: Search your library for a creature card, reveal that card, and put it into your hand. Then shuffle your library.");
ability.setStackDescription("Survival of the Fittest - search for a creature card and put into hand");
card.addSpellAbility(ability);
}//*************** END ************ END **************************
/*
//*************** START *********** START **************************
else if(cardName.equals("Gerrard's Command"))
{
SpellAbility spell = new Spell(card)
{
private static final long serialVersionUID = 3128602006949603902L;
public boolean canPlayAI()
{
return getAttacker() != null;
}
public void chooseTargetAI()
{
setTargetCard(getAttacker());
}
public Card getAttacker()
{
//target creature that is going to attack
Combat c = ComputerUtil.getAttackers();
Card[] att = c.getAttackers();
if(att.length != 0)
return att[0];
else
return null;
}//getAttacker()
public void resolve()
{
final Card[] target = new Card[1];
final Command untilEOT = new Command()
{
private static final long serialVersionUID = -650846106294962607L;
public void execute()
{
if(AllZone.GameAction.isCardInPlay(target[0]))
{
target[0].addTempAttackBoost(-3);
target[0].addTempDefenseBoost(-3);
}
}
};
target[0] = getTargetCard();
if(AllZone.GameAction.isCardInPlay(target[0]) && CardFactoryUtil.canTarget(card, target[0]))
{
target[0].addTempAttackBoost(3);
target[0].addTempDefenseBoost(3);
target[0].untap();
AllZone.EndOfTurn.addUntil(untilEOT);
}
}//resolve()
};
spell.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
*/
/*
//*************** START *********** START **************************
else if(cardName.equals("Brute Force"))
{
SpellAbility spell = new Spell(card)
{
private static final long serialVersionUID = 4733538427752827505L;
public boolean canPlayAI()
{
return getAttacker() != null;
}
public void chooseTargetAI()
{
setTargetCard(getAttacker());
}
public Card getAttacker()
{
//target creature that is going to attack
Combat c = ComputerUtil.getAttackers();
//Card[] att = c.getAttackers();
CardList list = new CardList();
list.addAll(c.getAttackers());
list = list.filter(new CardListFilter()
{
public boolean addCard(Card c) {
return CardFactoryUtil.canTarget(card, c);
}
});
if(list.size() != 0)
return list.get(0);
else
return null;
}//getAttacker()
public void resolve()
{
final Card[] target = new Card[1];
final Command untilEOT = new Command()
{
private static final long serialVersionUID = 8299648917436556370L;
public void execute()
{
if(AllZone.GameAction.isCardInPlay(target[0]))
{
target[0].addTempAttackBoost(-3);
target[0].addTempDefenseBoost(-3);
}
}
};
target[0] = getTargetCard();
if(AllZone.GameAction.isCardInPlay(target[0]) && CardFactoryUtil.canTarget(card, target[0]) )
{
target[0].addTempAttackBoost(3);
target[0].addTempDefenseBoost(3);
AllZone.EndOfTurn.addUntil(untilEOT);
}
}//resolve()
};
spell.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
*/
//*************** START *********** START **************************
else if(cardName.equals("Nameless Inversion")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 5479536291205544905L;
@Override
public boolean canPlayAI() {
CardList list = CardFactoryUtil.AI_getHumanCreature(3, card, true);
CardListUtil.sortFlying(list);
for(int i = 0; i < list.size(); i++)
if(2 <= list.get(i).getNetAttack()) {
setTargetCard(list.get(i));
return true;
}
return false;
}//canPlayAI()
@Override
public void resolve() {
final Card[] target = new Card[1];
final Command untilEOT = new Command() {
private static final long serialVersionUID = -1954104042512587145L;
public void execute() {
if(AllZone.GameAction.isCardInPlay(target[0])) {
target[0].addTempAttackBoost(-3);
target[0].addTempDefenseBoost(3);
}
}
};
target[0] = getTargetCard();
if(AllZone.GameAction.isCardInPlay(target[0]) && CardFactoryUtil.canTarget(card, target[0])) {
target[0].addTempAttackBoost(3);
target[0].addTempDefenseBoost(-3);
AllZone.EndOfTurn.addUntil(untilEOT);
}
}//resolve()
};
spell.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Tromp the Domains")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 1523193367625798058L;
@Override
public boolean canPlayAI() {
return getAttacker() != null;
}
public Card getAttacker() {
//target creature that is going to attack
Combat c = ComputerUtil.getAttackers();
Card[] att = c.getAttackers();
if(att.length != 0) return att[0];
else return null;
}//getAttacker()
int countLandTypes() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList land = new CardList(play.getCards());
String basic[] = {"Forest", "Plains", "Mountain", "Island", "Swamp"};
int count = 0;
for(int i = 0; i < basic.length; i++) {
CardList c = land.getType(basic[i]);
if(!c.isEmpty()) count++;
}
return count;
}//countLandTypes()
@Override
public void resolve() {
final int boost = countLandTypes();
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList list = new CardList(play.getCards());
for(int i = 0; i < list.size(); i++) {
final Card[] target = new Card[1];
target[0] = list.get(i);
final Command untilEOT = new Command() {
private static final long serialVersionUID = -4207130279969069542L;
public void execute() {
if(AllZone.GameAction.isCardInPlay(target[0])) {
target[0].addTempAttackBoost(-boost);
target[0].addTempDefenseBoost(-boost);
target[0].removeExtrinsicKeyword("Trample");
}
}
};//Command
if(AllZone.GameAction.isCardInPlay(target[0])) {
target[0].addTempAttackBoost(boost);
target[0].addTempDefenseBoost(boost);
target[0].addExtrinsicKeyword("Trample");
AllZone.EndOfTurn.addUntil(untilEOT);
}//if
}//for
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Titanic Ultimatum")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 4920407567000133514L;
@Override
public boolean canPlayAI() {
return getAttacker() != null;
}
public Card getAttacker() {
//target creature that is going to attack
Combat c = ComputerUtil.getAttackers();
Card[] att = c.getAttackers();
if(att.length != 0) return att[0];
else return null;
}//getAttacker()
@Override
public void resolve() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList list = new CardList(play.getCards());
for(int i = 0; i < list.size(); i++) {
final Card[] target = new Card[1];
target[0] = list.get(i);
final Command untilEOT = new Command() {
private static final long serialVersionUID = -3807842003906681893L;
public void execute() {
if(AllZone.GameAction.isCardInPlay(target[0])) {
target[0].addTempAttackBoost(-5);
target[0].addTempDefenseBoost(-5);
target[0].removeExtrinsicKeyword("Trample");
target[0].removeExtrinsicKeyword("First Strike");
target[0].removeExtrinsicKeyword("Lifelink");
}
}
};//Command
if(AllZone.GameAction.isCardInPlay(target[0])) {
target[0].addTempAttackBoost(5);
target[0].addTempDefenseBoost(5);
target[0].addExtrinsicKeyword("Trample");
target[0].addExtrinsicKeyword("First Strike");
target[0].addExtrinsicKeyword("Lifelink");
AllZone.EndOfTurn.addUntil(untilEOT);
}//if
}//for
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Primal Boost")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 2449600319884238808L;
@Override
public boolean canPlayAI() {
return getAttacker() != null;
}
@Override
public void chooseTargetAI() {
setTargetCard(getAttacker());
}
public Card getAttacker() {
//target creature that is going to attack
Combat c = ComputerUtil.getAttackers();
CardList list = new CardList(c.getAttackers());
CardListUtil.sortFlying(list);
Card[] att = list.toArray();
if(att.length != 0) return att[0];
else return null;
}//getAttacker()
@Override
public void resolve() {
final Card[] target = new Card[1];
final Command untilEOT = new Command() {
private static final long serialVersionUID = 3753684523153747308L;
public void execute() {
if(AllZone.GameAction.isCardInPlay(target[0])) {
target[0].addTempAttackBoost(-4);
target[0].addTempDefenseBoost(-4);
}
}
};
target[0] = getTargetCard();
if(AllZone.GameAction.isCardInPlay(target[0]) && CardFactoryUtil.canTarget(card, target[0])) {
target[0].addTempAttackBoost(4);
target[0].addTempDefenseBoost(4);
AllZone.EndOfTurn.addUntil(untilEOT);
}
}//resolve()
};
spell.setDescription("\r\nTarget creature gets +4/+4 until end of turn.");
spell.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
//card.addSpellAbility(CardFactoryUtil.ability_cycle(card, "2 G"));
}//*************** END ************ END **************************
/*
//*************** START *********** START **************************
else if(cardName.equals("Wildsize"))
{
SpellAbility spell = new Spell(card)
{
private static final long serialVersionUID = -4558777579924787035L;
public boolean canPlayAI()
{
return getAttacker() != null;
}
public void chooseTargetAI()
{
setTargetCard(getAttacker());
}
public Card getAttacker()
{
//target creature that is going to attack
Combat c = ComputerUtil.getAttackers();
CardList list = new CardList(c.getAttackers());
CardListUtil.sortFlying(list);
Card[] att = list.toArray();
if(att.length != 0)
return att[0];
else
return null;
}//getAttacker()
public void resolve()
{
final Card[] target = new Card[1];
final Command untilEOT = new Command()
{
private static final long serialVersionUID = -8390763209393328399L;
public void execute()
{
if(AllZone.GameAction.isCardInPlay(target[0]))
{
target[0].addTempAttackBoost(-2);
target[0].addTempDefenseBoost(-2);
target[0].removeExtrinsicKeyword("Trample");
}
}
};
target[0] = getTargetCard();
if(AllZone.GameAction.isCardInPlay(target[0]) && CardFactoryUtil.canTarget(card, target[0]))
{
target[0].addTempAttackBoost(2);
target[0].addTempDefenseBoost(2);
target[0].addExtrinsicKeyword("Trample");
AllZone.EndOfTurn.addUntil(untilEOT);
AllZone.GameAction.drawCard(card.getController());
}
}//resolve()
};
spell.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
*/
//*************** START *********** START **************************
else if(cardName.equals("Feral Lightning")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -1841642966580694848L;
@Override
public boolean canPlayAI() {
return AllZone.Phase.getPhase().equals(Constant.Phase.Main1);
}
@Override
public void resolve() {
int multiplier = 1;
int doublingSeasons = CardFactoryUtil.getCards("Doubling Season", card.getController()).size();
if(doublingSeasons > 0) multiplier = (int) Math.pow(2, doublingSeasons);
final Card[] token = new Card[3 * multiplier];
final Command atEOT = new Command() {
private static final long serialVersionUID = -1928884889370422828L;
public void execute() {
//destroy tokens at end of turn
for(int i = 0; i < token.length; i++)
if(AllZone.GameAction.isCardInPlay(token[i])) AllZone.GameAction.destroy(token[i]);
}
};
AllZone.EndOfTurn.addAt(atEOT);
for(int i = 0; i < token.length; i++)
token[i] = makeToken();
}//resolve()
Card makeToken() {
Card c = new Card();
c.setOwner(card.getController());
c.setController(card.getController());
c.setName("Elemental");
c.setImageName("R 3 1 Elemental");
c.setManaCost("R");
c.setToken(true);
c.addType("Creature");
c.addType("Elemental");
c.setBaseAttack(3);
c.setBaseDefense(1);
c.addIntrinsicKeyword("Haste");
c.setSacrificeAtEOT(true);
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
play.add(c);
return c;
}//makeToken()
};//SpellAbility
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Animate Land")) {
final Card[] target = new Card[1];
final Command untilEOT = new Command() {
private static final long serialVersionUID = -3359299797188942353L;
public void execute() {
if(AllZone.GameAction.isCardInPlay(target[0])) {
target[0].removeType("Creature");
}
}
};
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 4890851927124377327L;
@Override
public void resolve() {
target[0] = getTargetCard();
if(AllZone.GameAction.isCardInPlay(target[0]) && CardFactoryUtil.canTarget(card, target[0])) {
target[0].addType("Creature");
target[0].setBaseAttack(3);
target[0].setBaseDefense(3);
AllZone.EndOfTurn.addUntil(untilEOT);
}
}//resolve()
@Override
public boolean canPlayAI() {
return false;
/* all this doesnt work, computer will not attack with the animated land
//does the computer have any land in play?
CardList land = new CardList(AllZone.Computer_Play.getCards());
land = land.getType("Land");
land = land.filter(new CardListFilter()
{
public boolean addCard(Card c)
{
//checks for summoning sickness, and is not tapped
return CombatUtil.canAttack(c);
}
});
return land.size() > 1 && CardFactoryUtil.AI_isMainPhase();
*/
}
};//SpellAbility
// spell.setChooseTargetAI(CardFactoryUtil.AI_targetType("Land", AllZone.Computer_Play));
spell.setBeforePayMana(CardFactoryUtil.input_targetType(spell, "Land"));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
if(cardName.equals("Ior Ruin Expedition")) {
final SpellAbility ability = new Ability(card, "0") {
@Override
public boolean canPlay() {
return card.getCounters(Counters.QUEST) >= 3 && AllZone.GameAction.isCardInPlay(card)
&& !AllZone.Stack.getSourceCards().contains(card);//in play and not already activated(Sac cost problems)
}
@Override
public boolean canPlayAI() {
return (AllZone.Computer_Hand.size() < 6) && (AllZone.Computer_Library.size() > 0);
}
@Override
public void resolve() {
AllZone.GameAction.drawCard(card.getController());
AllZone.GameAction.drawCard(card.getController());
AllZone.GameAction.sacrifice(getSourceCard());
}
};
ability.setDescription("Remove three quest counters from Ior Ruin Expedition and sacrifice it: Draw two cards.");
ability.setStackDescription(card.getName() + " - Draw two cards.");
card.addSpellAbility(ability);
}
//*************** START *********** START **************************
else if(cardName.equals("Earthcraft")) {
final SpellAbility a1 = new Ability(card, "0") {
private static final long serialVersionUID = 6787319311700905218L;
@Override
public boolean canPlayAI() {
return false;
}
@Override
public boolean canPlay() {
String controller = card.getController();
PlayerZone play = AllZone.getZone(Constant.Zone.Play, controller);
CardList creats = new CardList();
creats.addAll(play.getCards());
creats = creats.getType("Creature");
creats = creats.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isUntapped();
}
});
if(creats.size() > 0 && AllZone.GameAction.isCardInPlay(card)) return true;
else return false;
}
@Override
public void resolve() {
if(getTargetCard() == null) return;
String player = card.getController();
if(player.equals(Constant.Player.Human)) humanResolve();
//else
// computerResolve();
}
public void humanResolve() {
String controller = card.getController();
PlayerZone play = AllZone.getZone(Constant.Zone.Play, controller);
CardList creats = new CardList();
creats.addAll(play.getCards());
creats = creats.getType("Creature");
creats = creats.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isUntapped() && !c.equals(card);
}
});
if(creats.size() == 1) {
creats.get(0).tap();
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) getTargetCard().untap();
} else if(creats.size() > 1) {
Object o = AllZone.Display.getChoice("Select creature to tap", creats.toArray());
if(o != null) {
Card c1 = (Card) o;
c1.tap();
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) getTargetCard().untap();
}
}
}//humanResolve
};//a1
//card.clearSpellAbility();
card.addSpellAbility(a1);
a1.setDescription("Tap an untapped creature you control: untap target basic land.");
Input runtime = new Input() {
private static final long serialVersionUID = -2287693175821059029L;
@Override
public void showMessage() {
CardList all = new CardList();
all.addAll(AllZone.Human_Play.getCards());
all.addAll(AllZone.Computer_Play.getCards());
all = all.filter(new CardListFilter() {
public boolean addCard(Card c) {
return (c.isBasicLand()) && CardFactoryUtil.canTarget(card, c) && c.isTapped();
}
});
stopSetNext(CardFactoryUtil.input_targetSpecific(a1, all, "Select target basic land", true,
false));
}
};
a1.setBeforePayMana(runtime);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Mox Diamond")) {
final Input discard = new Input() {
private static final long serialVersionUID = -1319202902385425204L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Discard a land card (or select Mox Diamond to sacrifice it)");
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectCard(Card c, PlayerZone zone) {
if(zone.is(Constant.Zone.Hand) && c.isLand()) {
AllZone.GameAction.discard(c);
stop();
} else if(c.equals(card)) {
AllZone.GameAction.sacrifice(card);
stop();
}
}
};//Input
final SpellAbility ability = new Ability(card, "0") {
@Override
public void resolve() {
if(card.getController().equals(Constant.Player.Human)) {
if(AllZone.Human_Hand.getCards().length == 0) AllZone.GameAction.sacrifice(card);
else AllZone.InputControl.setInput(discard);
} else {
CardList list = new CardList(AllZone.Computer_Hand.getCards());
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
return (c.isLand());
}
});
AllZone.GameAction.discard(list.get(0));
}//else
}//resolve()
};//SpellAbility
Command intoPlay = new Command() {
private static final long serialVersionUID = -7679939432259603542L;
public void execute() {
ability.setStackDescription("If Mox Diamond would come into play, you may discard a land card instead. If you do, put Mox Diamond into play. If you don't, put it into its owner's graveyard.");
AllZone.Stack.add(ability);
}
};
SpellAbility spell = new Spell_Permanent(card) {
private static final long serialVersionUID = -1818766848857998431L;
//could never get the AI to work correctly
//it always played the same card 2 or 3 times
@Override
public boolean canPlayAI() {
return false;
}
@Override
public boolean canPlay() {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
CardList list = new CardList(hand.getCards());
list.remove(card);
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
return (c.isLand());
}
});
return list.size() != 0 && super.canPlay();
}//canPlay()
};
card.addComesIntoPlayCommand(intoPlay);
card.clearSpellKeepManaAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Standstill")) {
card.clearSpellAbility();
card.addSpellAbility(new Spell_Permanent(card) {
private static final long serialVersionUID = 6912683989507840172L;
@Override
public boolean canPlayAI() {
PlayerZone compPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
PlayerZone humPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList compCreats = new CardList(compPlay.getCards());
compCreats = compCreats.getType("Creature");
CardList humCreats = new CardList(humPlay.getCards());
humCreats = humCreats.getType("Creature");
//only play standstill if comp controls more creatures than human
//this needs some additional rules, maybe add all power + toughness and compare
if(compCreats.size() > humCreats.size()) return true;
else return false;
}
});
}//*************** END ************ END **************************
//*************** START *********** START **************************
if(cardName.equals("Legacy Weapon")) {
final Ability ability = new Ability(card, "W U B R G") {
@Override
public void resolve() {
Card c = getTargetCard();
if(AllZone.GameAction.isCardInPlay(c) && CardFactoryUtil.canTarget(card, c)) {
AllZone.GameAction.removeFromGame(c);
}
}
@Override
public void chooseTargetAI() {
PlayerZone hplay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList human = new CardList(hplay.getCards());
human = human.filter(new CardListFilter() {
public boolean addCard(Card c) {
return CardFactoryUtil.canTarget(card, c);
}
});
if(human.size() != 0) {
setTargetCard(CardFactoryUtil.AI_getMostExpensivePermanent(human, card, true));
}
}
@Override
public boolean canPlayAI() {
PlayerZone hplay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList human = new CardList(hplay.getCards());
human = human.filter(new CardListFilter() {
public boolean addCard(Card c) {
return CardFactoryUtil.canTarget(card, c);
}
});
return human.size() > 0;
}
};//ability
Input target = new Input() {
private static final long serialVersionUID = -7279903055386088569L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target permanent for " + ability.getSourceCard());
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card crd, PlayerZone zone) {
if(zone.is(Constant.Zone.Play) && CardFactoryUtil.canTarget(card, crd)) {
ability.setTargetCard(crd);
stopSetNext(new Input_PayManaCost(ability));
}
}
};//Input
ability.setDescription("W U B R G: Exile target permanent.");
ability.setBeforePayMana(target);
card.addSpellAbility(ability);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Voltaic Key")) {
final Ability_Tap ability = new Ability_Tap(card, "1") {
private static final long serialVersionUID = 6097818373831898299L;
@Override
public void resolve() {
Card c = getTargetCard();
if(AllZone.GameAction.isCardInPlay(c) && CardFactoryUtil.canTarget(card, c) && c.isTapped()) c.untap();
}
@Override
public boolean canPlayAI() {
return false;
}
};//ability
Input target = new Input() {
private static final long serialVersionUID = -7279903055386088569L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target tapped artifact for " + ability.getSourceCard());
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card crd, PlayerZone zone) {
if(zone.is(Constant.Zone.Play) && CardFactoryUtil.canTarget(card, crd) && crd.isArtifact()
&& crd.isTapped()) {
ability.setTargetCard(crd);
stopSetNext(new Input_PayManaCost(ability));
}
}
};//Input
ability.setDescription("1, tap: Untap target artifact.");
ability.setBeforePayMana(target);
card.addSpellAbility(ability);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Seething Song")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 113811381138L;
@Override
public void resolve() {
//CardList list = new CardList(AllZone.getZone(Constant.Zone.Play, Constant.Player.Human).getCards());
//list = list.getName("Mana Pool");
Card mp = AllZone.ManaPool;//list.getCard(0);
mp.addExtrinsicKeyword("ManaPool:R");
mp.addExtrinsicKeyword("ManaPool:R");
mp.addExtrinsicKeyword("ManaPool:R");
mp.addExtrinsicKeyword("ManaPool:R");
mp.addExtrinsicKeyword("ManaPool:R");
}
@Override
public boolean canPlayAI() {
return false;
}
};
spell.setStackDescription("Adds R R R R R to your mana pool");
card.clearSpellAbility();
card.addSpellAbility(spell);
return card;
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Dark Ritual")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -8579887529151755266L;
@Override
public void resolve() {
/*CardList list = new CardList(AllZone.getZone(Constant.Zone.Play, Constant.Player.Human).getCards());
list = list.getName("Mana Pool");*/
Card mp = AllZone.ManaPool;//list.getCard(0);
mp.addExtrinsicKeyword("ManaPool:B");
mp.addExtrinsicKeyword("ManaPool:B");
mp.addExtrinsicKeyword("ManaPool:B");
}
@Override
public boolean canPlayAI() {
return false;
}
};
spell.setStackDescription(cardName + " adds B B B to your mana pool");
card.clearSpellAbility();
card.addSpellAbility(spell);
return card;
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Black Lotus")) {
final Ability_Tap ability = new Ability_Tap(card, "0") {
private static final long serialVersionUID = 8394047173115959008L;
@Override
public boolean canPlayAI() {
return false;
}
@Override
public void resolve() {
if(card.getController().equals(Constant.Player.Human)) {
//CardList list = new CardList(AllZone.getZone(Constant.Zone.Play, Constant.Player.Human).getCards());
//list = list.getName("Mana Pool");
Card mp = AllZone.ManaPool;//list.getCard(0);
String color = "";
Object o = AllZone.Display.getChoice("Choose mana color", Constant.Color.Colors);
color = (String) o;
if(color.equals("white")) color = "W";
else if(color.equals("blue")) color = "U";
else if(color.equals("black")) color = "B";
else if(color.equals("red")) color = "R";
else if(color.equals("green")) color = "G";
else color = "1";
//System.out.println("ManaPool:"+color+":");
for(int i = 0; i < 3; i++)
mp.addExtrinsicKeyword("ManaPool:" + color);
//AllZone.GameAction.sacrifice(card);
}
}
};
ability.setDescription("tap, Sacrifice Black Lotus: Add three mana of any one color to your mana pool.");
ability.setStackDescription("Adds 3 mana of any one color to your mana pool");
Input sac = new Input() {
private static final long serialVersionUID = -4503945947115838818L;
@Override
public void showMessage() {
AllZone.GameAction.sacrifice(card);
ability.resolve();
stop();
}
};//Input
ability.setBeforePayMana(sac);
card.addSpellAbility(ability);
}//*************** END ************ END **************************
//**************************Equipment*****************************
//*************** START ************ START **************************
else if(cardName.equals("Ashnod's Transmogrant")) {
final Ability_Tap ability = new Ability_Tap(card) {
private static final long serialVersionUID = -401631574059431293L;
@Override
public void resolve() {
if(card.getController().equals(Constant.Player.Computer)) AllZone.GameAction.sacrifice(card);
if(getTargetCard() == null || !getTargetCard().isCreature()) return;
Card crd = getTargetCard();
crd.addCounter(Counters.P1P1, 1);
if(!crd.getType().contains("Artifact")) crd.addType("Artifact");
}
@Override
public boolean canPlayAI() {
CardList list = new CardList(AllZone.Computer_Play.getCards()).filter(new CardListFilter() {
public boolean addCard(Card c) {
return !c.isArtifact() && c.isCreature();
}
});
Card crd = CardFactoryUtil.AI_getBestCreature(list);
if(crd != null) setTargetCard(crd);
return (getTargetCard() != null);
}
};
Input runtime = new Input() {
private static final long serialVersionUID = 141164423096887945L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target creature for " + card);
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card c, PlayerZone zone) {
if(!CardFactoryUtil.canTarget(ability, c)) {
AllZone.Display.showMessage("Cannot target this card (Shroud? Protection?).");
} else if(c.isCreature() && !c.isArtifact() && zone.is(Constant.Zone.Play)) {
ability.setTargetCard(c);
AllZone.GameAction.sacrifice(card);
stopSetNext(new Input_NoCost_TapAbility(ability));
}
}
};
ability.setBeforePayMana(runtime);
ability.setDescription("T, Sacrifice Ashnod's Transmogrant: put a +1/+1 counter on target nonartifact creature. That creature becomes an artifact in addition to its other types.");
card.addSpellAbility(ability);
}//*************** END ************ END **************************
//*************** START ************ START **************************
else if(cardName.equals("Gemstone Array")) {
final Ability store = new Ability(card, "2") {
@Override
public void resolve() {
card.addCounter(Counters.CHARGE, 1);
}
@Override
public boolean canPlayAI() {
return AllZone.Phase.is(Constant.Phase.Main2, Constant.Player.Computer);
}
};
store.setDescription("2: Put a charge counter on Gemstone Array.");
store.setStackDescription("Put a charge counter on Gemstone Array");
card.addSpellAbility(store);
final Ability_Mana retrieve = new Ability_Mana(card,
"Remove a charge counter from Gemstone Array: Add one mana of any color to your mana pool.") {
private static final long serialVersionUID = -2938965362221626028L;
@Override
public void undo() {
card.addCounter(Counters.CHARGE, 1);
}
@Override
public String Mana() {
return this.choices_made[0].toString();
}
@Override
public boolean canPlay() {
if(choices_made[0] == null) choices_made[0] = "1";
return super.canPlay() && card.getCounters(Counters.CHARGE) > 0;
}
@Override
public void resolve() {
card.subtractCounter(Counters.CHARGE, 1);
super.resolve();
}
};
retrieve.choices_made = new String[1];
retrieve.setBeforePayMana(new Input() {
private static final long serialVersionUID = 376497609786542558L;
@Override
public void showMessage() {
retrieve.choices_made[0] = Input_PayManaCostUtil.getColor2(AllZone.Display.getChoiceOptional(
"Select a Color", Constant.Color.onlyColors));
AllZone.Stack.add(retrieve);
stop();
}
});
card.addSpellAbility(retrieve);
}//*************** END ************ END **************************
//*************** START ************ START **************************
else if(cardName.equals("Goblin Grenade")) {
final SpellAbility DamageCP = new Spell(card) {
private static final long serialVersionUID = -4289150611689144985L;
Card check;
@Override
public boolean canPlay() {
CardList gobs = new CardList(
AllZone.getZone(Constant.Zone.Play, card.getController()).getCards());
gobs = gobs.getType("Goblin");
return super.canPlay() && gobs.size() > 0;
}
@Override
public boolean canPlayAI() {
if(AllZone.Human_Life.getLife() <= 5) return true;
PlayerZone compHand = AllZone.getZone(Constant.Zone.Hand, Constant.Player.Computer);
CardList hand = new CardList(compHand.getCards());
if(hand.size() >= 8) return true;
check = getFlying();
return check != null;
}
@Override
public void chooseTargetAI() {
if(AllZone.Human_Life.getLife() <= 5) {
setTargetPlayer(Constant.Player.Human);
return;
}
PlayerZone compHand = AllZone.getZone(Constant.Zone.Hand, Constant.Player.Computer);
CardList hand = new CardList(compHand.getCards());
if(getFlying() == null && hand.size() >= 7) //not 8, since it becomes 7 when getting cast
{
setTargetPlayer(Constant.Player.Human);
return;
}
Card c = getFlying();
if(check == null && c != null) System.out.println("Check equals null");
else if((c == null) || (!check.equals(c))) throw new RuntimeException(card
+ " error in chooseTargetAI() - Card c is " + c + ", Card check is " + check);
setTargetCard(c);
}//chooseTargetAI()
//uses "damage" variable
Card getFlying() {
CardList flying = CardFactoryUtil.AI_getHumanCreature("Flying", card, true);
for(int i = 0; i < flying.size(); i++)
if(flying.get(i).getNetDefense() <= 5) {
System.out.println("getFlying() returns " + flying.get(i).getName());
return flying.get(i);
}
System.out.println("getFlying() returned null");
return null;
}
@Override
public void resolve() {
if(card.getController().equals(Constant.Player.Computer)) {
CardList gobs = new CardList(
AllZone.getZone(Constant.Zone.Play, card.getController()).getCards());
gobs = gobs.getType("Goblin");
if(gobs.size() > 0) {
CardListUtil.sortAttackLowFirst(gobs);
AllZone.GameAction.sacrifice(gobs.get(0));
}
//TODO, if AI can't sack, break out of this
}
if(getTargetCard() != null) {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
Card c = getTargetCard();
//c.addDamage(damage);
AllZone.GameAction.addDamage(c, card, 5);
}
} else AllZone.GameAction.getPlayerLife(getTargetPlayer()).subtractLife(5);
//resolve()
}
}; //spellAbility
DamageCP.setDescription(card.getName() + " deals 5 damage to target creature or player.");
//DamageCP.setStackDescription(card.getName() +" deals 5 damage.");
Input target = new Input() {
private static final long serialVersionUID = 1843037500197925110L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target Creature, Player, or Planeswalker");
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card crd, PlayerZone zone) {
if((crd.isCreature() || crd.isPlaneswalker()) && zone.is(Constant.Zone.Play)
&& CardFactoryUtil.canTarget(DamageCP, crd)) {
DamageCP.setTargetCard(crd);
done();
}
}//selectCard()
@Override
public void selectPlayer(String player) {
DamageCP.setTargetPlayer(player);
done();
}
void done() {
AllZone.Stack.add(DamageCP);
stop();
}
};
Input targetSac = new Input() {
private static final long serialVersionUID = -6102143961778874295L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select a Goblin to sacrifice.");
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card crd, PlayerZone zone) {
CardList choices = new CardList(
AllZone.getZone(Constant.Zone.Play, card.getController()).getCards());
choices = choices.getType("Goblin");
if(choices.contains(crd)) {
AllZone.GameAction.sacrifice(crd);
//DamageCP.setTargetCard(crd);
if(DamageCP instanceof Ability_Tap && DamageCP.getManaCost().equals("0")) stopSetNext(new Input_NoCost_TapAbility(
(Ability_Tap) DamageCP));
else if(DamageCP.getManaCost().equals("0")) {
//AllZone.Stack.add(DamageCP);
stop();
} else stopSetNext(new Input_PayManaCost(DamageCP));
}
}//selectCard()
};
DamageCP.setBeforePayMana(targetSac);
DamageCP.setAfterPayMana(target);
card.clearSpellAbility();
card.addSpellAbility(DamageCP);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Onyx Goblet")) {
final Ability_Tap ability = new Ability_Tap(card) {
private static final long serialVersionUID = -5726693225692494554L;
@Override
public boolean canPlayAI() {
return AllZone.Phase.getPhase().equals(Constant.Phase.Main2);
}
@Override
public void resolve() {
String opponent = AllZone.GameAction.getOpponent(card.getController());
AllZone.GameAction.getPlayerLife(opponent).subtractLife(1);
}
};//SpellAbility
card.addSpellAbility(ability);
ability.setDescription("tap: Target player loses 1 life.");
ability.setStackDescription(card.getName() + " - Opponent loses 1 life.");
ability.setBeforePayMana(new Input_NoCost_TapAbility(ability));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Braidwood Cup")) {
final Ability_Tap ability = new Ability_Tap(card) {
private static final long serialVersionUID = -7784976576326683976L;
@Override
public boolean canPlayAI() {
return AllZone.Phase.getPhase().equals(Constant.Phase.Main2);
}
@Override
public void resolve() {
AllZone.GameAction.getPlayerLife(card.getController()).addLife(1);
}
};//SpellAbility
card.addSpellAbility(ability);
ability.setDescription("tap: You gain 1 life.");
ability.setStackDescription("Braidwood Cup - " + card.getController() + " gains 1 life.");
ability.setBeforePayMana(new Input_NoCost_TapAbility(ability));
}//*************** END ************ END **************************
/*
//*************** START *********** START **************************
else if(cardName.equals("Scepter of Insight"))
{
final SpellAbility ability = new Ability_Tap(card, "3 U")
{
private static final long serialVersionUID = -3567474686431369541L;
public boolean canPlayAI() {return AllZone.Phase.getPhase().equals(Constant.Phase.Main2);}
public void resolve()
{
AllZone.GameAction.drawCard(card.getController());
}
};//SpellAbility
card.addSpellAbility(ability);
ability.setDescription("3 U, tap: Draw a card.");
ability.setStackDescription(card.getName() + " - draw a card.");
}//*************** END ************ END **************************
*/
//*************** START *********** START **************************
else if(cardName.equals("Innocent Blood")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 3915880400376059369L;
@Override
public void resolve() {
AllZone.GameAction.sacrificeCreature(Constant.Player.Human, this);
AllZone.GameAction.sacrificeCreature(Constant.Player.Computer, this);
}
@Override
public boolean canPlayAI() {
PlayerZone cPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
PlayerZone hPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList hList = new CardList(hPlay.getCards());
CardList cList = new CardList(cPlay.getCards());
CardList smallCreats = cList.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isCreature() && c.getNetAttack() < 2 && c.getNetDefense() < 3;
}
});
hList = hList.getType("Creature");
cList = cList.getType("Creature");
if(hList.size() == 0) return false;
return smallCreats.size() > 0;
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Diabolic Edict") || cardName.equals("Chainer's Edict")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 8970446094797667088L;
@Override
public void resolve() {
AllZone.GameAction.sacrificeCreature(getTargetPlayer(), this);
}
@Override
public boolean canPlayAI() {
PlayerZone hPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList hList = new CardList(hPlay.getCards());
hList = hList.getType("Creature");
return hList.size() > 0;
}
};
spell.setChooseTargetAI(CardFactoryUtil.AI_targetHuman());
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
if(cardName.equals("Chainer's Edict")) {
final SpellAbility flashback = new Spell(card) {
private static final long serialVersionUID = -4889392369463499074L;
@Override
public boolean canPlay() {
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, card.getController());
String phase = AllZone.Phase.getPhase();
String activePlayer = AllZone.Phase.getActivePlayer();
return AllZone.GameAction.isCardInZone(card, grave)
&& ((phase.equals(Constant.Phase.Main1) || phase.equals(Constant.Phase.Main2))
&& card.getController().equals(activePlayer) && AllZone.Stack.size() == 0);
}
@Override
public boolean canPlayAI() {
PlayerZone hPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList hList = new CardList(hPlay.getCards());
hList = hList.getType("Creature");
return hList.size() > 0;
}
@Override
public void resolve() {
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, card.getController());
PlayerZone removed = AllZone.getZone(Constant.Zone.Removed_From_Play, card.getController());
AllZone.GameAction.sacrificeCreature(getTargetPlayer(), this);
grave.remove(card);
removed.add(card);
}
};
flashback.setManaCost("5 B B");
flashback.setBeforePayMana(CardFactoryUtil.input_targetPlayer(flashback));
flashback.setDescription("Flashback: 5 B B");
flashback.setChooseTargetAI(CardFactoryUtil.AI_targetHuman());
card.addSpellAbility(flashback);
card.setFlashback(true);
}//if Chainer's Edict
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Cruel Edict") || cardName.equals("Imperial Edict")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 4782606423085170723L;
@Override
public void resolve() {
AllZone.GameAction.sacrificeCreature(AllZone.GameAction.getOpponent(card.getController()),
this);
}
@Override
public boolean canPlayAI() {
PlayerZone hPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList hList = new CardList(hPlay.getCards());
hList = hList.getType("Creature");
return hList.size() > 0;
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Door to Nothingness")) {
Ability_Tap ab1 = new Ability_Tap(card, "G G R R B B U U W W") {
private static final long serialVersionUID = 6665327569823149191L;
@Override
public void resolve() {
AllZone.GameAction.getPlayerLife(getTargetPlayer()).setLife(0);
}
@Override
public boolean canPlayAI() {
return true;
}
};
ab1.setChooseTargetAI(CardFactoryUtil.AI_targetHuman());
ab1.setBeforePayMana(CardFactoryUtil.input_targetPlayer(ab1));
ab1.setDescription("WWUUBBRRGG, tap, sacrifice Door to Nothingness: Target player loses the game.");
card.addSpellAbility(ab1);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Seal of Cleansing") || cardName.equals("Seal of Primordium")) {
final Ability ability = new Ability(card, "0") {
@Override
public boolean canPlayAI() {
return getArtEnchantments().size() != 0;
}
@Override
public void chooseTargetAI() {
CardList list = getArtEnchantments();
if(list.size() > 0) {
CardListUtil.sortCMC(list);
list.reverse();
setTargetCard(list.get(0));
AllZone.GameAction.sacrifice(card);
}
}//chooseTargetAI()
CardList getArtEnchantments() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList list = new CardList(play.getCards());
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isArtifact() || c.isEnchantment();
}
});
return list;
}//getArtEnchantments()
@Override
public void resolve() {
if(getTargetCard() != null) {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) AllZone.GameAction.destroy(getTargetCard());
}
}//resolve()
};//SpellAbility
Input runtime = new Input() {
private static final long serialVersionUID = -1750678113925588670L;
@Override
public void showMessage() {
card.addSpellAbility(ability);
ability.setDescription("Sacrifice " + cardName + ": destroy target artifact or enchantment.");
PlayerZone hplay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
PlayerZone cplay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
CardList choices = new CardList();
choices.addAll(hplay.getCards());
choices.addAll(cplay.getCards());
choices = choices.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isEnchantment() || c.isArtifact();
}
});
stopSetNext(CardFactoryUtil.input_targetSpecific(ability, choices,
"Destroy target artifact or enchantment", new Command() {
private static final long serialVersionUID = -4987328870651000691L;
public void execute() {
AllZone.GameAction.sacrifice(card);
}
}, true, false));
}
};
ability.setDescription("Sacrifice " + card.getName() + ": destroy target artifact or enchantment.");
ability.setBeforePayMana(runtime);
card.addSpellAbility(ability);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Seal of Fire")) {
final Ability ability = new Ability(card, "0") {
@Override
public boolean canPlayAI() {
return getCreature().size() != 0 || AllZone.Human_Life.getLife() < 4;
}
@Override
public void chooseTargetAI() {
if(AllZone.Human_Life.getLife() < 4) setTargetPlayer(Constant.Player.Human);
else {
CardList list = getCreature();
list.shuffle();
setTargetCard(list.get(0));
}
AllZone.GameAction.sacrifice(card);
}//chooseTargetAI()
CardList getCreature() {
//toughness of 1
CardList list = CardFactoryUtil.AI_getHumanCreature(2, card, true);
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
//only get 1/1 flyers or 2/1 or bigger creatures
return (2 <= c.getNetAttack()) || c.getKeyword().contains("Flying");
}
});
return list;
}//getCreature()
@Override
public void resolve() {
if(getTargetCard() != null) {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) getTargetCard().addDamage(2,
card);
} else AllZone.GameAction.getPlayerLife(getTargetPlayer()).subtractLife(2);
}//resolve()
};//SpellAbility
card.addSpellAbility(ability);
ability.setDescription("Sacrifice Seal of Fire: Seal of Fire deals 2 damage to target creature or player.");
ability.setBeforePayMana(CardFactoryUtil.input_targetCreaturePlayer(ability, new Command() {
private static final long serialVersionUID = 4180346673509230280L;
public void execute() {
AllZone.GameAction.sacrifice(card);
}
}, true, false));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Seal of Removal")) {
final Ability ability = new Ability(card, "0") {
@Override
public boolean canPlayAI() {
return getCreature().size() != 0;
}
@Override
public void chooseTargetAI() {
CardList list = getCreature();
list.shuffle();
setTargetCard(list.get(0));
AllZone.GameAction.sacrifice(card);
}//chooseTargetAI()
CardList getCreature() {
CardList list = new CardList(AllZone.Human_Play.getCards());
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isCreature()
&& (c.getNetAttack() >= 3 || c.getKeyword().contains("Flying") || c.isEnchanted())
&& CardFactoryUtil.canTarget(card, c);
}
});
return list;
}//getCreature()
@Override
public void resolve() {
if(getTargetCard() != null) {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, getTargetCard().getOwner());
AllZone.GameAction.moveTo(hand, getTargetCard());
}
}
}//resolve()
};//SpellAbility
card.addSpellAbility(ability);
ability.setDescription("Sacrifice Seal of Removal: return target creature to its owner's hand.");
ability.setBeforePayMana(CardFactoryUtil.input_targetCreature(ability, new Command() {
private static final long serialVersionUID = 2565599788533507611L;
public void execute() {
AllZone.GameAction.sacrifice(card);
}
}));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Conqueror's Pledge")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -2902179434079334177L;
@Override
public void resolve() {
for(int i = 0; i < 6; i++) {
CardFactoryUtil.makeToken("Kor Soldier", "W 1 1 Kor Soldier", card, "W", new String[] {
"Creature", "Kor", "Soldier"}, 1, 1, new String[] {""});
}//for
}//resolve()
};
spell.setDescription("Put six 1/1 white Kor Soldier creature tokens onto the battlefield.");
spell.setStackDescription(card.getName() + " - " + card.getController()
+ " puts six 1/1 white Kor Soldier creature tokens onto the battlefield.");
SpellAbility kicker = new Spell(card) {
private static final long serialVersionUID = 1376255732058673590L;
@Override
public void resolve() {
card.setKicked(true);
for(int i = 0; i < 12; i++) {
CardFactoryUtil.makeToken("Kor Soldier", "W 1 1 Kor Soldier", card, "W", new String[] {
"Creature", "Kor", "Soldier"}, 1, 1, new String[] {""});
}//for
}//resolve()
};
kicker.setManaCost("8 W W W");
kicker.setAdditionalManaCost("6");
kicker.setDescription("Kicker 6: If Conqueror's Pledge was kicked, put twelve of those tokens onto the battlefield instead.");
kicker.setStackDescription(card.getName() + " - " + card.getController()
+ " puts twelve 1/1 white Kor Soldier creature tokens onto the battlefield.");
card.clearSpellAbility();
card.addSpellAbility(spell);
card.addSpellAbility(kicker);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Kaervek's Spite")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -6259614160639535500L;
@Override
public boolean canPlayAI() {
if(AllZone.Human_Life.getLife() <= 5) return true;
PlayerZone play = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, Constant.Player.Computer);
CardList playList = new CardList(play.getCards());
CardList libList = new CardList(lib.getCards());
playList = playList.getName("Academy Rector");
libList = libList.getName("Barren Glory");
return (AllZone.Human_Life.getLife() <= 5) || (playList.size() == 1 && libList.size() >= 1);
}
@Override
public void resolve() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
PlayerZone hand = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList list = new CardList(play.getCards());
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
return !c.getName().equals("Mana Pool");
}
});
CardList handList = new CardList(hand.getCards());
for(Card c:list) {
AllZone.GameAction.sacrifice(c);
}
AllZone.GameAction.discardRandom(card.getController(), handList.size());
PlayerLife life = AllZone.GameAction.getPlayerLife(getTargetPlayer());
life.subtractLife(5);
}
};
spell.setChooseTargetAI(CardFactoryUtil.AI_targetHuman());
card.clearSpellAbility();
card.addSpellAbility(spell);
/*
final Command sac = new Command(){
private static final long serialVersionUID = 1643946454479782123L;
public void execute() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
PlayerZone hand = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList list = new CardList(play.getCards());
list = list.filter(new CardListFilter()
{
public boolean addCard(Card c) {
return !c.getName().equals("Mana Pool");
}
});
CardList handList = new CardList(hand.getCards());
for (Card c : list)
{
AllZone.GameAction.sacrifice(c);
}
AllZone.GameAction.discardRandom(card.getController(), handList.size());
}
};
*/
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Staff of Domination")) {
final Ability_Tap ability2 = new Ability_Tap(card, "2") {
private static final long serialVersionUID = -5513078874305811825L;
@Override
public boolean canPlayAI() {
return AllZone.Phase.getPhase().equals(Constant.Phase.Main2);
}
@Override
public void resolve() {
AllZone.GameAction.getPlayerLife(card.getController()).addLife(1);
}
};//SpellAbility
ability2.setDescription("2, tap: You gain 1 life");
ability2.setStackDescription(cardName + " - You gain 1 life.");
final SpellAbility ability3 = new Ability_Tap(card, "3") {
private static final long serialVersionUID = 1125696151526415705L;
@Override
public boolean canPlayAI() {
return getTapped().size() != 0;
}
@Override
public void chooseTargetAI() {
card.tap();
Card target = CardFactoryUtil.AI_getBestCreature(getTapped());
setTargetCard(target);
}
CardList getTapped() {
CardList list = new CardList(AllZone.Computer_Play.getCards());
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isCreature() && c.isTapped();
}
});
return list;
}//getTapped()
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
Card c = getTargetCard();
if(c.isTapped()) c.untap();
}
}//resolve()
};//SpellAbility
ability3.setDescription("3, tap: Untap target creature.");
ability3.setBeforePayMana(CardFactoryUtil.input_targetCreature(ability3));
final SpellAbility ability4 = new Ability_Tap(card, "4") {
private static final long serialVersionUID = 8102011024731535257L;
@Override
public boolean canPlayAI() {
return false;
}
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
Card c = getTargetCard();
if(c.isUntapped()) c.tap();
}
}//resolve()
};//SpellAbility
ability4.setDescription("4, tap: Tap target creature.");
ability4.setBeforePayMana(CardFactoryUtil.input_targetCreature(ability4));
final Ability_Tap ability5 = new Ability_Tap(card, "5") {
private static final long serialVersionUID = -8459438547823091716L;
@Override
public boolean canPlayAI() {
return true;
}
@Override
public void resolve() {
AllZone.GameAction.drawCard(card.getController());
}
};//SpellAbility
ability5.setDescription("5, tap: Draw a card.");
ability5.setStackDescription(card.getName() + " - draw a card.");
card.addSpellAbility(ability2);
card.addSpellAbility(ability3);
card.addSpellAbility(ability4);
card.addSpellAbility(ability5);
}//*************** END ************ END **************************
//*************** START *********** START **************************
if(cardName.equals("Goblin Charbelcher")) {
final Ability_Tap ability = new Ability_Tap(card, "3") {
private static final long serialVersionUID = -840041589720758423L;
@Override
public void resolve() {
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, card.getController());
CardList topOfLibrary = new CardList(lib.getCards());
CardList revealed = new CardList();
if(topOfLibrary.size() == 0) return;
int damage = 0;
int count = 0;
Card c = null;
Card crd;
while(c == null) {
revealed.add(topOfLibrary.get(count));
crd = topOfLibrary.get(count++);
if(crd.isLand() || count == topOfLibrary.size()) {
c = crd;
damage = count;
if(crd.getName().equals("Mountain")) damage = damage * 2;
}
}//while
AllZone.Display.getChoiceOptional("Revealed cards:", revealed.toArray());
if(getTargetCard() != null) {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
getTargetCard().addDamage(damage, card);
}
} else AllZone.GameAction.getPlayerLife(getTargetPlayer()).subtractLife(damage);
}
};
ability.setDescription("3, tap: Reveal cards from the top of your library until you reveal a land card. Goblin Charbelcher deals damage equal to the number of nonland cards revealed this way to target creature or player. If the revealed land card was a Mountain, Goblin Charbelcher deals double that damage instead. Put the revealed cards on the bottom of your library in any order.");
ability.setChooseTargetAI(CardFactoryUtil.AI_targetHuman());
ability.setBeforePayMana(CardFactoryUtil.input_targetCreaturePlayer(ability, true, false));
card.addSpellAbility(ability);
}//*************** END ************ END **************************
//*************** START *********** START **************************
if(cardName.equals("Tinker")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -5878957726445248334L;
@Override
public boolean canPlay() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList list = new CardList(play.getCards());
list = list.getType("Artifact");
return list.size() > 0;
}
@Override
public boolean canPlayAI() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, Constant.Player.Computer);
CardList playList = new CardList(play.getCards());
playList = playList.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isArtifact() && CardUtil.getConvertedManaCost(c.getManaCost()) <= 2;
}
});
CardList libList = new CardList(lib.getCards());
libList = libList.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isArtifact() && CardUtil.getConvertedManaCost(c.getManaCost()) > 5;
}
});
if(libList.size() > 0 && playList.size() > 0) {
playList.shuffle();
setTargetCard(playList.get(0));
return true;
}
return false;
}
@Override
public void resolve() {
Card c = getTargetCard();
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, card.getController());
if(AllZone.GameAction.isCardInPlay(c)) {
AllZone.GameAction.sacrifice(c);
if(card.getController().equals(Constant.Player.Computer)) {
CardList list = new CardList(lib.getCards());
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isArtifact() && CardUtil.getConvertedManaCost(c.getManaCost()) > 5;
}
});
if(list.size() > 0) {
Card crd = CardFactoryUtil.AI_getBestArtifact(list);
lib.remove(crd);
play.add(crd);
AllZone.GameAction.shuffle(Constant.Player.Computer);
}
} else //human
{
CardList list = new CardList(lib.getCards());
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isArtifact();
}
});
if(list.size() > 0) {
Object o = AllZone.Display.getChoiceOptional("Select artifact", list.toArray());
if(o != null) {
Card crd = (Card) o;
lib.remove(crd);
play.add(crd);
}
AllZone.GameAction.shuffle(Constant.Player.Human);
}
}
}//if isCardInPlay
}
};
/*
final Command sac = new Command()
{
private static final long serialVersionUID = -8925816099640324876L;
public void execute() {
AllZone.GameAction.sacrifice(spell.getTargetCard());
}
};
*/
Input runtime = new Input() {
private static final long serialVersionUID = -4653972223582155502L;
@Override
public void showMessage() {
CardList choice = new CardList();
choice.addAll(AllZone.Human_Play.getCards());
choice = choice.getType("Artifact");
boolean free = false;
if(this.isFree()) free = true;
stopSetNext(CardFactoryUtil.input_targetSpecific(spell, choice,
"Select artifact to sacrifice.", false, free));
}
};
spell.setBeforePayMana(runtime);
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Thopter Foundry")) {
final String player = card.getController();
final SpellAbility ability = new Ability(card, "1") {
@Override
public void chooseTargetAI() {
Card c;
PlayerZone play = AllZone.getZone(Constant.Zone.Play, player);
CardList meek = new CardList();
meek.addAll(play.getCards());
meek = meek.getName("Sword of the Meek");
if(meek.size() >= 1) c = meek.get(0);
else c = getArtifact();
if(c != null) setTargetCard(c);
}
public Card getArtifact() {
//target creature that is going to attack
PlayerZone play = AllZone.getZone(Constant.Zone.Play, player);
CardList arts = new CardList();
arts.addAll(play.getCards());
arts = arts.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isArtifact()
&& !c.isToken()
&& (CardUtil.getConvertedManaCost(c.getManaCost()) <= 1 && !c.equals(card) || c.getName().equals(
"Sword of the Meek"));
}
});
if(arts.size() > 0) {
arts.shuffle();
return arts.get(0);
} else return null;
}
@Override
public boolean canPlayAI() {
String phase = AllZone.Phase.getPhase();
return phase.equals(Constant.Phase.Main2) && getArtifact() != null;
}
@Override
public void resolve() {
Card c = getTargetCard();
if(AllZone.GameAction.isCardInPlay(c)) {
AllZone.GameAction.sacrifice(c);
makeToken();
PlayerLife life = AllZone.GameAction.getPlayerLife(card.getController());
life.addLife(1);
}
}//resolve
public void makeToken() {
CardFactoryUtil.makeToken("Thopter", "U 1 1 Thopter", card, "U", new String[] {
"Artifact", "Creature", "Thopter"}, 1, 1, new String[] {"Flying"});
}
};
Input runtime = new Input() {
private static final long serialVersionUID = 3557158378851031238L;
@Override
public void showMessage() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, player);
CardList arts = new CardList();
arts.addAll(play.getCards());
arts = arts.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isArtifact() && !c.isToken();
}
});
stopSetNext(CardFactoryUtil.input_targetSpecific(ability, arts,
"Select a non-token Artifact to sacrifice", false, false));
}//showMessage()
};//Input
card.addSpellAbility(ability);
ability.setDescription("1, Sacrifice a nontoken artifact: Put a 1/1 blue Thopter artifact creature token with flying onto the battlefield. You gain 1 life.");
ability.setStackDescription(card.getName()
+ " - Put a 1/1 blue Thopter artifact creature token with flying onto the battlefield. You gain 1 life.");
ability.setBeforePayMana(runtime);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Spell Snare")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -3254886985412814994L;
@Override
public void resolve() {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& CardFactoryUtil.isCounterable(sa.getSourceCard())
&& CardUtil.getConvertedManaCost(sa.getSourceCard().getManaCost()) == 2;
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Time Walk") || cardName.equals("Temporal Manipulation")
|| cardName.equals("Capture of Jingzhou")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 35300742940184315L;
@Override
public void resolve() {
System.out.println("Turn: " + AllZone.Phase.getTurn());
AllZone.Phase.addExtraTurn(card.getController());
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Time Stretch") || cardName.equals("Time Warp")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -76579316599195788L;
@Override
public void resolve() {
AllZone.Phase.addExtraTurn(getTargetPlayer());
if(cardName.equals("Time Stretch")) ;
AllZone.Phase.addExtraTurn(getTargetPlayer());
}
};
card.clearSpellAbility();
spell.setChooseTargetAI(CardFactoryUtil.AI_targetComputer());
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Time Vault")) {
final Ability_Tap ability = new Ability_Tap(card) {
private static final long serialVersionUID = 5784473766585071504L;
@Override
public void resolve() {
//System.out.println("Turn: " + AllZone.Phase.getTurn());
AllZone.Phase.addExtraTurn(card.getController());
}
};
card.addSpellAbility(ability);
ability.setStackDescription(card + " - take an extra turn after this one.");
ability.setDescription("Tap: Take an extra turn after this one.");
}//*************** END ************ END **************************
//*************** START *********** START **************************
if(cardName.equals("Celestial Purge")) {
final Spell spell = new Spell(card) {
private static final long serialVersionUID = 2626237206744317044L;
@Override
public void resolve() {
Card c = getTargetCard();
if(AllZone.GameAction.isCardInPlay(c) && CardFactoryUtil.canTarget(card, c)) {
AllZone.GameAction.removeFromGame(c);
}
}
@Override
public void chooseTargetAI() {
PlayerZone hplay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList human = new CardList(hplay.getCards());
human = human.filter(new CardListFilter() {
public boolean addCard(Card c) {
return CardFactoryUtil.canTarget(card, c)
&& (CardUtil.getColors(c).contains(Constant.Color.Black) || CardUtil.getColors(
c).contains(Constant.Color.Red));
}
});
if(human.size() != 0) {
setTargetCard(CardFactoryUtil.AI_getMostExpensivePermanent(human, card, true));
}
}
@Override
public boolean canPlayAI() {
PlayerZone hplay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList human = new CardList(hplay.getCards());
human = human.filter(new CardListFilter() {
public boolean addCard(Card c) {
return CardFactoryUtil.canTarget(card, c)
&& (CardUtil.getColors(c).contains(Constant.Color.Black) || CardUtil.getColors(
c).contains(Constant.Color.Red));
}
});
return human.size() > 0;
}
};//ability
Input target = new Input() {
private static final long serialVersionUID = -7279903055386088569L;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select target black or red permanent for " + card);
ButtonUtil.enableOnlyCancel();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card crd, PlayerZone zone) {
if(zone.is(Constant.Zone.Play)
&& CardFactoryUtil.canTarget(card, crd)
&& (CardUtil.getColors(crd).contains(Constant.Color.Black) || CardUtil.getColors(crd).contains(
Constant.Color.Red))) {
spell.setTargetCard(crd);
stopSetNext(new Input_PayManaCost(spell));
}
}
};//Input
spell.setBeforePayMana(target);
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Millstone")) {
Ability_Tap ab1 = new Ability_Tap(card, "2") {
private static final long serialVersionUID = 42470566751344693L;
@Override
public boolean canPlayAI() {
String player = getTargetPlayer();
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, player);
CardList libList = new CardList(lib.getCards());
return libList.size() > 0;
}
@Override
public void resolve() {
String player = getTargetPlayer();
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, player);
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, player);
CardList libList = new CardList(lib.getCards());
int max = 2;
if(libList.size() < 2) max = libList.size();
for(int i = 0; i < max; i++) {
Card c = libList.get(i);
lib.remove(c);
grave.add(c);
}
}
};
ab1.setChooseTargetAI(CardFactoryUtil.AI_targetHuman());
ab1.setBeforePayMana(CardFactoryUtil.input_targetPlayer(ab1));
ab1.setDescription("2, tap: Target player puts the top two cards of his or her library into his or her graveyard.");
card.addSpellAbility(ab1);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Path to Exile")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 4752934806606319269L;
@Override
public void resolve() {
if(AllZone.GameAction.isCardInPlay(getTargetCard())
&& CardFactoryUtil.canTarget(card, getTargetCard())) {
//add life
String player = getTargetCard().getController();
// PlayerLife life = AllZone.GameAction.getPlayerLife(player);
// life.addLife(getTargetCard().getNetAttack());
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, player);
CardList lands = new CardList(lib.getCards());
lands = lands.getType("Basic");
if(player.equals("Human") && lands.size() > 0) {
String[] choices = {"Yes", "No"};
Object choice = AllZone.Display.getChoice("Search for Basic Land?", choices);
if(choice.equals("Yes")) {
Object o = AllZone.Display.getChoiceOptional(
"Pick a basic land card to put into play", lands.toArray());
if(o != null) {
Card card = (Card) o;
lib.remove(card);
AllZone.Human_Play.add(card);
card.tap();
lands.remove(card);
AllZone.GameAction.shuffle(player);
}
}// if choice yes
} // player equals human
else if(player.equals("Computer") && lands.size() > 0) {
Card card = lands.get(0);
lib.remove(card);
// hand.add(card);
AllZone.Computer_Play.add(card);
card.tap();
lands.remove(card);
AllZone.GameAction.shuffle(player);
}
//remove card from play
AllZone.GameAction.removeFromGame(getTargetCard());
}
}//resolve()
@Override
public boolean canPlayAI() {
CardList creature = new CardList(AllZone.Human_Play.getCards());
creature = creature.getType("Creature");
creature = creature.filter(new CardListFilter() {
public boolean addCard(Card c) {
return CardFactoryUtil.canTarget(card, c);
}
});
return creature.size() != 0 && (AllZone.Phase.getTurn() > 4);
}
@Override
public void chooseTargetAI() {
CardList play = new CardList(AllZone.Human_Play.getCards());
Card target = CardFactoryUtil.AI_getBestCreature(play, card);
setTargetCard(target);
}
};
spell.setBeforePayMana(CardFactoryUtil.input_targetCreature(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
if(cardName.equals("Glimpse the Unthinkable") || cardName.equals("Tome Scour")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 42470566751344693L;
@Override
public boolean canPlayAI() {
String player = getTargetPlayer();
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, player);
CardList libList = new CardList(lib.getCards());
return libList.size() > 0;
}
@Override
public void resolve() {
String player = getTargetPlayer();
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, player);
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, player);
CardList libList = new CardList(lib.getCards());
int max = 0;
if(cardName.equals("Glimpse the Unthinkable")) max = 10;
else max = 5;
if(libList.size() < max) max = libList.size();
for(int i = 0; i < max; i++) {
Card c = libList.get(i);
lib.remove(c);
grave.add(c);
}
}
};//SpellAbility
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
if(cardName.equals("Traumatize")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 42470566751344693L;
@Override
public boolean canPlayAI() {
String player = getTargetPlayer();
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, player);
CardList libList = new CardList(lib.getCards());
return libList.size() > 0;
}
@Override
public void resolve() {
String player = getTargetPlayer();
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, player);
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, player);
CardList libList = new CardList(lib.getCards());
int max = libList.size() / 2;
for(int i = 0; i < max; i++) {
Card c = libList.get(i);
lib.remove(c);
grave.add(c);
}
}
};//SpellAbility
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
if(cardName.equals("Mind Funeral")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 42470566751344693L;
@Override
public boolean canPlayAI() {
String player = getTargetPlayer();
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, player);
CardList libList = new CardList(lib.getCards());
return libList.size() > 0;
}
@Override
public void resolve() {
String player = getTargetPlayer();
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, player);
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, player);
CardList libList = new CardList(lib.getCards());
int max = libList.size();
int prev = 0;
int count = 0;
int total = 0;
for(int i = 0; i < max; i++) {
Card c = libList.get(i);
if(c.getType().contains("Land")) {
count = count + 1;
if(count == 4 && prev == 0) total = i;
if(count == 4) prev = 1;
}
}
for(int i = 0; i < total + 1; i++) {
Card c = libList.get(i);
lib.remove(c);
grave.add(c);
}
}
};//SpellAbility
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
if(cardName.equals("Haunting Echoes")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 42470566751344693L;
@Override
public boolean canPlayAI() {
String player = getTargetPlayer();
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, player);
CardList libList = new CardList(lib.getCards());
return libList.size() > 0;
}
@Override
public void resolve() {
String player = getTargetPlayer();
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, player);
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, player);
PlayerZone exiled = AllZone.getZone(Constant.Zone.Removed_From_Play, player);
CardList libList = new CardList(lib.getCards());
CardList grvList = new CardList(grave.getCards());
int max = libList.size();
int grv = grvList.size();
for(int j = 0; j < grv; j++) {
Card g = grvList.get(j);
for(int i = 0; i < max; i++) {
Card c = libList.get(i);
if(c.getName().equals(g.getName()) && !g.getType().contains("Basic")) {
lib.remove(c);
exiled.add(c);
}
}
if(!g.getType().contains("Basic")) {
grave.remove(g);
exiled.add(g);
}
}
}
};//SpellAbility
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Lobotomy")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 5338238621454661783L;
@Override
public void resolve() {
Card choice = null;
//check for no cards in hand on resolve
String player = getTargetPlayer();
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, player);
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, player);
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, player);
PlayerZone exiled = AllZone.getZone(Constant.Zone.Removed_From_Play, player);
CardList libList = new CardList(lib.getCards());
CardList grvList = new CardList(grave.getCards());
CardList fullHand = new CardList(hand.getCards());
Card[] handChoices = removeLand(hand.getCards());
if(fullHand.size() > 0 && card.getController().equals(Constant.Player.Human)) AllZone.Display.getChoice(
"Revealing hand", fullHand.toArray());
if(card.getController().equals(Constant.Player.Human)) {
choice = AllZone.Display.getChoice("Choose", handChoices);
} else//computer chooses
{
choice = CardUtil.getRandom(handChoices);
}
String chosen = choice.getName();
int max = libList.size();
for(int i = 0; i < max; i++) {
Card c = libList.get(i);
if(c.getName().equals(chosen)) {
lib.remove(c);
exiled.add(c);
}
}
int grv = grvList.size();
for(int i = 0; i < grv; i++) {
Card c = grvList.get(i);
if(c.getName().equals(chosen)) {
grave.remove(c);
exiled.add(c);
}
}
int hnd = fullHand.size();
for(int i = 0; i < hnd; i++) {
Card c = fullHand.get(i);
if(c.getName().equals(chosen)) {
hand.remove(c);
exiled.add(c);
}
}
}//resolve()
@Override
public boolean canPlayAI() {
Card[] c = removeLand(AllZone.Human_Hand.getCards());
return 0 < c.length;
}
Card[] removeLand(Card[] in) {
CardList c = new CardList(in);
c = c.filter(new CardListFilter() {
public boolean addCard(Card c) {
return !c.getType().contains("Basic");
}
});
return c.toArray();
}//removeLand()
};//SpellAbility spell
spell.setChooseTargetAI(CardFactoryUtil.AI_targetHuman());
card.clearSpellAbility();
card.addSpellAbility(spell);
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
}//*************** END ************ END **************************
//*************** START *********** START **************************
if(cardName.equals("Identity Crisis")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 42470566751344693L;
@Override
public boolean canPlayAI() {
String player = getTargetPlayer();
PlayerZone lib = AllZone.getZone(Constant.Zone.Library, player);
CardList libList = new CardList(lib.getCards());
return libList.size() > 0;
}
@Override
public void resolve() {
String player = getTargetPlayer();
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, player);
PlayerZone grave = AllZone.getZone(Constant.Zone.Graveyard, player);
PlayerZone exiled = AllZone.getZone(Constant.Zone.Removed_From_Play, player);
CardList handList = new CardList(hand.getCards());
CardList graveList = new CardList(grave.getCards());
int max = handList.size();
for(int i = 0; i < max; i++) {
Card c = handList.get(i);
hand.remove(c);
exiled.add(c);
}
int grv = graveList.size();
for(int i = 0; i < grv; i++) {
Card c = graveList.get(i);
grave.remove(c);
exiled.add(c);
}
}
};//SpellAbility
spell.setBeforePayMana(CardFactoryUtil.input_targetPlayer(spell));
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
if(cardName.equals("Flame Rift")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = -6008296722680155321L;
@Override
public void resolve() {
AllZone.Human_Life.subtractLife(4);
AllZone.Computer_Life.subtractLife(4);
}
@Override
public boolean canPlayAI() {
return AllZone.Computer_Life.getLife() > 7 && AllZone.Human_Life.getLife() < 7;
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
if(cardName.equals("Serpent Generator")) {
final SpellAbility ability = new Ability_Tap(card, "4") {
private static final long serialVersionUID = 8428205362391909464L;
@Override
public void resolve() {
CardFactoryUtil.makeToken(
"Snake",
"C 1 1 Snake",
card,
"",
new String[] {"Artifact", "Creature", "Snake"},
1,
1,
new String[] {"Whenever this creature deals damage to a player, that player gets a poison counter."});
}
};
ability.setStackDescription("Put a 1/1 colorless Snake artifact creature token onto the battlefield. This creature has \"Whenever this creature deals damage to a player, that player gets a poison counter.\"");
ability.setDescription("4, Tap: Put a 1/1 colorless Snake artifact creature token onto the battlefield. This creature has \"Whenever this creature deals damage to a player, that player gets a poison counter.\" (A player with ten or more poison counters loses the game.)");
card.addSpellAbility(ability);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Urza's Blueprints")) {
final SpellAbility ability = new Ability_Tap(card, "0") {
private static final long serialVersionUID = -1802481790805608497L;
@Override
public boolean canPlayAI() {
return AllZone.Phase.getPhase().equals(Constant.Phase.Main1);
}
@Override
public void resolve() {
AllZone.GameAction.drawCard(card.getController());
}
};//SpellAbility
card.addSpellAbility(ability);
ability.setDescription("tap: Draw a card.");
ability.setStackDescription(card.getName() + " - draw a card.");
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Illusions of Grandeur")) {
final SpellAbility gainLife = new Ability(card, "0") {
@Override
public void resolve() {
Card c = card;
PlayerLife life = AllZone.GameAction.getPlayerLife(c.getController());
life.addLife(20);
}
};
final SpellAbility loseLife = new Ability(card, "0") {
@Override
public void resolve() {
Card c = card;
PlayerLife life = AllZone.GameAction.getPlayerLife(c.getController());
life.subtractLife(20);
}
};
Command intoPlay = new Command() {
private static final long serialVersionUID = 502892931516451254L;
public void execute() {
gainLife.setStackDescription(card.getController() + " gains 20 life");
AllZone.Stack.add(gainLife);
}
};
Command leavesPlay = new Command() {
private static final long serialVersionUID = 5772999389072757369L;
public void execute() {
loseLife.setStackDescription(card.getController() + " loses 20 life");
AllZone.Stack.add(loseLife);
}
};
card.addComesIntoPlayCommand(intoPlay);
card.addLeavesPlayCommand(leavesPlay);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Donate")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 782912579034503349L;
@Override
public void resolve() {
Card c = getTargetCard();
if(c != null && AllZone.GameAction.isCardInPlay(c) && CardFactoryUtil.canTarget(card, c)) {
if(!c.isAura()) {
((PlayerZone_ComesIntoPlay) AllZone.Human_Play).setTriggers(false);
((PlayerZone_ComesIntoPlay) AllZone.Computer_Play).setTriggers(false);
PlayerZone from = AllZone.getZone(c);
from.remove(c);
c.setController(AllZone.GameAction.getOpponent(card.getController()));
PlayerZone to = AllZone.getZone(Constant.Zone.Play,
AllZone.GameAction.getOpponent(card.getController()));
to.add(c);
((PlayerZone_ComesIntoPlay) AllZone.Human_Play).setTriggers(true);
((PlayerZone_ComesIntoPlay) AllZone.Computer_Play).setTriggers(true);
} else //Aura
{
c.setController(AllZone.GameAction.getOpponent(card.getController()));
}
}
}
@Override
public boolean canPlayAI() {
CardList list = new CardList(AllZone.Computer_Play.getCards());
list = list.getName("Illusions of Grandeur");
if(list.size() > 0) {
setTargetCard(list.get(0));
return true;
}
return false;
}
};
Input runtime = new Input() {
private static final long serialVersionUID = -7823269301012427007L;
@Override
public void showMessage() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
CardList perms = new CardList();
perms.addAll(play.getCards());
perms = perms.filter(new CardListFilter() {
public boolean addCard(Card c) {
return c.isPermanent() && !c.getName().equals("Mana Pool");
}
});
boolean free = false;
if(this.isFree()) free = true;
stopSetNext(CardFactoryUtil.input_targetSpecific(spell, perms,
"Select a permanent you control", true, free));
}//showMessage()
};//Input
spell.setBeforePayMana(runtime);
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Gush")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 8881817765689776033L;
@Override
public void resolve() {
AllZone.GameAction.drawCard(card.getController());
AllZone.GameAction.drawCard(card.getController());
}
};
spell.setDescription("Draw two cards.");
spell.setStackDescription(card.getName() + " - Draw two cards.");
final SpellAbility bounce = new Spell(card) {
private static final long serialVersionUID = 1950742710354343569L;
@Override
public void resolve() {
AllZone.GameAction.drawCard(card.getController());
AllZone.GameAction.drawCard(card.getController());
}
@Override
public boolean canPlay() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList list = new CardList(play.getCards());
list = list.getType("Island");
return list.size() >= 2;
}
};
bounce.setDescription("You may return two Islands you control to their owner's hand rather than pay Gush's mana cost.");
bounce.setStackDescription(card.getName() + " - Draw two cards.");
bounce.setManaCost("0");
final Input bounceIslands = new Input() {
private static final long serialVersionUID = 3124427514142382129L;
int stop = 2;
int count = 0;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select an Island");
ButtonUtil.disableAll();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card c, PlayerZone zone) {
if(c.getType().contains("Island") && zone.is(Constant.Zone.Play)) {
AllZone.GameAction.moveToHand(c);
count++;
if(count == stop) {
AllZone.Stack.add(bounce);
stop();
}
}
}//selectCard()
};
bounce.setBeforePayMana(bounceIslands);
Command bounceIslandsAI = new Command() {
private static final long serialVersionUID = 235908265780575226L;
public void execute() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
CardList list = new CardList(play.getCards());
list = list.getType("Island");
//TODO: sort by tapped
for(int i = 0; i < 2; i++) {
AllZone.GameAction.moveToHand(list.get(i));
}
}
};
bounce.setBeforePayManaAI(bounceIslandsAI);
card.clearSpellAbility();
card.addSpellAbility(bounce);
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Thwart")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 6549506712141125977L;
@Override
public void resolve() {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& CardFactoryUtil.isCounterable(sa.getSourceCard());
}
@Override
public boolean canPlayAI() {
return false;
}
};
spell.setDescription("Counter target spell.");
spell.setStackDescription(card.getName() + " - Counter target spell.");
final SpellAbility bounce = new Spell(card) {
private static final long serialVersionUID = -8310299673731730438L;
@Override
public void resolve() {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
PlayerZone play = AllZone.getZone(Constant.Zone.Play, card.getController());
CardList list = new CardList(play.getCards());
list = list.getType("Island");
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& CardFactoryUtil.isCounterable(sa.getSourceCard()) && list.size() >= 3;
}
@Override
public boolean canPlayAI() {
return false;
}
};
bounce.setDescription("You may return three Islands you control to their owner's hand rather than pay Thwart's mana cost.");
bounce.setStackDescription(card.getName() + " - Counter target spell.");
bounce.setManaCost("0");
final Input bounceIslands = new Input() {
private static final long serialVersionUID = 3124427514142382129L;
int stop = 3;
int count = 0;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select an Island");
ButtonUtil.disableAll();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card c, PlayerZone zone) {
if(c.getType().contains("Island") && zone.is(Constant.Zone.Play)) {
AllZone.GameAction.moveToHand(c);
count++;
if(count == stop) {
AllZone.Stack.add(bounce);
stop();
}
}
}//selectCard()
};
bounce.setBeforePayMana(bounceIslands);
Command bounceIslandsAI = new Command() {
private static final long serialVersionUID = 8250154784542733353L;
public void execute() {
PlayerZone play = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
CardList list = new CardList(play.getCards());
list = list.getType("Island");
//TODO: sort by tapped
for(int i = 0; i < 3; i++) {
AllZone.GameAction.moveToHand(list.get(i));
}
}
};
bounce.setBeforePayManaAI(bounceIslandsAI);
card.clearSpellAbility();
card.addSpellAbility(bounce);
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Force of Will")) {
final SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 7960371805654673281L;
@Override
public void resolve() {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& CardFactoryUtil.isCounterable(sa.getSourceCard());
}
@Override
public boolean canPlayAI() {
return false;
}
};
spell.setDescription("Counter target spell.");
spell.setStackDescription(card.getName() + " - Counter target spell.");
final SpellAbility alt = new Spell(card) {
private static final long serialVersionUID = -8643870743780757816L;
@Override
public void resolve() {
SpellAbility sa = AllZone.Stack.pop();
AllZone.GameAction.moveToGraveyard(sa.getSourceCard());
}
@Override
public boolean canPlay() {
if(AllZone.Stack.size() == 0) return false;
//see if spell is on stack and that opponent played it
String opponent = AllZone.GameAction.getOpponent(card.getController());
SpellAbility sa = AllZone.Stack.peek();
PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getController());
CardList list = new CardList(hand.getCards());
list = list.filter(new CardListFilter() {
public boolean addCard(Card c) {
return CardUtil.getColors(c).contains(Constant.Color.Blue) && !c.equals(card);
}
});
return sa.isSpell() && opponent.equals(sa.getSourceCard().getController())
&& CardFactoryUtil.isCounterable(sa.getSourceCard()) && list.size() >= 1;
}
@Override
public boolean canPlayAI() {
return false;
}
};
alt.setDescription("You may pay 1 life and exile a blue card from your hand rather than pay Force of Will's mana cost.");
alt.setStackDescription(card.getName() + " - Counter target spell.");
alt.setManaCost("0");
final Input exileBlue = new Input() {
private static final long serialVersionUID = 8692998689009712987L;
int stop = 1;
int count = 0;
@Override
public void showMessage() {
AllZone.Display.showMessage("Select a blue card");
ButtonUtil.disableAll();
}
@Override
public void selectButtonCancel() {
stop();
}
@Override
public void selectCard(Card c, PlayerZone zone) {
if(CardUtil.getColors(c).contains(Constant.Color.Blue) && zone.is(Constant.Zone.Hand)
&& !c.equals(card)) {
AllZone.GameAction.removeFromGame(c);
String player = card.getController();
AllZone.GameAction.getPlayerLife(player).subtractLife(1);
count++;
if(count == stop) {
AllZone.Stack.add(alt);
stop();
}
}
}//selectCard()
};
alt.setBeforePayMana(exileBlue);
/*
Command bounceIslandsAI = new Command()
{
private static final long serialVersionUID = -8745630329512914365L;
public void execute()
{
PlayerZone play = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
CardList list = new CardList(play.getCards());
list = list.getType("Island");
//TODO: sort by tapped
for (int i=0;i<3;i++)
{
AllZone.GameAction.moveToHand(list.get(i));
}
}
};
alt.setBeforePayManaAI(bounceIslandsAI);
*/
card.clearSpellAbility();
card.addSpellAbility(alt);
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Bestial Menace")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 523613120207836692L;
@Override
public void resolve() {
CardFactoryUtil.makeToken("Snake", "G 1 1 Snake", card, "G",
new String[] {"Creature", "Snake"}, 1, 1, new String[] {""});
CardFactoryUtil.makeToken("Wolf", "G 2 2 Wolf", card, "G", new String[] {"Creature", "Wolf"},
2, 2, new String[] {""});
CardFactoryUtil.makeToken("Elephant", "G 3 3 Elephant", card, "G", new String[] {
"Creature", "Elephant"}, 3, 3, new String[] {""});
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//*************** START *********** START **************************
else if(cardName.equals("Join the Ranks")) {
SpellAbility spell = new Spell(card) {
private static final long serialVersionUID = 2700238195526474372L;
@Override
public void resolve() {
CardFactoryUtil.makeToken("Soldier Ally", "W 1 1 Soldier Ally", card, "W",
new String[] {"Creature", "Soldier", "Ally"}, 1, 1, new String[] {""});
CardFactoryUtil.makeToken("Soldier Ally", "W 1 1 Soldier Ally", card, "W",
new String[] {"Creature", "Soldier", "Ally"}, 1, 1, new String[] {""});
}//resolve()
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*************** END ************ END **************************
//********************Start********Start***********************
else if(cardName.equals("Living Death"))
{
final SpellAbility spell = new Spell(card)
{
private static final long serialVersionUID = -7657135492744579098L;
public void resolve()
{ //grab make 4 creature lists: human_play, human_graveyard, computer_play, computer_graveyard
CardList human_play = new CardList();
human_play.addAll(AllZone.Human_Play.getCards());
human_play = human_play.filter(new CardListFilter()
{
public boolean addCard(Card c) { return c.isCreature(); }
});
CardList human_graveyard = new CardList();
human_graveyard.addAll(AllZone.Human_Graveyard.getCards());
human_graveyard = human_graveyard.filter(new CardListFilter()
{
public boolean addCard(Card c) { return c.isCreature(); }
});
CardList computer_play = new CardList();
computer_play.addAll(AllZone.Computer_Play.getCards());
computer_play = computer_play.filter(new CardListFilter()
{
public boolean addCard(Card c) { return c.isCreature(); }
});
CardList computer_graveyard = new CardList();
computer_graveyard.addAll(AllZone.Computer_Graveyard.getCards());
computer_graveyard = computer_graveyard.filter(new CardListFilter()
{
public boolean addCard(Card c) { return c.isCreature(); }
});
Card c = new Card();
Iterator<Card> it = human_play.iterator();
while(it.hasNext())
{
c = it.next();
AllZone.GameAction.moveTo(AllZone.Human_Play,c);
AllZone.GameAction.moveTo(AllZone.Human_Graveyard,c);
}
it = human_graveyard.iterator();
while(it.hasNext())
{
c = it.next();
AllZone.GameAction.moveTo(AllZone.Human_Graveyard,c);
AllZone.GameAction.moveTo(AllZone.Human_Play,c);
}
it = computer_play.iterator();
while(it.hasNext())
{
c = it.next();
AllZone.GameAction.moveTo(AllZone.Computer_Play,c);
AllZone.GameAction.moveTo(AllZone.Computer_Graveyard,c);
}
it = computer_graveyard.iterator();
while(it.hasNext())
{
c = it.next();
AllZone.GameAction.moveTo(AllZone.Computer_Graveyard,c);
AllZone.GameAction.moveTo(AllZone.Computer_Play,c);
}
}//resolve
};//spellability
card.clearSpellAbility();
card.addSpellAbility(spell);
}//*********************END**********END***********************
//*************** START *********** START **************************
else if(cardName.equals("Exhume"))
{
final SpellAbility spell = new Spell(card)
{
private static final long serialVersionUID = 8073863864604364654L;
public void resolve()
{
PlayerZone humanPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
PlayerZone computerPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
PlayerZone humanGrave = AllZone.getZone(Constant.Zone.Graveyard, Constant.Player.Human);
PlayerZone computerGrave = AllZone.getZone(Constant.Zone.Graveyard, Constant.Player.Computer);
CardList humanList = new CardList(humanGrave.getCards());
humanList = humanList.getType("Creature");
CardList computerList = new CardList(computerGrave.getCards());
computerList = computerList.getType("Creature");
Card c;
if (humanList.size() > 0)
{
Object check = AllZone.Display.getChoiceOptional("Select creature to Exhume", humanList.toArray());
if (check!=null)
{
c = (Card)check;
humanGrave.remove(c);
humanPlay.add(c);
}
}
if (computerList.size() > 0)
{
c = CardFactoryUtil.AI_getBestCreature(computerList);
if (c != null)
{
computerGrave.remove(c);
computerPlay.add(c);
}
else
{
computerGrave.remove(computerList.get(0));
computerPlay.add(computerList.get(0));
}
}
}
public boolean canPlayAI()
{
PlayerZone humanGrave = AllZone.getZone(Constant.Zone.Graveyard, Constant.Player.Human);
PlayerZone computerGrave = AllZone.getZone(Constant.Zone.Graveyard, Constant.Player.Computer);
CardList humanList = new CardList(humanGrave.getCards());
humanList = humanList.getType("Creature");
CardList computerList = new CardList(computerGrave.getCards());
computerList = computerList.getType("Creature");
if (computerList.size() > 0)
{
if (humanList.size() == 0)
return true;
return CardFactoryUtil.AI_getBestCreature(computerList).getNetAttack() >
CardFactoryUtil.AI_getBestCreature(humanList).getNetAttack();
}
return false;
}
};
card.clearSpellAbility();
card.addSpellAbility(spell);
}
//*************** END ************ END **************************
// Cards with Cycling abilities
// -1 means keyword "Cycling" not found
if(hasKeyword(card, "Cycling") != -1) {
int n = hasKeyword(card, "Cycling");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final String manacost = k[1];
card.addSpellAbility(CardFactoryUtil.ability_cycle(card, manacost));
}
}//Cycling
while(hasKeyword(card, "TypeCycling") != -1) {
int n = hasKeyword(card, "TypeCycling");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final String type = k[1];
final String manacost = k[2];
card.addSpellAbility(CardFactoryUtil.ability_typecycle(card, manacost, type));
}
}//TypeCycling
if(hasKeyword(card, "Transmute") != -1) {
int n = hasKeyword(card, "Transmute");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final String manacost = k[1];
card.addSpellAbility(CardFactoryUtil.ability_transmute(card, manacost));
}
}//transmute
while(hasKeyword(card, "Soulshift") != -1) {
int n = hasKeyword(card, "Soulshift");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final String manacost = k[1];
card.addSpellAbility(CardFactoryUtil.soul_desc(card, manacost));
card.addDestroyCommand(CardFactoryUtil.ability_Soulshift(card, manacost));
}
}//Soulshift
if(hasKeyword(card, "Vanishing") != -1) {
int n = hasKeyword(card, "Vanishing");
if(n != -1) {
String parse = card.getKeyword().get(n).toString();
card.removeIntrinsicKeyword(parse);
String k[] = parse.split(":");
final int power = Integer.parseInt(k[1]);
card.addComesIntoPlayCommand(CardFactoryUtil.vanishing(card, power));
card.addSpellAbility(CardFactoryUtil.vanish_desc(card, power));
}
}//Vanishing
return card;
}//getCard2
// copies stats like attack, defense, etc..
public static Card copyStats(Object o) {
Card sim = (Card) o;
Card c = new Card();
c.setBaseAttack(sim.getBaseAttack());
c.setBaseDefense(sim.getBaseDefense());
c.setIntrinsicKeyword(sim.getKeyword());
c.setName(sim.getName());
c.setImageName(sim.getImageName());
c.setType(sim.getType());
c.setText(sim.getSpellText());
c.setManaCost(sim.getManaCost());
return c;
}// copyStats()
public static void main(String[] args) {
CardFactory f = new CardFactory("cards.txt");
Card c = f.getCard("Arc-Slogger", "d");
System.out.println(c.getOwner());
}
}
Reference in New Issue View Git Blame Copy Permalink