diff --git a/Mage.AI/build.xml b/Mage.AI/build.xml
new file mode 100644
index 00000000000..e4c2bb70bc5
--- /dev/null
+++ b/Mage.AI/build.xml
@@ -0,0 +1,74 @@
+
+
+
+
+
+
+
+
+
+
+ Builds, tests, and runs the project Mage.AI.
+
+
+
diff --git a/Mage.AI/manifest.mf b/Mage.AI/manifest.mf
new file mode 100644
index 00000000000..1574df4a2de
--- /dev/null
+++ b/Mage.AI/manifest.mf
@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+X-COMMENT: Main-Class will be added automatically by build
+
diff --git a/Mage.AI/nbproject/build-impl.xml b/Mage.AI/nbproject/build-impl.xml
new file mode 100644
index 00000000000..24a2f89b101
--- /dev/null
+++ b/Mage.AI/nbproject/build-impl.xml
@@ -0,0 +1,704 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must set src.src.dir
+ Must set test.test.dir
+ Must set build.dir
+ Must set dist.dir
+ Must set build.classes.dir
+ Must set dist.javadoc.dir
+ Must set build.test.classes.dir
+ Must set build.test.results.dir
+ Must set build.classes.excludes
+ Must set dist.jar
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must set javac.includes
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must select some files in the IDE or set javac.includes
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ To run this application from the command line without Ant, try:
+
+
+
+
+
+
+ java -cp "${run.classpath.with.dist.jar}" ${main.class}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ To run this application from the command line without Ant, try:
+
+ java -jar "${dist.jar.resolved}"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must select one file in the IDE or set run.class
+
+
+
+ Must select one file in the IDE or set run.class
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must select one file in the IDE or set debug.class
+
+
+
+
+ Must select one file in the IDE or set debug.class
+
+
+
+
+ Must set fix.includes
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must select some files in the IDE or set javac.includes
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Some tests failed; see details above.
+
+
+
+
+
+
+
+
+ Must select some files in the IDE or set test.includes
+
+
+
+ Some tests failed; see details above.
+
+
+
+
+ Must select one file in the IDE or set test.class
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must select one file in the IDE or set applet.url
+
+
+
+
+
+
+
+
+ Must select one file in the IDE or set applet.url
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/Mage.AI/nbproject/genfiles.properties b/Mage.AI/nbproject/genfiles.properties
new file mode 100644
index 00000000000..28eb8ef0949
--- /dev/null
+++ b/Mage.AI/nbproject/genfiles.properties
@@ -0,0 +1,8 @@
+build.xml.data.CRC32=40a1fd8e
+build.xml.script.CRC32=dffb6c05
+build.xml.stylesheet.CRC32=958a1d3e@1.26.2.45
+# This file is used by a NetBeans-based IDE to track changes in generated files such as build-impl.xml.
+# Do not edit this file. You may delete it but then the IDE will never regenerate such files for you.
+nbproject/build-impl.xml.data.CRC32=40a1fd8e
+nbproject/build-impl.xml.script.CRC32=dd2e0367
+nbproject/build-impl.xml.stylesheet.CRC32=5c621a33@1.26.2.45
diff --git a/Mage.AI/nbproject/project.properties b/Mage.AI/nbproject/project.properties
new file mode 100644
index 00000000000..11160ec2c77
--- /dev/null
+++ b/Mage.AI/nbproject/project.properties
@@ -0,0 +1,70 @@
+application.title=Mage.AI
+application.vendor=BetaSteward_at_googlemail.com
+build.classes.dir=${build.dir}/classes
+build.classes.excludes=**/*.java,**/*.form
+# This directory is removed when the project is cleaned:
+build.dir=build
+build.generated.dir=${build.dir}/generated
+build.generated.sources.dir=${build.dir}/generated-sources
+# Only compile against the classpath explicitly listed here:
+build.sysclasspath=ignore
+build.test.classes.dir=${build.dir}/test/classes
+build.test.results.dir=${build.dir}/test/results
+# Uncomment to specify the preferred debugger connection transport:
+#debug.transport=dt_socket
+debug.classpath=\
+ ${run.classpath}
+debug.test.classpath=\
+ ${run.test.classpath}
+# This directory is removed when the project is cleaned:
+dist.dir=dist
+dist.jar=${dist.dir}/Mage.AI.jar
+dist.javadoc.dir=${dist.dir}/javadoc
+excludes=
+file.reference.Mage.AI-src=src
+file.reference.Mage.AI-test=test
+includes=**
+jar.compress=false
+javac.classpath=\
+ ${reference.Mage.jar}
+# Space-separated list of extra javac options
+javac.compilerargs=
+javac.deprecation=false
+javac.source=1.6
+javac.target=1.6
+javac.test.classpath=\
+ ${javac.classpath}:\
+ ${build.classes.dir}:\
+ ${libs.junit.classpath}:\
+ ${libs.junit_4.classpath}
+javadoc.additionalparam=
+javadoc.author=false
+javadoc.encoding=${source.encoding}
+javadoc.noindex=false
+javadoc.nonavbar=false
+javadoc.notree=false
+javadoc.private=false
+javadoc.splitindex=true
+javadoc.use=true
+javadoc.version=false
+javadoc.windowtitle=
+main.class=
+manifest.file=manifest.mf
+meta.inf.dir=${src.dir}/META-INF
+platform.active=default_platform
+project.license=bsd
+project.Mage=../Mage
+reference.Mage.jar=${project.Mage}/dist/Mage.jar
+run.classpath=\
+ ${javac.classpath}:\
+ ${build.classes.dir}
+# Space-separated list of JVM arguments used when running the project
+# (you may also define separate properties like run-sys-prop.name=value instead of -Dname=value
+# or test-sys-prop.name=value to set system properties for unit tests):
+run.jvmargs=
+run.test.classpath=\
+ ${javac.test.classpath}:\
+ ${build.test.classes.dir}
+source.encoding=UTF-8
+src.src.dir=src
+test.test.dir=test
diff --git a/Mage.AI/nbproject/project.xml b/Mage.AI/nbproject/project.xml
new file mode 100644
index 00000000000..37b4c2bbee5
--- /dev/null
+++ b/Mage.AI/nbproject/project.xml
@@ -0,0 +1,25 @@
+
+
+ org.netbeans.modules.java.j2seproject
+
+
+ Mage.AI
+
+
+
+
+
+
+
+
+
+ Mage
+ jar
+
+ jar
+ clean
+ jar
+
+
+
+
diff --git a/Mage.AI/src/mage/ai/Attackers.java b/Mage.AI/src/mage/ai/Attackers.java
new file mode 100644
index 00000000000..2f65fc8b1a7
--- /dev/null
+++ b/Mage.AI/src/mage/ai/Attackers.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ * conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ * of conditions and the following disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of BetaSteward_at_googlemail.com.
+ */
+
+package mage.ai;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.TreeMap;
+import mage.game.permanent.Permanent;
+
+/**
+ *
+ * @author BetaSteward_at_googlemail.com
+ */
+public class Attackers extends TreeMap> {
+
+ public List getAttackers() {
+ List attackers = new ArrayList();
+ for (List l: this.values()) {
+ for (Permanent permanent: l) {
+ attackers.add(permanent);
+ }
+ }
+ return attackers;
+ }
+
+}
diff --git a/Mage.AI/src/mage/ai/ComputerPlayer.java b/Mage.AI/src/mage/ai/ComputerPlayer.java
new file mode 100644
index 00000000000..1cfce6ddab0
--- /dev/null
+++ b/Mage.AI/src/mage/ai/ComputerPlayer.java
@@ -0,0 +1,750 @@
+/*
+* Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without modification, are
+* permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this list of
+* conditions and the following disclaimer.
+*
+* 2. Redistributions in binary form must reproduce the above copyright notice, this list
+* of conditions and the following disclaimer in the documentation and/or other materials
+* provided with the distribution.
+*
+* THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED
+* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR
+* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*
+* The views and conclusions contained in the software and documentation are those of the
+* authors and should not be interpreted as representing official policies, either expressed
+* or implied, of BetaSteward_at_googlemail.com.
+*/
+
+package mage.ai;
+
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.TreeMap;
+import java.util.UUID;
+import java.util.logging.Logger;
+import mage.Constants.CardType;
+import mage.Constants.Outcome;
+import mage.Constants.Zone;
+import mage.Mana;
+import mage.abilities.ActivatedAbility;
+import mage.abilities.costs.mana.ColoredManaCost;
+import mage.abilities.costs.mana.GenericManaCost;
+import mage.abilities.costs.mana.HybridManaCost;
+import mage.abilities.costs.mana.ManaCost;
+import mage.abilities.costs.mana.ManaCosts;
+import mage.abilities.costs.mana.MonoHybridManaCost;
+import mage.abilities.costs.mana.VariableManaCost;
+import mage.abilities.effects.Effect;
+import mage.abilities.effects.ReplacementEffect;
+import mage.abilities.keyword.DoubleStrikeAbility;
+import mage.abilities.keyword.FirstStrikeAbility;
+import mage.abilities.keyword.TrampleAbility;
+import mage.abilities.mana.ManaAbility;
+import mage.abilities.mana.ManaOptions;
+import mage.ai.simulators.CombatGroupSimulator;
+import mage.ai.simulators.CombatSimulator;
+import mage.ai.simulators.CreatureSimulator;
+import mage.cards.Card;
+import mage.cards.Cards;
+import mage.choices.Choice;
+import mage.filter.common.FilterCreatureForAttack;
+import mage.filter.common.FilterCreatureForCombat;
+import mage.filter.common.FilterLandCard;
+import mage.filter.common.FilterNonlandCard;
+import mage.game.Game;
+import mage.game.GameState;
+import mage.game.combat.CombatGroup;
+import mage.game.permanent.Permanent;
+import mage.players.Player;
+import mage.players.PlayerImpl;
+import mage.target.Target;
+import mage.target.TargetCard;
+import mage.target.TargetPermanent;
+import mage.target.TargetPlayer;
+import mage.target.common.TargetDiscard;
+import mage.util.Copier;
+import mage.util.Logging;
+import mage.util.TreeNode;
+
+/**
+ *
+ * only suitable for two player games
+ *
+ * @author BetaSteward_at_googlemail.com
+ */
+public class ComputerPlayer extends PlayerImpl implements Player {
+
+ private final static Logger logger = Logging.getLogger(ComputerPlayer.class.getName());
+ private boolean abort = false;
+ private Map unplayable = new TreeMap();
+ private List playableNonInstant = new ArrayList();
+ private List playableInstant = new ArrayList();
+ private List playableAbilities = new ArrayList();
+
+ public ComputerPlayer(String name) {
+ super(name);
+ }
+
+ @Override
+ public boolean chooseMulligan(Game game) {
+ if (hand.size() < 6)
+ return false;
+ List lands = hand.getCards(new FilterLandCard());
+ if (lands.size() < 2 || lands.size() > hand.size() - 2)
+ return true;
+ return false;
+ }
+
+ @Override
+ public boolean chooseTarget(Outcome outcome, Target target, Game game) {
+ logger.info("chooseTarget: " + outcome.toString() + ":" + target.toString());
+ UUID opponentId = game.getOpponents(playerId).get(0);
+ if (target instanceof TargetPlayer) {
+ if (outcome.isGood()) {
+ if (target.canTarget(playerId, game)) {
+ target.addTarget(playerId, game);
+ return true;
+ }
+ }
+ else {
+ if (target.canTarget(playerId, game)) {
+ target.addTarget(opponentId, game);
+ return true;
+ }
+ }
+ }
+ if (target instanceof TargetDiscard) {
+ findPlayables(game);
+ if (unplayable.size() > 0) {
+ for (int i = unplayable.size() - 1; i >= 0; i--) {
+ if (target.canTarget(unplayable.values().toArray(new Card[0])[i].getId(), game)) {
+ target.addTarget(unplayable.values().toArray(new Card[0])[i].getId(), game);
+ return true;
+ }
+ }
+ }
+ if (hand.size() > 0) {
+ if (target.canTarget(hand.keySet().toArray(new UUID[0])[0], game)) {
+ target.addTarget(hand.keySet().toArray(new UUID[0])[0], game);
+ return true;
+ }
+ }
+ }
+ if (target instanceof TargetPermanent) {
+ List targets;
+ if (outcome.isGood()) {
+ targets = threats(playerId, (TargetPermanent) target, game);
+ }
+ else {
+ targets = threats(opponentId, (TargetPermanent) target, game);
+ }
+ for (Permanent permanent: targets) {
+ if (target.canTarget(permanent.getId(), game)) {
+ target.addTarget(permanent.getId(), game);
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public void priority(Game game) {
+ logger.info("priority");
+ if (game.getActivePlayerId().equals(playerId)) {
+ if (game.isMainPhase() && game.getStack().isEmpty()) {
+ playLand(game);
+ }
+ switch (game.getStep()) {
+ case UPKEEP:
+ findPlayables(game);
+ break;
+ case DRAW:
+ logState(game);
+ case DECLARE_BLOCKERS:
+ playRemoval(game.getCombat().getAttackers(), game);
+ case PRECOMBAT_MAIN:
+ findPlayables(game);
+ if (playableAbilities.size() > 0) {
+ for (ActivatedAbility ability: playableAbilities) {
+ if (ability.canActivate(playerId, game)) {
+ if (ability.getEffects().hasOutcome(Outcome.PutLandInPlay)) {
+ if (this.activateAbility(ability, game))
+ return;
+ }
+ }
+ }
+ }
+ break;
+ case POSTCOMBAT_MAIN:
+ findPlayables(game);
+ if (game.getStack().isEmpty()) {
+ if (playableNonInstant.size() > 0) {
+ for (Card card: playableNonInstant) {
+ if (card.getSpellAbility().canActivate(playerId, game)) {
+ if (this.activateAbility(card.getSpellAbility(), game))
+ return;
+ }
+ }
+ }
+ if (playableAbilities.size() > 0) {
+ for (ActivatedAbility ability: playableAbilities) {
+ if (ability.canActivate(playerId, game)) {
+ if (this.activateAbility(ability, game))
+ return;
+ }
+ }
+ }
+ }
+ break;
+ }
+ }
+ else {
+ //respond to opponent events
+ }
+ this.passed = true;
+ }
+
+ private void playLand(Game game) {
+ logger.info("playLand");
+ List lands = hand.getCards(new FilterLandCard());
+ while (lands.size() > 0 && this.landsPlayed < this.landsPerTurn) {
+ if (lands.size() == 1)
+ this.playLand(lands.get(0), game);
+ else {
+ playALand(lands, game);
+ }
+ }
+ }
+
+ private void playALand(List lands, Game game) {
+ logger.info("playALand");
+ //play a land that will allow us to play an unplayable
+ for (Mana mana: unplayable.keySet()) {
+ for (Card card: lands) {
+ for (ManaAbility ability: card.getAbilities().getManaAbilities(Zone.BATTLEFIELD)) {
+ if (ability.getNetMana().enough(mana)) {
+ this.playLand(card, game);
+ lands.remove(card);
+ return;
+ }
+ }
+ }
+ }
+ //play a land that will get us closer to playing an unplayable
+ for (Mana mana: unplayable.keySet()) {
+ for (Card card: lands) {
+ for (ManaAbility ability: card.getAbilities().getManaAbilities(Zone.BATTLEFIELD)) {
+ if (mana.contains(ability.getNetMana())) {
+ this.playLand(card, game);
+ lands.remove(card);
+ return;
+ }
+ }
+ }
+ }
+ //play first available land
+ this.playLand(lands.get(0), game);
+ lands.remove(0);
+ }
+
+ private void findPlayables(Game game) {
+ playableInstant.clear();
+ playableNonInstant.clear();
+ unplayable.clear();
+ playableAbilities.clear();
+ List nonLands = hand.getCards(new FilterNonlandCard());
+ ManaOptions available = getManaAvailable(game);
+ available.addMana(manaPool.getMana());
+
+ for (Card card: nonLands) {
+ ManaOptions options = card.getManaCost().getOptions();
+ if (card.getManaCost().getVariableCosts().size() > 0) {
+ //don't use variable mana costs unless there is at least 3 extra mana for X
+ for (Mana option: options) {
+ option.add(Mana.ColorlessMana(3));
+ }
+ }
+ for (Mana mana: options) {
+ for (Mana avail: available) {
+ if (mana.enough(avail)) {
+ if (card.getCardType().contains(CardType.INSTANT))
+ playableInstant.add(card);
+ else
+ playableNonInstant.add(card);
+ }
+ else {
+ if (!playableInstant.contains(card) && !playableNonInstant.contains(card))
+ unplayable.put(mana.needed(avail), card);
+ }
+ }
+ }
+ }
+ for (Permanent permanent: game.getBattlefield().getActivePermanents(playerId)) {
+ for (ActivatedAbility ability: permanent.getAbilities().getActivatedAbilities(Zone.BATTLEFIELD)) {
+ if (!(ability instanceof ManaAbility) && ability.canActivate(playerId, game)) {
+ ManaOptions abilityOptions = ability.getCosts().getManaCosts().getOptions();
+ if (ability.getCosts().getVariableCosts().size() > 0) {
+ //don't use variable mana costs unless there is at least 3 extra mana for X
+ for (Mana option: abilityOptions) {
+ option.add(Mana.ColorlessMana(3));
+ }
+ }
+ if (abilityOptions.size() == 0) {
+ playableAbilities.add(ability);
+ }
+ else {
+ for (Mana mana: abilityOptions) {
+ for (Mana avail: available) {
+ if (mana.enough(avail)) {
+ playableAbilities.add(ability);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ logger.info("findPlayables: " + playableInstant.toString() + "---" + playableNonInstant.toString() + "---" + playableAbilities.toString() );
+ }
+
+ protected ManaOptions getManaAvailable(Game game) {
+ logger.info("getManaAvailable");
+ List manaPerms = this.getAvailableManaProducers(game);
+
+ ManaOptions available = new ManaOptions();
+ for (Permanent perm: manaPerms) {
+ available.addMana(perm.getAbilities().getManaAbilities(Zone.BATTLEFIELD));
+ }
+ return available;
+ }
+
+ @Override
+ public boolean playMana(ManaCost unpaid, Game game) {
+ logger.info("playMana");
+ ManaCost cost;
+ List producers;
+ if (unpaid instanceof ManaCosts) {
+ cost = ((ManaCosts)unpaid).get(0);
+ producers = getSortedProducers((ManaCosts)unpaid, game);
+ }
+ else {
+ cost = unpaid;
+ producers = this.getAvailableManaProducers(game);
+ }
+ for (Permanent perm: producers) {
+ // pay all colored costs first
+ for (ManaAbility ability: perm.getAbilities().getManaAbilities(Zone.BATTLEFIELD)) {
+ if (cost instanceof ColoredManaCost) {
+ if (cost.testPay(ability.getNetMana())) {
+ if (activateAbility(ability, game))
+ return true;
+ }
+ }
+ }
+ // then pay hybrid
+ for (ManaAbility ability: perm.getAbilities().getManaAbilities(Zone.BATTLEFIELD)) {
+ if (cost instanceof HybridManaCost) {
+ if (cost.testPay(ability.getNetMana())) {
+ if (activateAbility(ability, game))
+ return true;
+ }
+ }
+ }
+ // then pay mono hybrid
+ for (ManaAbility ability: perm.getAbilities().getManaAbilities(Zone.BATTLEFIELD)) {
+ if (cost instanceof MonoHybridManaCost) {
+ if (cost.testPay(ability.getNetMana())) {
+ if (activateAbility(ability, game))
+ return true;
+ }
+ }
+ }
+ // finally pay generic
+ for (ManaAbility ability: perm.getAbilities().getManaAbilities(Zone.BATTLEFIELD)) {
+ if (cost instanceof GenericManaCost) {
+ if (cost.testPay(ability.getNetMana())) {
+ if (activateAbility(ability, game))
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+ }
+
+ private List getSortedProducers(ManaCosts unpaid, Game game) {
+ List unsorted = this.getAvailableManaProducers(game);
+ Map scored = new HashMap();
+ for (Permanent permanent: unsorted) {
+ int score = 0;
+ for (ManaCost cost: unpaid) {
+ for (ManaAbility ability: permanent.getAbilities().getManaAbilities(Zone.BATTLEFIELD)) {
+ if (cost.testPay(ability.getNetMana())) {
+ score++;
+ break;
+ }
+ }
+ }
+ scored.put(permanent, score);
+ }
+ return sortByValue(scored);
+ }
+
+ private List sortByValue(Map map) {
+ List> list = new LinkedList>(map.entrySet());
+ Collections.sort(list, new Comparator>() {
+ @Override
+ public int compare(Entry o1, Entry o2) {
+ return (o1.getValue().compareTo(o2.getValue()));
+ }
+ });
+ List result = new ArrayList();
+ for (Iterator it = list.iterator(); it.hasNext();) {
+ Entry entry = (Entry)it.next();
+ result.add(entry.getKey());
+ }
+ return result;
+ }
+
+ @Override
+ public boolean playXMana(VariableManaCost cost, Game game) {
+ logger.info("playXMana");
+ //put everything into X
+ for (Permanent perm: this.getAvailableManaProducers(game)) {
+ for (ManaAbility ability: perm.getAbilities().getManaAbilities(Zone.BATTLEFIELD)) {
+ if (activateAbility(ability, game))
+ return true;
+ }
+ }
+ cost.setPaid();
+ return true;
+ }
+
+ @Override
+ public void abort() {
+ abort = true;
+ }
+
+ @Override
+ public boolean chooseUse(Outcome outcome, String message, Game game) {
+ logger.info("chooseUse");
+ //TODO: improve ths
+ return outcome.isGood();
+ }
+
+ @Override
+ public boolean choose(Outcome outcome, Choice choice, Game game) {
+ logger.info("choose");
+ //TODO: implement this
+ return false;
+ }
+
+ @Override
+ public boolean searchCards(Cards cards, TargetCard target, Game game) {
+ logger.info("searchCards");
+ //TODO: improve ths
+ //return first match
+ for (Card card: cards.getCards(target.getFilter())) {
+ target.addTarget(card.getId(), game);
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public void selectAttackers(Game game) {
+ logger.info("selectAttackers");
+ UUID opponentId = game.getOpponents(playerId).get(0);
+ Attackers attackers = getAvailableAttackers(game);
+ List blockers = getOpponentBlockers(opponentId, game);
+ List actualAttackers = new ArrayList();
+ if (blockers.isEmpty()) {
+ actualAttackers = attackers.getAttackers();
+ }
+ else if (attackers.size() - blockers.size() >= game.getPlayer(opponentId).getLife()) {
+ actualAttackers = attackers.getAttackers();
+ }
+ else {
+ CombatSimulator combat = simulateAttack(attackers, blockers, opponentId, game);
+ if (combat.rating > 2) {
+ for (CombatGroupSimulator group: combat.groups) {
+ this.declareAttacker(group.attackers.get(0).id, group.defenderId, game);
+ }
+ }
+ }
+ for (Permanent attacker: actualAttackers) {
+ this.declareAttacker(attacker.getId(), opponentId, game);
+ }
+ return;
+ }
+
+ @Override
+ public void selectBlockers(Game game) {
+ logger.info("selectBlockers");
+
+ List blockers = getAvailableBlockers(game);
+
+ CombatSimulator sim = simulateBlock(CombatSimulator.load(game), blockers, game);
+
+ List groups = game.getCombat().getGroups();
+ for (int i = 0; i< groups.size(); i++) {
+ for (CreatureSimulator creature: sim.groups.get(i).blockers) {
+ groups.get(i).addBlocker(creature.id, playerId, game);
+ }
+ }
+ }
+
+ @Override
+ public int chooseEffect(List rEffects, Game game) {
+ logger.info("chooseEffect");
+ //TODO: implement this
+ return 0;
+ }
+
+ @Override
+ public void assignDamage(int damage, List targets, UUID sourceId, Game game) {
+ logger.info("assignDamage");
+ //TODO: improve this
+ game.getPermanent(targets.get(0)).damage(damage, sourceId, game);
+ }
+
+ @Override
+ public int getAmount(int min, int max, String message, Game game) {
+ logger.info("getAmount");
+ //TODO: improve this
+ return min;
+ }
+
+ protected List getAvailableManaProducers(Game game) {
+ logger.info("getAvailableManaProducers");
+ List result = new ArrayList();
+ for (Permanent permanent: game.getBattlefield().getActivePermanents(playerId)) {
+ for (ManaAbility ability: permanent.getAbilities().getManaAbilities(Zone.BATTLEFIELD)) {
+ if (ability.canActivate(playerId, game)) {
+ result.add(permanent);
+ break;
+ }
+ }
+ }
+ return result;
+ }
+
+ protected Attackers getAvailableAttackers(Game game) {
+ logger.info("getAvailableAttackers");
+ FilterCreatureForAttack attackFilter = new FilterCreatureForAttack();
+ attackFilter.getControllerId().add(playerId);
+ Attackers attackers = new Attackers();
+ List creatures = game.getBattlefield().getActivePermanents(attackFilter);
+ for (Permanent creature: creatures) {
+ int potential = combatPotential(creature, game);
+ if (potential > 0) {
+ List l = attackers.get(potential);
+ if (l == null)
+ attackers.put(potential, l = new ArrayList());
+ l.add(creature);
+ }
+ }
+ return attackers;
+ }
+
+ protected int combatPotential(Permanent creature, Game game) {
+ logger.info("combatPotential");
+ if (!creature.canAttack(game))
+ return 0;
+ int potential = creature.getPower().getValue();
+ potential += creature.getAbilities().getEvasionAbilities().size();
+ potential += creature.getAbilities().getProtectionAbilities().size();
+ potential += creature.getAbilities().containsKey(FirstStrikeAbility.getInstance().getId())?1:0;
+ potential += creature.getAbilities().containsKey(DoubleStrikeAbility.getInstance().getId())?2:0;
+ potential += creature.getAbilities().containsKey(TrampleAbility.getInstance().getId())?1:0;
+ return potential;
+ }
+
+ protected List getAvailableBlockers(Game game) {
+ logger.info("getAvailableBlockers");
+ FilterCreatureForCombat blockFilter = new FilterCreatureForCombat();
+ blockFilter.getControllerId().add(playerId);
+ List blockers = game.getBattlefield().getActivePermanents(blockFilter);
+ return blockers;
+ }
+
+ protected List getOpponentBlockers(UUID opponentId, Game game) {
+ logger.info("getOpponentBlockers");
+ FilterCreatureForCombat blockFilter = new FilterCreatureForCombat();
+ blockFilter.getControllerId().add(opponentId);
+ List blockers = game.getBattlefield().getActivePermanents(blockFilter);
+ return blockers;
+ }
+
+ protected CombatSimulator simulateAttack(Attackers attackers, List blockers, UUID opponentId, Game game) {
+ logger.info("simulateAttack");
+ List attackersList = attackers.getAttackers();
+ CombatSimulator best = new CombatSimulator();
+ int bestResult = 0;
+ //use binary digits to calculate powerset of attackers
+ int powerElements = (int) Math.pow(2, attackersList.size());
+ for (int i = 1; i < powerElements; i++) {
+ String binary = Integer.toBinaryString(i);
+ while(binary.length() < attackersList.size()) {
+ binary = "0" + binary;
+ }
+ List trialAttackers = new ArrayList();
+ for (int j = 0; j < attackersList.size(); j++) {
+ if (binary.charAt(j) == '1')
+ trialAttackers.add(attackersList.get(j));
+ }
+ CombatSimulator combat = new CombatSimulator();
+ for (Permanent permanent: trialAttackers) {
+ combat.groups.add(new CombatGroupSimulator(opponentId, Arrays.asList(permanent.getId()), new ArrayList(), game));
+ }
+ CombatSimulator test = simulateBlock(combat, blockers, game);
+ if (test.evaluate() > bestResult) {
+ best = test;
+ bestResult = test.evaluate();
+ }
+ }
+
+ return best;
+ }
+
+ protected CombatSimulator simulateBlock(CombatSimulator combat, List blockers, Game game) {
+ logger.info("simulateBlock");
+
+ TreeNode simulations;
+
+ simulations = new TreeNode(combat);
+ addBlockSimulations(blockers, simulations, game);
+ combat.simulate();
+
+ return getWorstSimulation(simulations);
+
+ }
+
+ protected void addBlockSimulations(List blockers, TreeNode node, Game game) {
+ int numGroups = node.getData().groups.size();
+ Copier copier = new Copier();
+ for (Permanent blocker: blockers) {
+ List subList = remove(blockers, blocker);
+ for (int i = 0; i < numGroups; i++) {
+ if (node.getData().groups.get(i).canBlock(blocker, game)) {
+ CombatSimulator combat = copier.copy(node.getData());
+ combat.groups.get(i).blockers.add(new CreatureSimulator(blocker));
+ TreeNode child = new TreeNode(combat);
+ node.addChild(child);
+ addBlockSimulations(subList, child, game);
+ combat.simulate();
+ }
+ }
+ }
+ }
+
+ protected List remove(List source, Permanent element) {
+ List newList = new ArrayList();
+ for (Permanent permanent: source) {
+ if (!permanent.equals(element)) {
+ newList.add(permanent);
+ }
+ }
+ return newList;
+ }
+
+ protected CombatSimulator getBestSimulation(TreeNode simulations) {
+ CombatSimulator best = simulations.getData();
+ int bestResult = best.evaluate();
+ for (TreeNode node: simulations.getChildren()) {
+ CombatSimulator bestSub = getBestSimulation(node);
+ if (bestSub.evaluate() > bestResult) {
+ best = node.getData();
+ bestResult = best.evaluate();
+ }
+ }
+ return best;
+ }
+
+ protected CombatSimulator getWorstSimulation(TreeNode simulations) {
+ CombatSimulator worst = simulations.getData();
+ int worstResult = worst.evaluate();
+ for (TreeNode node: simulations.getChildren()) {
+ CombatSimulator worstSub = getWorstSimulation(node);
+ if (worstSub.evaluate() < worstResult) {
+ worst = node.getData();
+ worstResult = worst.evaluate();
+ }
+ }
+ return worst;
+ }
+
+ protected List threats(UUID playerId, TargetPermanent target, Game game) {
+ List threats = game.getBattlefield().getActivePermanents(target.getFilter());
+ Iterator it = threats.iterator();
+ while(it.hasNext()) {
+ Permanent permanent = it.next();
+ if (!permanent.getControllerId().equals(playerId)) {
+ it.remove();
+ }
+ }
+
+ Collections.sort(threats, new PermanentComparator(game));
+ return threats;
+ }
+
+ private void logState(Game game) {
+ StringBuilder sb = new StringBuilder();
+ sb.append("computer player hand: ");
+ for (Card card: hand.values()) {
+ sb.append(card.getName());
+ sb.append(",");
+ }
+ logger.info(sb.toString());
+ }
+
+ private void playRemoval(List attackers, Game game) {
+ for (UUID attackerId: attackers) {
+ for (Card card: this.playableInstant) {
+ if (card.getSpellAbility().canActivate(playerId, game)) {
+ for (Effect effect: card.getSpellAbility().getEffects()) {
+ if (effect.getOutcome().equals(Outcome.DestroyPermanent) || effect.getOutcome().equals(Outcome.Damage)) {
+ if (card.getSpellAbility().getTargets().get(0).canTarget(attackerId, game)) {
+
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ protected int evaluateState(GameState state, Game game) {
+ int value = life;
+ Player opponent = game.getPlayer(game.getOpponents(playerId).get(0));
+ if (opponent.getLife() <= 0)
+ return Integer.MAX_VALUE;
+ value -= opponent.getLife();
+ for (Permanent permanent: state.getBattlefield().getAllPermanents()) {
+
+ }
+ return value;
+ }
+}
+