/MWServer/src/main/java/mw/server/model/Card.java

package mw.server.model;



import java.io.Serializable;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;



import mw.mtgforge.Constant;

import mw.server.GameManager;

import mw.server.card.GroovyScriptFacade;

import mw.server.event.EventManager;

import mw.server.model.MagicWarsModel.CardSuperType;

import mw.server.model.MagicWarsModel.CardType;

import mw.server.model.MagicWarsModel.Color;

import mw.server.model.MagicWarsModel.GameZone;

import mw.server.model.ability.ManaAbility;

import mw.server.model.cost.ManaCost;

import mw.server.pattern.Command;

import mw.server.pattern.CommandArgs;

import mw.server.pattern.CommandChain;

import mw.server.pattern.CommandChain.ExecuteOrder;

import mw.utils.CommonUtil;



import org.apache.log4j.Logger;



/**

 * @author mtgforge modified by nantuko

 */

public class Card implements Serializable, Cloneable {



	private static final Logger log = Logger.getLogger(Card.class);

	

	private static int nextUniqueNumber;

	private int uniqueNumber = nextUniqueNumber++;

	

	private boolean isScripted = false;



    private GameManager game;

    

	private ArrayList<String> keyword = new ArrayList<String>();

	private Map<String, List<Object>> aspects = new HashMap<String, List<Object>>();

	private ArrayList<Card> attached = new ArrayList<Card>();



	private List<CardSuperType> cardSuperType = new ArrayList<CardSuperType>();

	private List<CardType> cardType = new ArrayList<CardType>();

	private List<String> cardSubType = new ArrayList<String>();

	



	/**

	 * Spell abilities.

	 */

	private ArrayList<SpellAbility> spellAbility = new ArrayList<SpellAbility>();



	/**

	 * Spell color

	 */

	private ArrayList<String> color = new ArrayList<String>();



	private boolean tapped;

	//private EditableProperty<Boolean> tapped;

	

	private boolean sickness = true;// summoning sickness

	private boolean token = false;

	private boolean suspended = false;



	private boolean isAttacking = false;

	private boolean isBlocking = false;



	/**

	 * When figuring a creature's power and toughness, apply effects in a series of sublayers in the following order: 

	 * (a) effects from characteristic-defining abilities; 

	 * (b) effects that set power and/or toughness to a specific number or value; 

	 * (c) effects that modify power and/or toughness but don't set power and/or toughness to a specific number or value; 

	 * (d) changes from counters; 

	 * (e) effects that switch a creature's power and toughness. 

	 * This means that effects that switch power and toughness are always applied last 

	 * when determining a creature's power and toughness, 

	 * even if other power/toughness-changing effects are created later in the turn. 

	 */

	private int power;

	private int toughness;

	private int pumpAttack;

	private int pumpDefense;

	private boolean powerToughnessIsSwitched;

	

	/**

	 * This values can't be changed. In real life this is what is displayed on printed card.

	 */

	private final int basePower;

	private final int baseToughness;

	private final List<String> baseColor;

	

	private int damage;

	private Damage assignedDamage = new Damage();

	private int nShield;

	private int turnInZone;

	private int abilityLastPlayedTurn = 0;

	private boolean canBePrevented = true;

	

	/**

	 * Mana abilities

	 */

	ArrayList<String> manaAbilities = new ArrayList<String>();



	/**

	 * Table ID.

	 */

	private int tableID;



	/**

	 * Owner ID.

	 */

	private int ownerID = 0;



	/**

	 * Controller ID.

	 */

	private int controllerID = 0;

	

	private String name = "";

	private String rarity = "";

	private String text = "";

	private ArrayList<String> oracleText = new ArrayList<String>();

	private String manaCost = "";



	private String setName = "";

	private int collectorID = 0;



	private boolean hybrid = false;

	

	private CommandChain entersTheGame = new CommandChain(Command.Blank, null);

	private CommandChain entersTheBattlefield = new CommandChain(Command.Blank, null);

	private CommandChain leavesTheBattlefield = new CommandChain(Command.Blank, null);

	private Command destroyCommand = Command.Blank;

	private CommandChain dealDamageCommand = new CommandChain(Command.Blank, null);

	//private Command dealDamageCommand = Command.Blank;

	private Command dealDamageToCreatureCommand = Command.Blank;

	private Command dealtDamageCommand = null;

	private Command dealtDamageCommandEx = null;

	private Command whenPlayCommand = Command.Blank;

	private CommandArgs changeCountersCommand = CommandArgs.Blank;

	private Command equipCommand = Command.Blank;

	private Command unEquipCommand = Command.Blank;

	private Command cyclingCommand = Command.Blank;

	private Command changeControllerCommand = null;

	private Command asLongAsCommand = null;

	private Command preCombatMainPhaseCommand = null;



	private int latestDealtDamage;



	private boolean isPlayer;

	private int playerIdToAsk = -1;



	private boolean flashback = false;



	/**

	 * Counters that prevent the permanent to being tapped.

	 */

	private int preventUntapCounters;

	

	/**

	 * Amount of damage that should be prevented

	 */

	private int preventDamage;



	/**

	 *  Contains cards this card is equipped by

	 */

	private ArrayList<Card> equippedBy = new ArrayList<Card>();



	/**

	 *  Contain card that this card equips

	 */

	private ArrayList<Card> equipping = new ArrayList<Card>(); //equipping size will always be 0 or 1 

	

	/**

	 * Contains counters of different types.

	 */

	private HashMap<CounterType,Integer> counters = new HashMap<CounterType,Integer>();

	

	/**

	 * Reference to groovy facade object. 

	 * Used by groovy scripting to get access to compiled groovy class.

	 */

	private GroovyScriptFacade groovyRef;

	

	/**

	 * Default constructor

	 */

	public Card() {

		this.basePower = this.baseToughness = 0;

		this.baseColor = new ArrayList<String>();

		this.baseColor.add(Constant.Color.Colorless);

		color.add(Constant.Color.Colorless);

	}

	

	public Card(int basePower, int baseToughness, List<String> baseColor) {

		this.basePower = basePower;

		this.baseToughness = baseToughness;

		this.power = basePower;

		this.toughness = baseToughness;

		this.baseColor = baseColor;

		for (String _color : baseColor) color.add(_color);

	}

	

	public void addLoyaltyCounter(int n) {

		putCounter(CounterType.LOYALTY, n);

	}



	public void subtractLoyaltyCounter(int n) {

		removeCounter(CounterType.LOYALTY, n);

	}



	public int getLoyaltyCounters() {

		return getCounters(CounterType.LOYALTY);

	}



	// the amount of damage needed to kill the creature

	public int getKillDamage() {

		return getDefense() - getDamage();

	}



	public int getTurnInZone() {

		return turnInZone;

	}



	public void setTurnInZone(int turn) {

		turnInZone = turn;

	}



	public void setManaCost(String s) {

		manaCost = s;

	}



	public String getManaCost() {

		return manaCost;

	}

	

	public ManaCost getManacost() {

		return new ManaCost(this.manaCost);

	}



	public String getSpellText() {

		return text;

	}



	public void setText(String t) {

		text = t;

	}

	

	public String getText() {

		String t = text.replace("{this}", this.name);

		return t;

	}



	public boolean isAttacking() {

		return isAttacking;

	}



	public void setAttacking(boolean isAttacking) {

		this.isAttacking = isAttacking;

	}



	public String getDetailedText() {

		if (isInstant() || isSorcery()) {

			String s = getSpellText();

			SpellAbility[] sa = getSpellAbility();

			for (int i = 0; i < sa.length; i++)

				s += sa[i].toString();



			return s;

		}



		String s = "";

		ArrayList<String> keyword = getKeyword();

		for (int i = 0; i < keyword.size(); i++) {

			if (i != 0)

				s += ", ";

			s += keyword.get(i).toString();

		}



		s += "\r\n" + text;



		SpellAbility[] sa = getSpellAbility();

		for (int i = 0; i < sa.length; i++) {

			// presumes the first SpellAbility added to this card, is the "main"

			// spell

			// skip the first SpellAbility for creatures, since it says

			// "Summon this creature"

			// looks bad on the Gui card detail

			if (isPermanent() && i != 0) {

				s += sa[i].toString();

			}

		}



		return s.trim();

	}// getText()

	

	public void clearSpellAbility() {

		spellAbility.clear();

	}



	public void addSpellAbility(SpellAbility a) {

		spellAbility.add(a);

	}	



	public SpellAbility[] getSpellAbility() {

		ArrayList<SpellAbility> spells = new ArrayList<SpellAbility>();

		for (SpellAbility spell : spellAbility) {

			/*f (spell instanceof SpellChainFactory) {

				spells.add(((SpellChainFactory) spell).getMainSpell());

			} else {

				spells.add(spell);

			}*/

			spells.add(spell);

		}

		SpellAbility[] s = new SpellAbility[spells.size()];

		spells.toArray(s);

		return s;

	}



	public ArrayList<SpellAbility> getSpellAbilities() {

		return spellAbility;

	}



	// shield = regeneration

	public void setShield(int n) {

		nShield = n;

	}



	public int getShield() {

		return nShield;

	}



	public void addShield() {

		nShield++;

	}



	public void subtractShield() {

		nShield--;

	}



	public void resetShield() {

		nShield = 0;

	}



	// is this "Card" supposed to be a token?

	public void setToken(boolean b) {

		token = b;

	}



	public boolean isToken() {

		return token;

	}



	public void setEntersTheGameCommand(Command entersTheGameCommand) {

		entersTheGame = new CommandChain(entersTheGameCommand, entersTheGame);

	}

	

	/**

	 * This method calls commands to prepare card for the game.

	 * At least it is used to register observers whenever card appears in the game.

	 * Note: card enters the game only once (usually when library is built) and never leaves.

	 */

	public void entersTheGame() {

		entersTheGame.executeChain();

	}

	

	/**

	 * Adds EntersTheBattlefield Trigger Command

	 * The command will be executed first, 

	 * use setEntersTheBattlefieldCommand(Command entersTheBattlefieldCommand, boolean backOrder)

	 * if you want to execute it at the end

	 * 

	 * @param entersTheBattlefieldCommand

	 */

	public void setEntersTheBattlefieldCommand(Command entersTheBattlefieldCommand) {

		entersTheBattlefield = new CommandChain(entersTheBattlefieldCommand, entersTheBattlefield);

	}

	

	/**

	 * Adds EntersTheBattlefield Trigger Command

	 * Allows to add command at the end (backOrder = true)

	 * 

	 * @param entersTheBattlefieldCommand

	 * @param order a

	 */

	public void setEntersTheBattlefieldCommand(Command entersTheBattlefieldCommand, ExecuteOrder order) {

		entersTheBattlefield = new CommandChain(entersTheBattlefieldCommand, entersTheBattlefield, order);

	}



	public void entersTheBattlefield() {

		entersTheBattlefield.executeChain();

	}



	public Command getChangeControllerCommand() {

		return changeControllerCommand;

	}



	public void setChangeControllerCommand(Command changeControllerCommand) {

		this.changeControllerCommand = changeControllerCommand;

	}

	

	public boolean hasComesIntoPlayCommand() {

		return !entersTheBattlefield.isBlank();

	}



	public void setDestroyCommand(Command c) {

		destroyCommand = c;

	}



	public void destroy() {

		destroyCommand.execute();

	}



	public void leavesTheBattlefield() {

		leavesTheBattlefield.executeChain();

	}



	public void setLeavesTheBattlefieldCommand(Command leavesTheBattlefieldCommand) {

		leavesTheBattlefield = new CommandChain(leavesTheBattlefieldCommand, leavesTheBattlefield);

	}

	

	public Command getCyclingCommand() {

		return cyclingCommand;

	}



	public void setCyclingCommand(Command cyclingCommand) {

		this.cyclingCommand = cyclingCommand;

	}

	

	public Command getPreCombatMainPhaseCommand() {

		return preCombatMainPhaseCommand;

	}



	public void setPreCombatMainPhaseCommand(Command preCombatMainPhaseCommand) {

		this.preCombatMainPhaseCommand = preCombatMainPhaseCommand;

	}

	

	public void setSickness(boolean b) {

		sickness = b;

	}



	public boolean hasSickness() {

		if (getKeyword().contains(MagicWarsModel.KEYWORD_HASTE_SA))

			return false;



		return sickness;

	}

	

	public boolean hasFlying() {

		return getKeyword().contains("Flying");

	}



	public void setRarity(String s) {

		rarity = s;

	}



	public String getRarity() {

		return rarity;

	}



	/**

	 * Use GameManager.addDamage(int tableID, int damage) instead. The method

	 * has default access that used by CardProxy.

	 */

	void addDamage(int n, Card source) {

		latestDealtDamage = n;

		if (dealtDamageCommand != null) {

			dealtDamageCommand.execute();

		}

		if (dealtDamageCommandEx != null) {

			dealtDamageCommandEx.setTarget(source);

			dealtDamageCommandEx.execute();

		}

		setDamage(getDamage() + latestDealtDamage);

	}



	void setDamage(int n) {

		damage = n;

	}



	public int getDamage() {

		return damage;

	}



	public void setAssignedDamage(Damage d) {

		assignedDamage = d;

	}



	public Damage getAssignedDamage() {

		return assignedDamage;

	}



	public String getName() {

		return name;

	}

	

	public boolean name(String name) {

		return this.name.equals(name);

	}

	

	public int getOwnerID() {

		return ownerID;

	}



	public int getOwner() {

		return getOwnerID();

	}



	public int getControllerID() {

		return controllerID;

	}

	

	public int getController() {

		return getControllerID();

	}



	public void setName(String s) {

		name = s;

	}

	

	public String getCardKey() {

		return setName + ':' + collectorID; 

	}

	

	public void setOwner(int ownerID) {

		this.ownerID = ownerID;

	}



	public void setController(int controllerID) {

		this.controllerID = controllerID;

		// this.updateObservers();

	}



	// array size might equal 0, will NEVER be null

	public ArrayList<Card> getAttachedCards() {

		return attached;

	}



	public boolean hasAttachedCards() {

		return attached.size() != 0;

	}



	public void attachCard(Card c) {

		attached.add(c);

	}



	public void unattachCard(Card c) {

		attached.remove(c);

	}



	public void setCardSubType(List<String> subTypes) {

		this.cardSubType = new ArrayList<String>(subTypes);

	}

	

	public void setCardType(List<CardType> cardTypes) {

		this.cardType = new ArrayList<CardType>(cardTypes);

	}



	public void setCardSuperType(List<CardSuperType> superTypes) {

		this.cardSuperType = new ArrayList<CardSuperType>(superTypes);

	}



	public void addType(String type) {

		CommonUtil.addType(this, type);

	}

	

	public void addSubType(String subType) {

		cardSubType.add(subType);

	}

	

	public void addCardType(CardType type) {

		cardType.add(type);

	}

	

	public void addSuperType(CardSuperType superType) {

		cardSuperType.add(superType);

	}



	public void removeType(String a) {

        cardSubType.remove(a);

	}

	

	public void resetType() {

		cardSubType.clear();

	}



    private boolean typeContains(List<?> list, Object s) {

    	if (s == null) return false;

    	return list.contains(s);

	}



	public boolean type(String type) {

		return subType(type) || cardType(CardType.getByName(type)) || superType(CardSuperType.getByName(type));

	}

	

	/**

	 * The same as type(String type)

	 * @param subType

	 * @return

	 */

	public boolean subType(String subType) {

		return typeContains(this.cardSubType, subType);

	}

	

	public boolean cardType(CardType cardType) {

		return typeContains(this.cardType, cardType);

	}



    public boolean superType(CardSuperType superType) {

    	return typeContains(this.cardSuperType, superType);

    }

    

	public ArrayList<String> getType() {

		return new ArrayList<String>(this.cardSubType);

	}

	

	public ArrayList<String> getSubType() {

		return getType();

	}

	

	public ArrayList<CardType> getCardType() {

		return new ArrayList<CardType>(this.cardType);

	}

	

	public ArrayList<CardSuperType> getCardSuperType() {

		return new ArrayList<CardSuperType>(this.cardSuperType);

	}



	public int getAttack() {

		if (!powerToughnessIsSwitched) {

			return power + pumpAttack + getCounters(CounterType.P1P1) - getCounters(CounterType.M1M1);

		} else {

			return toughness + pumpDefense + getCounters(CounterType.P1P1) - getCounters(CounterType.M1M1);

		}

	}



	public int getPower() {

		return getAttack();

	}

	

	public int getDefense() {

		if (!powerToughnessIsSwitched) {

			return toughness + pumpDefense + getCounters(CounterType.P1P1) - getCounters(CounterType.M1M1);

		} else {

			return power + pumpAttack + getCounters(CounterType.P1P1) - getCounters(CounterType.M1M1);

		}

	}

	

	public int getToughness() {

		return getDefense();

	}

	

	public int getBaseAttack() {

		return power;

	}



	public int getBaseDefense() {

		return toughness;

	}

	

	public void switchPowerToughness() {

		powerToughnessIsSwitched = !powerToughnessIsSwitched;

	}

	

	public void setAttack(int n) {

		power = n;

	}



	public void addAttack(int n) {

		pumpAttack += n;

	}



	public void subAttack(int n) {

		pumpAttack -= n;

	}



	public void addDefense(int n) {

		pumpDefense += n;

	}



	public void subDefense(int n) {

		pumpDefense -= n;

	}

	

	public void setDefense(int n) {

		toughness = n;

	}

	

	public void resetPump() {

		pumpAttack = 0;

		pumpDefense = 0;

	}

	

	/**

	 * Set power and toughness to original.

	 */

	public void resetPT() {

		power = basePower;

		toughness = baseToughness;

	}



	public boolean isUntapped() {

		return !tapped;

		//return !tapped.getValue();

	}



	public boolean isTapped() {

		return tapped;

		//return tapped.getValue();

	}



	private void setTapped(boolean value) {

		tapped = value;

		//tapped.setValue(value);

	}

	

	public void entersTheBattlefieldTapped() {

		tapped = true;

		//tapped.setValueSilent(true);

	}

	

	public void tap() {

		setTapped(true);

		if (this.game == null) {

			throw new RuntimeException("Game reference is null.");

		}

		getGame().getEventManager().getTapEvent().notifyObservers(this);

	}



	public void untap() {

		if (preventUntapCounters == 0) {

			setTapped(false);

		}

	}



	/**

	 * Keywords are like flying, fear, first strike, etc...

	 * @return

	 */

	public ArrayList<String> getKeyword() {

		return new ArrayList<String>(keyword);

	}



	public void setKeyword(ArrayList<String> a) {

		keyword = new ArrayList<String>(a);

	}



	public void addKeyword(String s) {

		keyword.add(s);

	}



	public void removeKeyword(String s) {       

		keyword.remove(s);

	}

	

	public boolean hasKeyword(String s) {

		return keyword.contains(s);

	}

	

	public boolean keyword(String s) {

		return hasKeyword(s);

	}



	/**

	 * Aspects are to save card specific information

	 * Example: touchedByGloryofWarfare that means that creature has been already pumped by the card

	 * @return

	 */

	public Map<String, List<Object>> getAspects() {

		return new HashMap<String, List<Object>>(aspects);

	}



	public Object getAspectValue(String aspect) {

		if (aspects.containsKey(aspect)) {

			List<Object> values = aspects.get(aspect);

			if (values != null) {

				return values.get(values.size()-1);

			}

		}

		return "";

	}

	

	public List<Object> getAspectValues(String aspect) {

		if (aspects.containsKey(aspect)) {

			List<Object> values = aspects.get(aspect);

			if (values != null) {

				return values;

			}

		}

		return new ArrayList<Object>();

	}

	

	public void setAspects(Map<String, List<Object>> a) {

		aspects = a;

	}

	

	public void addAspect(String aspect) {

		aspects.put(aspect, null);

	}

	

	public void addAspect(String aspect, Object value) {

		if (aspects.containsKey(aspect)) {

			List<Object> values = aspects.get(aspect);

			if (values == null) {

				values = new ArrayList<Object>();

			}

			values.add(value);

			aspects.put(aspect, values);

		} else {

			List<Object> values = new ArrayList<Object>();

			values.add(value);

			aspects.put(aspect, values);	

		}

	}



	public void removeAspect(String aspect) {

		if (aspects.containsKey(aspect)) {

			List<Object> values = aspects.get(aspect);

			if (values == null || values.size() < 2) {

				aspects.remove(aspect);		

			} else {

				values.remove(values.size() - 1);

				aspects.put(aspect, values);

			}

		}

	}

	

	public boolean hasAspect(String s) {

		return aspects.containsKey(s);

	}

	

	public void updateAspectValue(String aspect, Serializable value) {

		if (aspects.containsKey(aspect)) {

			List<Object> values = aspects.get(aspect);

			if (values != null && values.size() > 0) {

				values.remove(values.size()-1);

			}

			values.add(value);

		} else {

			addAspect(aspect, value);

		}

	}

	

	///////////////////////////////////////////////////////////////////////////////////////////////

	

	public boolean isPermanent() {

		return !(isInstant() || isSorcery());

	}



	public boolean isCreature() {

		return cardType(CardType.Creature);

	}



	public boolean isBasicLand() {

		return superType(CardSuperType.Basic) && isLand();

	}



	public boolean isLand() {

		return cardType(CardType.Land);

	}



	public boolean isSorcery() {

		return cardType(CardType.Sorcery);

	}



	public boolean isInstant() {

		return cardType(CardType.Instant);

	}



	public boolean isArtifact() {

		return cardType(CardType.Artifact);

	}



	public boolean isEquipment() {

		return subType("Equipment");

	}



	public boolean isPlaneswalker() {

		return cardType(CardType.Planeswalker);

	}



	// global and local enchantments

	public boolean isEnchantment() {

		return cardType(CardType.Enchantment);

	}



	public boolean isAura() {

		return subType("Aura");

	}



	public void setUniqueNumber(int n) {

		uniqueNumber = n;

	}



	public int getUniqueNumber() {

		return uniqueNumber;

	}



	public ArrayList<String> getColor() {

		return color;

	}

	

	public boolean isColored() {

		return color.contains(Color.White.toCode()) || color.contains(Color.Green.toCode()) || color.contains(Color.Red.toCode()) || color.contains(Color.Black.toCode())

				|| color.contains(Color.Blue.toCode());

	}

	

	public boolean isMulticolored() {

		int count = 0;

		if (color.contains(Color.White.toCode())) count++;

		if (color.contains(Color.Green.toCode())) count++;

		if (color.contains(Color.Red.toCode())) count++;

		if (color.contains(Color.Black.toCode())) count++;

		if (color.contains(Color.Blue.toCode())) count++;

		return count > 1;

	}



	public void resetColor() {

		this.color.clear();

		for (String _color : baseColor) {

			this.color.add(_color);

		}

	}



	public void setColor(String color) {

		this.color.clear();

		this.color.add(color);

	}

	

	public void setColors(ArrayList<String> colors) {

		this.color = colors;

	}



	public void addColor(String color) {

		this.color.add(color);

	}

	

	public void removeColor(String color) {

		this.color.remove(color);

	}

	

	public void addColor(MagicWarsModel.Color color) {

		addColor(color.toCode());

	}

	

	public void removeColor(MagicWarsModel.Color color) {

		removeColor(color.toCode());

	}

	

	public void setColor(MagicWarsModel.Color color) {

		setColor(color.toCode());

	}

	

	public boolean color(Color color) {

		return this.color.contains(color.toCode());

	}



	public int getTableID() {

		return tableID;

	}



	public void setTableID(int id) {

		tableID = id;

	}



	public void dealCombatDamageToPlayer() {

		dealDamageCommand.executeChain();

	}



	public void setDamagePlayerCommand(Command c) {

		dealDamageCommand = new CommandChain(c, dealDamageCommand);

	}

	

	public void dealDamageToCreatureCommand() {

		dealDamageToCreatureCommand.execute();

	}



	public void setDealDamageToCreatureCommand(Command c) {

		dealDamageToCreatureCommand = c;

	}



	public void setDealtDamageCommand(Command c) {

		dealtDamageCommand = c;

	}



	public Command getDealtDamageCommand() {

		return dealtDamageCommand;

	}



	public void setDealtDamageCommandEx(Command c) {

		dealtDamageCommandEx = c;

	}



	public Command getDealtDamageCommandEx() {

		return dealtDamageCommand;

	}



	public boolean equals(Object o) {

		if (o instanceof Card) {

			Card c = (Card) o;

			int a = getUniqueNumber();

			int b = c.getUniqueNumber();

			//int a1 = getTableID();

			//int b1 = c.getTableID();

			//return (a == b && a1 == b1);

			return a == b;

		}

		return false;

	}

	

	/**

	 * Compare card parameters (type, controller, keywords, etc.)

	 * @param card

	 * @return true if the same

	 */

	public boolean equalsTo(Card card) {

		List<CardType> newCardType = card.getCardType();

		List<CardSuperType> newCardSuperType = card.getCardSuperType();

		List<String> newCardSubType = card.getType();

		List<String> newCardKeyword = card.getKeyword();

		List<String> newCardColor = card.getColor();

		HashMap<CounterType, Integer> newCardCounters = card.getAllCounters();

		ArrayList<String> newCardMA = card.getManaAbilities();

		ArrayList<Card> newCardAttached = card.getAttachedCards();

		// quick check

		if (cardType.size() != newCardType.size()) return false;		

		if (keyword.size() != newCardKeyword.size()) return false;		

		if (color.size() != newCardColor.size()) return false;

		if (counters.size() != newCardCounters.size()) return false;

		if (manaAbilities.size() != newCardMA.size()) return false;

		if (attached.size() != newCardAttached.size()) return false;

		

		if (isAttacking != card.isAttacking) return false;

		if (isBlocking != card.isBlocking) return false;

		//if (tapped.getValue() != card.isTapped()) return false;

		if (tapped != card.isTapped()) return false;

		if (hasSickness() != card.hasSickness()) return false;

		if (isEquipping() != card.isEquipping()) return false;

		if (damage != card.getDamage()) return false;

		

		// name

		if (!getName().equals(card.getName())) return false;

		// controller

		if (getController() != card.getController()) return false;

		// type

		for (CardSuperType t : cardSuperType) {

			if (!newCardSuperType.contains(t)) return false;

		}

		for (CardType t : cardType) {

			if (!newCardType.contains(t)) return false;

		}

		for (String t : cardSubType) {

			if (!newCardSubType.contains(t)) return false;

		}

		// power/toughness

		if (isCreature()) {

			if (getAttack() != card.getAttack()) return false;

			if (getDefense() != card.getDefense()) return false;

		}

		// keyword

		for (String k : keyword) {

			if (!newCardKeyword.contains(k)) return false;

		}

		// color

		for (String c : color) {

			if (!newCardColor.contains(c)) return false;

		}

		// counters

		for (CounterType ct : counters.keySet()) {

			if (!newCardCounters.containsKey(ct)) return false;

			if (!counters.get(ct).equals(newCardCounters.get(ct))) return false;

		}

		// mana abilities

		for (String m : manaAbilities) {

			if (!newCardMA.contains(m)) return false;

		}

		

		return true;

	}



	public int hashCode() {

		return getUniqueNumber();

	}



	public String toString() {

		String lc = "";

		String tid = "";

		Integer count = getLoyaltyCounters();

		if (count > 0) {

			lc = "[" + count + "]";

		}

		if (this.getTableID() > 0) {

			tid = " (" + this.getTableID() + ")";

		}

		return this.getName() + lc + tid;

	}

	

	public String toStringWithUID() {

		return this.getName() + "(" + this.getUniqueNumber() + ")";

	}



	public int getLatestDealtDamage() {

		return latestDealtDamage;

	}



	public void setLatestDealtDamage(int latestDealtDamage) {

		this.latestDealtDamage = latestDealtDamage;

	}



	public int getAbilityLastPlayedTurn() {

		return abilityLastPlayedTurn;

	}



	public void setAbilityLastPlayedTurn(int turn) {

		this.abilityLastPlayedTurn = turn;

	}



	public int getPreventUntapCounters() {

		return preventUntapCounters;

	}



	public void setPreventUntapCounters(int preventUntapCounters) {

		this.preventUntapCounters = preventUntapCounters;

	}



	public void setCounters(CounterType counterType, int n) {

		counters.put(counterType, Integer.valueOf(n));

		if (counterType.equals(CounterType.P1P1) || counterType.equals(CounterType.M1M1)) {

			checkPlusAndMinusCounters();

			changeCountersCommand.execute(this, getCounters(CounterType.P1P1) - getCounters(CounterType.M1M1));

		}

	}



	public void putCounter(CounterType counterType, int n) {

		if (counters.containsKey(counterType)) {

			Integer count = counters.get(counterType) + n;

			counters.put(counterType, count);

		} else {

			counters.put(counterType, Integer.valueOf(n));

		}

		if (counterType.equals(CounterType.P1P1) || counterType.equals(CounterType.M1M1)) {

			checkPlusAndMinusCounters();

			changeCountersCommand.execute(this, getCounters(CounterType.P1P1) - getCounters(CounterType.M1M1));

		}

		

		if (getGame() != null) {

			getGame().getEventManager().getChangeCountersEvent().notifyObservers(this);

		}

	}



	public void removeCounter(CounterType counterType) {

		removeCounter(counterType, 1);

	}

	

	public void resetCounters() {

		for (CounterType type : CounterType.values()) {

			this.removeCounter(type, this.getCounters(type));

		}

	}

	

	public void removeCounter(CounterType counterType, int n) {

		if (counters.containsKey(counterType)) {

			Integer count = counters.get(counterType) - n;

			counters.put(counterType, count);

		}

		if (counterType.equals(CounterType.P1P1) || counterType.equals(CounterType.M1M1)) {

			checkPlusAndMinusCounters();

			changeCountersCommand.execute(this, getCounters(CounterType.P1P1) - getCounters(CounterType.M1M1));

		}

	}

	

	public HashMap<CounterType, Integer> getAllCounters() {

		return this.counters;

	}

	

	@SuppressWarnings("unchecked")

	private void cloneCounters() {

		this.counters = (HashMap<CounterType, Integer>) this.counters.clone();

	}

	

	@SuppressWarnings("unchecked")

	private void cloneEquipping() {

		this.equipping = (ArrayList<Card>) this.equipping.clone();

	}

	

	@SuppressWarnings("unchecked")

	private void cloneAttached() {

		this.attached = (ArrayList<Card>) this.attached.clone();

	}

	

	@SuppressWarnings("unchecked")

	private void cloneKeywords() {

		this.keyword = (ArrayList<String>) this.keyword.clone();

	}

	

	@SuppressWarnings("unchecked")

	private void cloneEditProperties() throws Exception {

		//this.tapped = (EditableProperty<Boolean>) new Expression(this.tapped, "clone", null).getValue();

	}



	private void checkPlusAndMinusCounters() {

		Integer plus = getCounters(CounterType.P1P1);

		Integer minus = getCounters(CounterType.M1M1);

		if (plus > 0 && minus > 0) {

			if (plus >= minus) {

				setCounters(CounterType.P1P1, plus - minus);

				setCounters(CounterType.M1M1, 0);

			} else {

				setCounters(CounterType.M1M1, minus - plus);

				setCounters(CounterType.P1P1, 0);

			}

		}

	}

	

	public int getCounters(CounterType counterType) {

		if (counters.containsKey(counterType)) {

			return counters.get(counterType);

		} else {

			return 0;

		}

	}



	public boolean isHybrid() {

		return hybrid;

	}



	public void setHybrid(boolean b) {

		hybrid = b;

	}



	public boolean isPlayer() {

		return isPlayer;

	}



	public void setPlayer(boolean isPlayer) {

		this.isPlayer = isPlayer;

	}



	private static final String manaString = "tap: add ";



	public void formManaAbilities() {

		formManaAbilities(false);

	}

	

	/**

	 * @param removeKeyword indicates that permanent shouldn't have keyword like "tap: Add {X}"

	 * that is used when paying for spell

	 * should be true for cases when there is need for additional actions, e.g. "sacrifice: add 1"

	 */

	public void formManaAbilities(boolean removeKeyword) {

		ArrayList<String> check = getKeyword();

		manaAbilities.clear();



		ArrayList<SpellAbility> spellAbilitiesWithMana = new ArrayList<SpellAbility>(spellAbility);

		clearSpellAbility();

		for (SpellAbility sa : spellAbilitiesWithMana) {

			if (!(sa instanceof ManaAbility && sa.hasAspect(MagicWarsModel.ASPECT_GENERATED_ABILITY))) {

				addSpellAbility(sa);

			}

		}

		

		for (String keyword : check) {

			if (keyword.startsWith(manaString)) {

				// gets G from "tap: add G"

				final String mana = keyword.substring(manaString.length()).trim();

				

				final ManaAbility manaAbility = new ManaAbility(this) {

					@Override

					public void manaResolve() {

						for (int i = 0; i < mana.length(); i++) {

							((GameManager)game).getPlayerById(getControllerID()).getManaPool().add(mana.substring(i,i+1));

						}

						tap();

					}

					private static final long serialVersionUID = 1L;

				};

				manaAbility.setDescription("{T}: Add " + mana + " to your mana pool.");

				manaAbility.addAspect(MagicWarsModel.ASPECT_GENERATED_ABILITY);

				addSpellAbility(manaAbility);

				if (!removeKeyword) {

					manaAbilities.add(mana);

				}

			}

		}

	}

	

	public ArrayList<String> getManaAbilities() {

		return manaAbilities;

	}



	public boolean isSuspended() {

		return suspended;

	}



	public void setSuspended(boolean suspended) {

		this.suspended = suspended;

	}



	public int getTimeCounters() {

		return getCounters(CounterType.TIME);

	}



	public void setTimeCounters(int timeCounters) {

		setCounters(CounterType.TIME, timeCounters);

	}



	public void addTimeCounters(int timeCounters) {

		putCounter(CounterType.TIME, timeCounters);

	}



	public void removeTimeCounters(int timeCounters) {

		removeCounter(CounterType.TIME, timeCounters);

	}

	

	public int getQuestCounters() {

		return getCounters(CounterType.QUEST);

	}

	

	public int getLevelCounters() {

		return getCounters(CounterType.LEVEL);

	}

	

	public int getChargeCounters() {

		return getCounters(CounterType.CHARGE);

	}



	public int getFadeCounters() {

		return getCounters(CounterType.FADE);

	}

	

	public boolean isBlocking() {

		return isBlocking;

	}



	public void setBlocking(boolean isBlocking) {

		this.isBlocking = isBlocking;

	}



	public Command getWhenPlayCommand() {

		return whenPlayCommand;

	}

	

	public void whenPlayCommand() {

		whenPlayCommand.execute();

	}



	public void setWhenPlayCommand(Command whenPlayCommand) {

		this.whenPlayCommand = whenPlayCommand;

	}

	

	public void setWhenCastCommand(Command whenCastCommand) {

		this.whenPlayCommand = whenCastCommand;

	}



	public void setChangeCountersCommand(CommandArgs changeCountersCommand) {

		this.changeCountersCommand = changeCountersCommand;

	}



	public boolean isFlashback() {

		return flashback;

	}



	public void setHasFlashback(boolean flashback) {

		this.flashback = flashback;

	}



	public boolean isCanBePrevented() {

		return canBePrevented;

	}



	public void setCanBePrevented(boolean canBePrevented) {

		this.canBePrevented = canBePrevented;

	}



	public String getSetName() {

		return setName;

	}



	public void setSetName(String setName) {

		this.setName = setName;

	}



	public void setEquip(Command c) {

		equipCommand = c;

	}



	public void equip() {

		equipCommand.execute();

	}



	public void setUnEquip(Command c) {

		unEquipCommand = c;

	}



	public void unEquip() {

		unEquipCommand.execute();

	}



	public ArrayList<Card> getEquippedBy() {

		return equippedBy;

	}



	public ArrayList<Card> getEquipping() {

		return equipping;

	}

	

	public ArrayList<Card> getEnchanting() {

		return equipping;

	}

	

	public boolean isEnchantedBy(Card card) {

		return equipping.contains(card);

	}

	

	/**

	 * Can be null

	 * @return creature that current card equips

	 */

	public Card getCreatureEquipped() {

		if (equipping == null || equipping.size() == 0) {

			return null;

		}

		return equipping.get(0);

	}



	public boolean isEquipped() {

		return equippedBy.size() != 0;

	}



	public boolean isEquipping() {

		return equipping.size() != 0;

	}

	

	public boolean isEnchanting() {

		return equipping.size() != 0;

	}



	public void removeEquipping(Card c) {

		equipping.remove(c);

		// this.updateObservers();

	}



	public void removeEquippedBy(Card c) {

		equippedBy.remove(c);

		// this.updateObservers();

	}



	public void addEquippedBy(Card c) {

		equippedBy.add(c);

		// this.updateObservers();

	}

	

	/**

	 * Remove equipment effect. Used for equipment cards only

	 * 

	 * @param c

	 */

	public void unEquipCard(Card c) {

		this.unEquip();

		equipping.remove(c);

		c.removeEquippedBy(this);

	}



	/**

	 * Add equipment effect. Used for equipment cards only

	 * 

	 * @param c

	 */

	public void equipCard(Card c) {

		equipping.add(c);

		c.addEquippedBy(this);

		this.equip();

	}

	

	public EventManager getEvents() {

		return getGame().getEventManager();

	}

	

	public int getPlayerIdToAsk() {

		return playerIdToAsk;

	}



	public void setPlayerIdToAsk(int playerIdToAsk) {

		this.playerIdToAsk = playerIdToAsk;

	}

	

	public int getCollectorID() {

		return collectorID;

	}



	public void setCollectorID(int collectorID) {

		this.collectorID = collectorID;

	}

	

	public Command getAsLongAsCommand() {

		return asLongAsCommand;

	}



	public void setAsLongAsCommand(Command asLongAsCommand) {

		this.asLongAsCommand = asLongAsCommand;

	}

	

	public ArrayList<String> getOracleText() {

		return oracleText;

	}



	public void setOracleText(ArrayList<String> oracleText) {

		this.oracleText = oracleText;

		

		if (oracleText == null) {

			return;

			

		}

		this.text = "";

		int index = 0;

		for (String t : oracleText) {

			if (index > 0) {

				text += "<p>";

			}

			text += t;

			index++;

		}

	}

	

	public boolean isScripted() {

		return isScripted;

	}



	public void setScripted(boolean isScripted) {

		this.isScripted = isScripted;

	}

	

	public GameManager getGame() {

		return game;

	}



	public void setGame(GameManager game) {

		this.game = game;

		

		//tapped = new EditableProperty<Boolean>(game, null, "tap", false);

	}

	

	public String plus(String arg) {

		return toString() + arg;

	}



	/**

	 * N.B. This method CAN'T BE used for "Clone" effects: Target creature becomes copy of another target creature.

	 * The main issue is with commands that are stateless but operate with parent card.

	 * So cloning them still operate with original one.

	 * Example: Card1 has "Card1 enters the battlefield tapped" that is implemented as EntersTheBattlefield command.

	 * When we try Card2 = Card1.getCopy() and Card2 enters the battlefield, it would try to tap Card1 because command points to it.

	 * 

	 * There is one option is to clone objects by serialization\desearialization but it causes some problems with anonymous Command classes as it throws exception whenever the class where it is defined is not Serializable (have no "implements Serializable")

	 * So such implementation is very dangerous as may cause exceptions in future when developers add new classes without implementing Serializable interface.

	 * That's why this way was rejected.

	 * 

	 * Call this method for internal use only.

	 * 

	 * 

	 * @deprecated Use {@link GameManager.copyCard(Card card)} instead. 

	 * 

	 * @return

	 */

	@Deprecated

	public Card getCopy() {

		Card clone = null;

		try {

			clone = (Card)this.clone();

			if (game != null) clone.setUniqueNumber(game.getUniqueCardID());

			clone.cloneCounters();

			clone.cloneEquipping();

			clone.cloneAttached();

			clone.cloneKeywords();

			clone.cloneEditProperties();

		} catch (CloneNotSupportedException e) {

			log.error(e,e);

		} catch (Exception e) {

			log.error(e,e);

		}

		return clone;

	}

	

	public int getPreventDamage() {

		return preventDamage;

	}



	public void setPreventDamage(int preventDamage) {

		this.preventDamage = preventDamage;

	}

		

	public void setGroovyRef(GroovyScriptFacade ref) {

		this.groovyRef = ref;

	}

	

	public GroovyScriptFacade getGroovyRef() {

		return this.groovyRef;

	}

	

	public boolean zone(GameZone zone) {

		switch(zone) {

			case Battlefield: 

				return game.getBattlefield().isCardInPlay(this);

			case Graveyard:

				return game.getGraveyard().isCardInGrave(this);

			case Hand:

				return game.getPlayer(getOwnerID()).getHand().isCardInHand(this);

			case Exile:

				return game.getExile().isCardInExile(this);

			case Any:

				return true;

			default: return false;

		}

	}

	

	/**

	 * Reset all parameters based on original card

	 * @param original card to use for reseting

	 * 

	 */

	public void resetCard(Card original) {

		setCardSubType(original.getSubType());

		setCardType(original.getCardType());

		setCardSuperType(original.getCardSuperType());

		setKeyword(original.getKeyword());

		setColors(original.getColor());

		attached.clear();

		

		ownerID = original.getOwnerID();

		controllerID = ownerID;

		

		isAttacking = false;

		isBlocking = false;

		//tapped.setValueSilent(false);

		tapped = false;

		sickness = true;

		equipping.clear();

		equippedBy.clear();

		damage = 0;

		preventUntapCounters = 0;

		flashback = false;

		controllerID = original.getControllerID();

		

		power = original.getAttack();

		toughness = original.getDefense();

		pumpAttack = 0;

		pumpDefense = 0;

		powerToughnessIsSwitched = false;



		resetCounters();

		for (Entry<CounterType, Integer> e : original.getAllCounters().entrySet()) {

			counters.put(e.getKey(), e.getValue());

		}

		

		Map<String, List<Object>> aspects = getAspects();

		setAspects(original.getAspects());

		for (String a : aspects.keySet()) {

			if (a.startsWith(MagicWarsModel.PERMANENT_ASPECT)) {

				addAspect(a);

			}

		}

		

		formManaAbilities();

	}	

	private static final long serialVersionUID = 2L;

}