AIPlayer.java removed

.gitattributes

@@ -14239,7 +14239,6 @@ src/main/java/forge/game/phase/PhaseUtil.java svneol=native#text/plain
 src/main/java/forge/game/phase/Untap.java -text
 src/main/java/forge/game/phase/Upkeep.java svneol=native#text/plain
 src/main/java/forge/game/phase/package-info.java svneol=native#text/plain
-src/main/java/forge/game/player/AIPlayer.java svneol=native#text/plain
 src/main/java/forge/game/player/GameLossReason.java -text
 src/main/java/forge/game/player/HumanPlay.java -text
 src/main/java/forge/game/player/LobbyPlayer.java -text

src/main/java/forge/card/ability/AbilityApiBased.java

@@ -12,7 +12,7 @@ import forge.card.cost.Cost;
 import forge.card.spellability.AbilityActivated;
 import forge.card.spellability.AbilityManaPart;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class AbilityApiBased extends AbilityActivated {
     private final SpellAbilityEffect effect;
@@ -64,11 +64,11 @@ public class AbilityApiBased extends AbilityActivated {
 
     @Override
     public boolean canPlayAI() {
-        return ai.canPlayAIWithSubs((AIPlayer)getActivatingPlayer(), this);
+        return ai.canPlayAIWithSubs(getActivatingPlayer(), this);
     }
 
     @Override
-    public boolean doTrigger(final boolean mandatory, AIPlayer aiPlayer) {
+    public boolean doTrigger(final boolean mandatory, Player aiPlayer) {
         return ai.doTriggerAI(aiPlayer, this, mandatory);
     }
 }

src/main/java/forge/card/ability/AbilityUtils.java

@@ -25,7 +25,6 @@ import forge.game.GameActionUtil;
 import forge.game.GameState;
 import forge.game.ai.ComputerUtil;
 import forge.game.ai.ComputerUtilCost;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.Expressions;
@@ -1109,7 +1108,7 @@ public class AbilityUtils {
             ability.setActivatingPlayer(payer);
             if (payer.isComputer()) {
                 if (ComputerUtilCost.willPayUnlessCost(sa, payer, ability, paid, payers)) {
-                    ComputerUtil.playNoStack((AIPlayer) payer, ability, game); // Unless cost was payed - no resolve
+                    ComputerUtil.playNoStack(payer, ability, game); // Unless cost was payed - no resolve
                     paid = true;
                 }
             } else {

src/main/java/forge/card/ability/SpellAbilityAi.java

@@ -6,12 +6,11 @@ import forge.card.spellability.SpellAbility;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 
 public abstract class SpellAbilityAi {
 
-    public final boolean canPlayAIWithSubs(final AIPlayer aiPlayer, final SpellAbility sa) {
+    public final boolean canPlayAIWithSubs(final Player aiPlayer, final SpellAbility sa) {
         if (!canPlayAI(aiPlayer, sa)) {
             return false;
         }
@@ -19,9 +18,9 @@ public abstract class SpellAbilityAi {
         return subAb == null || chkDrawbackWithSubs(aiPlayer,  subAb);
     }
 
-    protected abstract boolean canPlayAI(final AIPlayer aiPlayer, final SpellAbility sa);
+    protected abstract boolean canPlayAI(final Player aiPlayer, final SpellAbility sa);
 
-    public final boolean doTriggerAI(final AIPlayer aiPlayer, final SpellAbility sa, final boolean mandatory) {
+    public final boolean doTriggerAI(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
         if (!ComputerUtilCost.canPayCost(sa, aiPlayer) && !mandatory) {
             return false;
         }
@@ -29,7 +28,7 @@ public abstract class SpellAbilityAi {
         return doTriggerNoCostWithSubs(aiPlayer, sa, mandatory);
     }
 
-    public final boolean doTriggerNoCostWithSubs(final AIPlayer aiPlayer, final SpellAbility sa, final boolean mandatory)
+    public final boolean doTriggerNoCostWithSubs(final Player aiPlayer, final SpellAbility sa, final boolean mandatory)
     {
         if (!doTriggerAINoCost(aiPlayer, sa, mandatory)) {
             return false;
@@ -38,11 +37,11 @@ public abstract class SpellAbilityAi {
         return subAb == null || chkDrawbackWithSubs(aiPlayer,  subAb) || mandatory;
     }
 
-    protected boolean doTriggerAINoCost(final AIPlayer aiPlayer, final SpellAbility sa, final boolean mandatory) {
+    protected boolean doTriggerAINoCost(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
         return canPlayAI(aiPlayer, sa) || mandatory;
     }
 
-    public boolean chkAIDrawback(final SpellAbility sa, final AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(final SpellAbility sa, final Player aiPlayer) {
         return true;
     }
 
@@ -100,7 +99,7 @@ public abstract class SpellAbilityAi {
      * @param subAb
      * @return
      */
-    public boolean chkDrawbackWithSubs(AIPlayer aiPlayer, AbilitySub ab) {
+    public boolean chkDrawbackWithSubs(Player aiPlayer, AbilitySub ab) {
         final AbilitySub subAb = ab.getSubAbility();
         return ab.getAi().chkAIDrawback(ab, aiPlayer) && (subAb == null || chkDrawbackWithSubs(aiPlayer, subAb));  
     }

src/main/java/forge/card/ability/SpellApiBased.java

@@ -11,7 +11,6 @@ import forge.card.cost.Cost;
 import forge.card.spellability.AbilityManaPart;
 import forge.card.spellability.Spell;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
 
 public class SpellApiBased extends Spell {
     private static final long serialVersionUID = -6741797239508483250L;
@@ -47,7 +46,7 @@ public class SpellApiBased extends Spell {
 
     @Override
     public boolean canPlayAI() {
-        return ai.canPlayAIWithSubs((AIPlayer) getActivatingPlayer(), this) && super.canPlayAI();
+        return ai.canPlayAIWithSubs(getActivatingPlayer(), this) && super.canPlayAI();
     }
 
     @Override
@@ -59,9 +58,9 @@ public class SpellApiBased extends Spell {
     public boolean canPlayFromEffectAI(final boolean mandatory, final boolean withOutManaCost) {
         boolean chance = false;
         if (withOutManaCost) {
-            chance = ai.doTriggerNoCostWithSubs((AIPlayer)this.getActivatingPlayer(), this, mandatory);
+            chance = ai.doTriggerNoCostWithSubs(this.getActivatingPlayer(), this, mandatory);
         }
-        chance = ai.doTriggerAI((AIPlayer)this.getActivatingPlayer(), this, mandatory);
+        chance = ai.doTriggerAI(this.getActivatingPlayer(), this, mandatory);
         return chance && super.canPlayAI();
     }
 }

src/main/java/forge/card/ability/ai/AddPhaseAi.java

@@ -2,7 +2,7 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 /** 
  * TODO: Write javadoc for this type.
@@ -11,7 +11,7 @@ import forge.game.player.AIPlayer;
 public class AddPhaseAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         return false;
     }
 

src/main/java/forge/card/ability/ai/AddTurnAi.java

@@ -23,7 +23,6 @@ import forge.card.ability.AbilityUtils;
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 
 /**
@@ -38,7 +37,7 @@ public class AddTurnAi extends SpellAbilityAi {
 
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Player opp = ai.getWeakestOpponent();
         final Target tgt = sa.getTarget();
 
@@ -76,7 +75,7 @@ public class AddTurnAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         return doTriggerAINoCost(aiPlayer, sa, false);
     }
 

src/main/java/forge/card/ability/ai/AlwaysPlayAi.java

@@ -3,14 +3,14 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class AlwaysPlayAi extends SpellAbilityAi {
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         return true;
     }
 }

src/main/java/forge/card/ability/ai/AnimateAi.java

@@ -12,7 +12,6 @@ import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.GameState;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -31,7 +30,7 @@ public class AnimateAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         final Target tgt = sa.getTarget();
         final Card source = sa.getSourceCard();
         final GameState game = aiPlayer.getGame();
@@ -125,7 +124,7 @@ public class AnimateAi extends SpellAbilityAi {
     // end animateCanPlayAI()
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         if (sa.getTarget() != null) {
             sa.getTarget().resetTargets();
             if (!animateTgtAI(sa)) {
@@ -150,7 +149,7 @@ public class AnimateAi extends SpellAbilityAi {
      * @return a boolean.
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
 
         if (sa.getTarget() != null && !animateTgtAI(sa) && !mandatory) {
             return false;

src/main/java/forge/card/ability/ai/AnimateAllAi.java

@@ -2,17 +2,17 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class AnimateAllAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         return false;
     } // end animateAllCanPlayAI()
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         return false;
     }
 

src/main/java/forge/card/ability/ai/AttachAi.java

@@ -28,7 +28,6 @@ import forge.game.ai.ComputerUtilMana;
 import forge.game.phase.CombatUtil;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
@@ -39,7 +38,7 @@ public class AttachAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Random r = MyRandom.getRandom();
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getSourceCard();
@@ -607,7 +606,7 @@ public class AttachAi extends SpellAbilityAi {
      * @return true, if successful
      */
     @Override
-    protected boolean doTriggerAINoCost(final AIPlayer ai, final SpellAbility sa, final boolean mandatory) {
+    protected boolean doTriggerAINoCost(final Player ai, final SpellAbility sa, final boolean mandatory) {
         final Card card = sa.getSourceCard();
         // Check if there are any valid targets
         ArrayList<Object> targets = new ArrayList<Object>();

src/main/java/forge/card/ability/ai/BecomesBlockedAi.java

@@ -11,13 +11,13 @@ import forge.card.spellability.Target;
 import forge.game.GameState;
 import forge.game.ai.ComputerUtilCard;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
 public class BecomesBlockedAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         final Card source = sa.getSourceCard();
         final Target tgt = sa.getTarget();
         final GameState game = aiPlayer.getGame();
@@ -52,7 +52,7 @@ public class BecomesBlockedAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
 
         // TODO - implement AI
         return false;
@@ -62,7 +62,7 @@ public class BecomesBlockedAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         boolean chance;
 
         // TODO - implement AI

src/main/java/forge/card/ability/ai/BondAi.java

@@ -19,7 +19,7 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 /**
  * <p>
@@ -42,7 +42,7 @@ public final class BondAi extends SpellAbilityAi {
      * @return a boolean.
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         return true;
     } // end bondCanPlayAI()
 }

src/main/java/forge/card/ability/ai/CanPlayAsDrawbackAi.java

@@ -3,7 +3,7 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class CanPlayAsDrawbackAi extends SpellAbilityAi {
 
@@ -11,7 +11,7 @@ public class CanPlayAsDrawbackAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         return false;
     }
 
@@ -29,7 +29,7 @@ public class CanPlayAsDrawbackAi extends SpellAbilityAi {
      * @return a boolean.
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         return false;
     }
 

src/main/java/forge/card/ability/ai/CannotPlayAi.java

@@ -3,14 +3,14 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class CannotPlayAi extends SpellAbilityAi {
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         return false;
     }
 
@@ -18,7 +18,7 @@ public class CannotPlayAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#chkAIDrawback(java.util.Map, forge.card.spellability.SpellAbility, forge.game.player.Player)
      */
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         return canPlayAI(aiPlayer, sa);
     }
 }

src/main/java/forge/card/ability/ai/ChangeZoneAi.java

@@ -37,7 +37,6 @@ import forge.game.ai.ComputerUtilCost;
 import forge.game.ai.ComputerUtilMana;
 import forge.game.phase.Combat;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.gui.GuiChoose;
@@ -58,7 +57,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
      * @return a boolean.
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         String origin = null;
         if (sa.hasParam("Origin")) {
             origin = sa.getParam("Origin");
@@ -88,7 +87,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
      * @return a boolean.
      */
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         String origin = null;
         if (sa.hasParam("Origin")) {
             origin = sa.getParam("Origin");
@@ -116,7 +115,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
      * @return a boolean.
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         String origin = null;
         if (sa.hasParam("Origin")) {
             origin = sa.getParam("Origin");
@@ -152,7 +151,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
      *            a {@link forge.card.spellability.SpellAbility} object.
      * @return a boolean.
      */
-    private static boolean hiddenOriginCanPlayAI(final AIPlayer ai, final SpellAbility sa) {
+    private static boolean hiddenOriginCanPlayAI(final Player ai, final SpellAbility sa) {
         // Fetching should occur fairly often as it helps cast more spells, and
         // have access to more mana
         final Cost abCost = sa.getPayCosts();
@@ -535,7 +534,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
      *            a {@link forge.card.spellability.SpellAbility} object.
      * @return a boolean.
      */
-    private static boolean knownOriginCanPlayAI(final AIPlayer ai, final SpellAbility sa) {
+    private static boolean knownOriginCanPlayAI(final Player ai, final SpellAbility sa) {
         // Retrieve either this card, or target Cards in Graveyard
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getSourceCard();
@@ -650,7 +649,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
      *            a {@link forge.card.spellability.SpellAbility} object.
      * @return a boolean.
      */
-    private static boolean knownOriginPlayDrawbackAI(final AIPlayer aiPlayer, final SpellAbility sa) {
+    private static boolean knownOriginPlayDrawbackAI(final Player aiPlayer, final SpellAbility sa) {
         if (sa.getTarget() == null) {
             return true;
         }
@@ -671,7 +670,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
      *            a boolean.
      * @return a boolean.
      */
-    private static boolean isPreferredTarget(final AIPlayer ai, final SpellAbility sa, final boolean mandatory) {
+    private static boolean isPreferredTarget(final Player ai, final SpellAbility sa, final boolean mandatory) {
         final Card source = sa.getSourceCard();
         final ZoneType origin = ZoneType.listValueOf(sa.getParam("Origin")).get(0);
         final ZoneType destination = ZoneType.smartValueOf(sa.getParam("Destination"));
@@ -1029,7 +1028,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
      *            a boolean.
      * @return a boolean.
      */
-    private static boolean knownOriginTriggerAI(final AIPlayer ai, final SpellAbility sa,
+    private static boolean knownOriginTriggerAI(final Player ai, final SpellAbility sa,
             final boolean mandatory) {
 
         if (sa.getTarget() == null) {

src/main/java/forge/card/ability/ai/ChangeZoneAllAi.java

@@ -13,7 +13,6 @@ import forge.card.spellability.Target;
 import forge.game.ai.ComputerUtilCard;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
@@ -24,7 +23,7 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         // Change Zone All, can be any type moving from one zone to another
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getSourceCard();
@@ -167,7 +166,7 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
      * @return a boolean.
      */
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         // if putting cards from hand to library and parent is drawing cards
         // make sure this will actually do something:
 
@@ -176,7 +175,7 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
 
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         // Change Zone All, can be any type moving from one zone to another
 
         final ZoneType destination = ZoneType.smartValueOf(sa.getParam("Destination"));

src/main/java/forge/card/ability/ai/CharmAi.java

@@ -10,14 +10,13 @@ import forge.card.ability.SpellAbilityAi;
 import forge.card.ability.effects.CharmEffect;
 import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.util.MyRandom;
 
 public class CharmAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Random r = MyRandom.getRandom();
 
         final int num = Integer.parseInt(sa.hasParam("CharmNum") ? sa.getParam("CharmNum") : "1");
@@ -35,7 +34,7 @@ public class CharmAi extends SpellAbilityAi {
         return r.nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
     }
 
-    public static List<AbilitySub> chooseOptionsAi(final AIPlayer ai, boolean playNow, List<AbilitySub> choices, int num, int min, boolean opponentChoser) {
+    public static List<AbilitySub> chooseOptionsAi(final Player ai, boolean playNow, List<AbilitySub> choices, int num, int min, boolean opponentChoser) {
         List<AbilitySub> chosenList = new ArrayList<AbilitySub>();
 
         if (opponentChoser) {
@@ -69,7 +68,7 @@ public class CharmAi extends SpellAbilityAi {
         return chosenList.size() >= min ? chosenList : null;
     }
     
-    public static Player determineOpponentChooser(AIPlayer ai, SpellAbility sa, List<Player> opponents) {
+    public static Player determineOpponentChooser(Player ai, SpellAbility sa, List<Player> opponents) {
         return opponents.get(RandomUtils.nextInt(opponents.size()));
     }
     

src/main/java/forge/card/ability/ai/ChooseCardAi.java

@@ -7,7 +7,7 @@ import forge.CardLists;
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
 public class ChooseCardAi extends SpellAbilityAi {
@@ -16,7 +16,7 @@ public class ChooseCardAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Card host = sa.getSourceCard();
 
         final Target tgt = sa.getTarget();
@@ -62,7 +62,7 @@ public class ChooseCardAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         return canPlayAI(ai, sa);
     }
 }

src/main/java/forge/card/ability/ai/ChooseCardNameAi.java

@@ -6,12 +6,12 @@ import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.ai.ComputerUtil;
 import forge.game.ai.ComputerUtilMana;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class ChooseCardNameAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         Card source = sa.getSourceCard();
         if (sa.hasParam("AILogic")) {
             // Don't tap creatures that may be able to block
@@ -58,7 +58,7 @@ public class ChooseCardNameAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         // TODO - there is no AILogic implemented yet
         return false;
     }

src/main/java/forge/card/ability/ai/ChooseColorAi.java

@@ -2,13 +2,13 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.util.MyRandom;
 
 public class ChooseColorAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         if (!sa.hasParam("AILogic")) {
             return false;
         }
@@ -17,7 +17,7 @@ public class ChooseColorAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         return mandatory || canPlayAI(ai, sa);
     }
 

src/main/java/forge/card/ability/ai/ChoosePlayerAi.java

@@ -2,7 +2,7 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class ChoosePlayerAi extends SpellAbilityAi {
 
@@ -10,17 +10,17 @@ public class ChoosePlayerAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         return true;
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         return canPlayAI(ai, sa);
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         return canPlayAI(ai, sa);
     }
 

src/main/java/forge/card/ability/ai/ChooseSourceAi.java

@@ -17,7 +17,7 @@ import forge.game.GameState;
 import forge.game.ai.ComputerUtilCombat;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
 public class ChooseSourceAi extends SpellAbilityAi {
@@ -26,7 +26,7 @@ public class ChooseSourceAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(final AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(final Player ai, SpellAbility sa) {
         // TODO: AI Support! Currently this is copied from AF ChooseCard.
         //       When implementing AI, I believe AI also needs to be made aware of the damage sources chosen
         //       to be prevented (e.g. so the AI doesn't attack with a creature that will not deal any damage

src/main/java/forge/card/ability/ai/ChooseTypeAi.java

@@ -4,12 +4,11 @@ import forge.card.ability.AbilityUtils;
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 
 public class ChooseTypeAi extends SpellAbilityAi {
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         if (!sa.hasParam("AILogic")) {
             return false;
         }
@@ -18,7 +17,7 @@ public class ChooseTypeAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Target tgt = sa.getTarget();
 
         if (sa.getTarget() != null) {

src/main/java/forge/card/ability/ai/ClashAi.java

@@ -4,7 +4,6 @@ package forge.card.ability.ai;
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 
 public class ClashAi extends SpellAbilityAi {
@@ -13,7 +12,7 @@ public class ClashAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         return true;
     }
 
@@ -21,7 +20,7 @@ public class ClashAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Target tgt = sa.getTarget();
         final Player opp = ai.getOpponent();
         if (tgt != null) {

src/main/java/forge/card/ability/ai/CloneAi.java

@@ -10,12 +10,12 @@ import forge.card.spellability.Target;
 import forge.game.GameState;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class CloneAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Target tgt = sa.getTarget();
         final Card source = sa.getSourceCard();
         final GameState game = source.getGame();
@@ -93,7 +93,7 @@ public class CloneAi extends SpellAbilityAi {
     } // end cloneCanPlayAI()
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         // AI should only activate this during Human's turn
         boolean chance = true;
 
@@ -106,7 +106,7 @@ public class CloneAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
 
         boolean chance = true;
 

src/main/java/forge/card/ability/ai/ControlExchangeAi.java

@@ -12,7 +12,7 @@ import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.ai.ComputerUtilCard;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
@@ -22,7 +22,7 @@ public class ControlExchangeAi extends SpellAbilityAi {
  * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
  */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, final SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, final SpellAbility sa) {
         Card object1 = null;
         Card object2 = null;
         final Target tgt = sa.getTarget();
@@ -62,7 +62,7 @@ public class ControlExchangeAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         return false;
     }
 }

src/main/java/forge/card/ability/ai/ControlGainAi.java

@@ -32,7 +32,6 @@ import forge.card.spellability.Target;
 import forge.game.GameState;
 import forge.game.ai.ComputerUtilCard;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -62,7 +61,7 @@ import forge.game.zone.ZoneType;
  */
 public class ControlGainAi extends SpellAbilityAi {
     @Override
-    protected boolean canPlayAI(AIPlayer ai, final SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, final SpellAbility sa) {
         boolean hasCreature = false;
         boolean hasArtifact = false;
         boolean hasEnchantment = false;
@@ -170,7 +169,7 @@ public class ControlGainAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         if (sa.getTarget() == null) {
             if (mandatory) {
                 return true;
@@ -183,7 +182,7 @@ public class ControlGainAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, final AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, final Player ai) {
         final GameState game = ai.getGame();
         if ((sa.getTarget() == null) || !sa.getTarget().doesTarget()) {
             if (sa.hasParam("AllValid")) {

src/main/java/forge/card/ability/ai/CopyPermanentAi.java

@@ -14,7 +14,7 @@ import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.ai.ComputerUtilCard;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
@@ -24,7 +24,7 @@ public class CopyPermanentAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         // Card source = sa.getSourceCard();
         // TODO - I'm sure someone can do this AI better
 
@@ -46,7 +46,7 @@ public class CopyPermanentAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(final AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(final Player aiPlayer, SpellAbility sa, boolean mandatory) {
         final Card source = sa.getSourceCard();
 
         // ////

src/main/java/forge/card/ability/ai/CounterAi.java

@@ -11,13 +11,13 @@ import forge.game.GameState;
 import forge.game.ai.ComputerUtilCard;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.ai.ComputerUtilMana;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.util.MyRandom;
 
 public class CounterAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         boolean toReturn = true;
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getSourceCard();
@@ -102,12 +102,12 @@ public class CounterAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         return doTriggerAINoCost(aiPlayer, sa, true);
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
 
         final Target tgt = sa.getTarget();
         if (tgt != null) {

src/main/java/forge/card/ability/ai/CountersMoveAi.java

@@ -11,7 +11,6 @@ import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.ai.ComputerUtilCard;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
@@ -19,7 +18,7 @@ import forge.util.MyRandom;
 
 public class CountersMoveAi extends SpellAbilityAi {
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         // AI needs to be expanded, since this function can be pretty complex
         // based on what
         // the expected targets could be
@@ -47,7 +46,7 @@ public class CountersMoveAi extends SpellAbilityAi {
     } // moveCounterCanPlayAI
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Card host = sa.getSourceCard();
         final Target abTgt = sa.getTarget();
         final String type = sa.getParam("CounterType");

src/main/java/forge/card/ability/ai/CountersProliferateAi.java

@@ -9,13 +9,13 @@ import forge.CardLists;
 import forge.CounterType;
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
 public class CountersProliferateAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         boolean chance = true;
 
         List<Card> cperms = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), new Predicate<Card>() {
@@ -49,7 +49,7 @@ public class CountersProliferateAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         boolean chance = true;
 
         // TODO Make sure Human has poison counters or there are some counters
@@ -61,7 +61,7 @@ public class CountersProliferateAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#chkAIDrawback(java.util.Map, forge.card.spellability.SpellAbility, forge.game.player.Player)
      */
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         return canPlayAI(ai, sa);
     }
 

src/main/java/forge/card/ability/ai/CountersPutAi.java

@@ -19,7 +19,6 @@ import forge.game.ai.ComputerUtilCard;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.ai.ComputerUtilMana;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
@@ -27,7 +26,7 @@ import forge.util.MyRandom;
 
 public class CountersPutAi extends SpellAbilityAi {
     @Override
-    protected boolean canPlayAI(AIPlayer ai, final SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, final SpellAbility sa) {
         // AI needs to be expanded, since this function can be pretty complex
         // based on
         // what the expected targets could be
@@ -172,7 +171,7 @@ public class CountersPutAi extends SpellAbilityAi {
     } // putCanPlayAI
 
     @Override
-    public boolean chkAIDrawback(final SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(final SpellAbility sa, Player ai) {
         boolean chance = true;
         final Target abTgt = sa.getTarget();
         final Card source = sa.getSourceCard();
@@ -240,7 +239,7 @@ public class CountersPutAi extends SpellAbilityAi {
     } // putPlayDrawbackAI
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Target abTgt = sa.getTarget();
         final Card source = sa.getSourceCard();
         // boolean chance = true;

src/main/java/forge/card/ability/ai/CountersPutAllAi.java

@@ -17,14 +17,13 @@ import forge.game.ai.ComputerUtilCost;
 import forge.game.ai.ComputerUtilMana;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
 public class CountersPutAllAi extends SpellAbilityAi {
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         // AI needs to be expanded, since this function can be pretty complex
         // based on what
         // the expected targets could be
@@ -131,7 +130,7 @@ public class CountersPutAllAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         return canPlayAI(ai, sa);
     }
 }

src/main/java/forge/card/ability/ai/CountersRemoveAi.java

@@ -10,13 +10,13 @@ import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.util.MyRandom;
 
 public class CountersRemoveAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         // AI needs to be expanded, since this function can be pretty complex
         // based on what
         // the expected targets could be
@@ -82,7 +82,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         // AI needs to be expanded, since this function can be pretty complex
         // based on what the
         // expected targets could be

src/main/java/forge/card/ability/ai/DamageAllAi.java

@@ -17,7 +17,6 @@ import forge.game.ai.ComputerUtilCard;
 import forge.game.ai.ComputerUtilCombat;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.ai.ComputerUtilMana;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
@@ -25,7 +24,7 @@ import forge.util.MyRandom;
 public class  DamageAllAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         // AI needs to be expanded, since this function can be pretty complex
         // based on what the expected targets could be
         final Random r = MyRandom.getRandom();
@@ -104,7 +103,7 @@ public class  DamageAllAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         final Card source = sa.getSourceCard();
         String validP = "";
 
@@ -188,7 +187,7 @@ public class  DamageAllAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Card source = sa.getSourceCard();
         String validP = "";
 

src/main/java/forge/card/ability/ai/DamageDealAi.java

@@ -22,14 +22,13 @@ import forge.game.ai.ComputerUtilCost;
 import forge.game.ai.ComputerUtilMana;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
 public class DamageDealAi extends DamageAiBase {
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         final String damage = sa.getParam("NumDmg");
         int dmg = AbilityUtils.calculateAmount(sa.getSourceCard(), damage, sa);
 
@@ -47,7 +46,7 @@ public class DamageDealAi extends DamageAiBase {
     }
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
 
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getSourceCard();
@@ -204,7 +203,7 @@ public class DamageDealAi extends DamageAiBase {
      *            a int.
      * @return a boolean.
      */
-    private boolean damageTargetAI(final AIPlayer ai, final SpellAbility saMe, final int dmg) {
+    private boolean damageTargetAI(final Player ai, final SpellAbility saMe, final int dmg) {
         final Target tgt = saMe.getTarget();
 
         if (tgt == null) {
@@ -354,7 +353,7 @@ public class DamageDealAi extends DamageAiBase {
      *            a int.
      * @return a boolean.
      */
-    private boolean damageChooseNontargeted(AIPlayer ai, final SpellAbility saMe, final int dmg) {
+    private boolean damageChooseNontargeted(Player ai, final SpellAbility saMe, final int dmg) {
         // TODO: Improve circumstances where the Defined Damage is unwanted
         final ArrayList<Object> objects = AbilityUtils.getDefinedObjects(saMe.getSourceCard(), saMe.getParam("Defined"), saMe);
         boolean urgent = false; // can it wait?
@@ -451,7 +450,7 @@ public class DamageDealAi extends DamageAiBase {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
 
         final Card source = sa.getSourceCard();
         final String damage = sa.getParam("NumDmg");

src/main/java/forge/card/ability/ai/DamageEachAi.java

@@ -4,7 +4,7 @@ package forge.card.ability.ai;
 import forge.card.ability.AbilityUtils;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class DamageEachAi extends DamageAiBase {
 
@@ -12,7 +12,7 @@ public class DamageEachAi extends DamageAiBase {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Target tgt = sa.getTarget();
 
         if (tgt != null && sa.canTarget(ai.getOpponent())) {
@@ -26,7 +26,7 @@ public class DamageEachAi extends DamageAiBase {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         // check AI life before playing this drawback?
         return true;
     }
@@ -35,7 +35,7 @@ public class DamageEachAi extends DamageAiBase {
      * @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
 
         return canPlayAI(ai, sa);
     }

src/main/java/forge/card/ability/ai/DamagePreventAi.java

@@ -18,14 +18,13 @@ import forge.game.ai.ComputerUtilCombat;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
 public class DamagePreventAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Card hostCard = sa.getSourceCard();
         final GameState game = ai.getGame();
         boolean chance = false;
@@ -150,7 +149,7 @@ public class DamagePreventAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         boolean chance = false;
         final Target tgt = sa.getTarget();
         if (tgt == null) {

src/main/java/forge/card/ability/ai/DamagePreventAllAi.java

@@ -7,7 +7,7 @@ import forge.card.cost.Cost;
 import forge.card.spellability.SpellAbility;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class DamagePreventAllAi extends SpellAbilityAi {
 
@@ -15,7 +15,7 @@ public class DamagePreventAllAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Card hostCard = sa.getSourceCard();
         boolean chance = false;
 
@@ -51,7 +51,7 @@ public class DamagePreventAllAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         boolean chance = true;
 
         return chance;

src/main/java/forge/card/ability/ai/DebuffAi.java

@@ -18,7 +18,6 @@ import forge.game.ai.ComputerUtilCard;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -28,7 +27,7 @@ public class DebuffAi extends SpellAbilityAi {
     // *************************************************************************
 
     @Override
-    protected boolean canPlayAI(final AIPlayer ai, final SpellAbility sa) {
+    protected boolean canPlayAI(final Player ai, final SpellAbility sa) {
         // if there is no target and host card isn't in play, don't activate
         final Card source = sa.getSourceCard();
         if ((sa.getTarget() == null) && !source.isInPlay()) {
@@ -97,7 +96,7 @@ public class DebuffAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         if ((sa.getTarget() == null) || !sa.getTarget().doesTarget()) {
             // TODO - copied from AF_Pump.pumpDrawbackAI() - what should be
             // here?
@@ -279,7 +278,7 @@ public class DebuffAi extends SpellAbilityAi {
     } // pumpMandatoryTarget()
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final List<String> kws = sa.hasParam("Keywords") ? Arrays.asList(sa.getParam("Keywords").split(" & ")) : new ArrayList<String>();
 
         if (sa.getTarget() == null) {

src/main/java/forge/card/ability/ai/DebuffAllAi.java

@@ -11,14 +11,13 @@ import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.game.phase.CombatUtil;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
 public class DebuffAllAi extends SpellAbilityAi {
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         String valid = "";
         final Random r = MyRandom.getRandom();
         // final Card source = sa.getSourceCard();
@@ -60,7 +59,7 @@ public class DebuffAllAi extends SpellAbilityAi {
     } // debuffAllCanPlayAI()
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         return true;
     }
 }

src/main/java/forge/card/ability/ai/DelayedTriggerAi.java

@@ -4,12 +4,12 @@ import forge.card.ability.AbilityFactory;
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class DelayedTriggerAi extends SpellAbilityAi {
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         final String svarName = sa.getParam("Execute");
         final SpellAbility trigsa = AbilityFactory.getAbility(sa.getSourceCard().getSVar(svarName), sa.getSourceCard());
         trigsa.setActivatingPlayer(ai);
@@ -22,7 +22,7 @@ public class DelayedTriggerAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final String svarName = sa.getParam("Execute");
         final SpellAbility trigsa = AbilityFactory.getAbility(sa.getSourceCard().getSVar(svarName), sa.getSourceCard());
         trigsa.setActivatingPlayer(ai);
@@ -35,7 +35,7 @@ public class DelayedTriggerAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final String svarName = sa.getParam("Execute");
         final SpellAbility trigsa = AbilityFactory.getAbility(sa.getSourceCard().getSVar(svarName), sa.getSourceCard());
         trigsa.setActivatingPlayer(ai);

src/main/java/forge/card/ability/ai/DestroyAi.java

@@ -19,7 +19,6 @@ import forge.card.spellability.Target;
 import forge.game.ai.ComputerUtil;
 import forge.game.ai.ComputerUtilCard;
 import forge.game.ai.ComputerUtilCost;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
@@ -30,14 +29,14 @@ public class DestroyAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#chkAIDrawback(java.util.Map, forge.card.spellability.SpellAbility, forge.game.player.Player)
      */
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         return canPlayAI(ai, sa);
     }
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(final AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(final Player ai, SpellAbility sa) {
         // AI needs to be expanded, since this function can be pretty complex
         // based on what the expected targets could be
         final Random r = MyRandom.getRandom();
@@ -164,7 +163,7 @@ public class DestroyAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Target tgt = sa.getTarget();
         final Card source = sa.getSourceCard();
         final boolean noRegen = sa.hasParam("NoRegen");

src/main/java/forge/card/ability/ai/DestroyAllAi.java

@@ -14,7 +14,7 @@ import forge.card.spellability.Target;
 import forge.game.ai.ComputerUtilCard;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.ai.ComputerUtilMana;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
@@ -31,7 +31,7 @@ public class DestroyAllAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Card source = sa.getSourceCard();
         final Target tgt = sa.getTarget();
         String valid = "";
@@ -73,13 +73,13 @@ public class DestroyAllAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         //TODO: Check for bad outcome
         return true;
     }
 
     @Override
-    protected boolean canPlayAI(final AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(final Player ai, SpellAbility sa) {
         // AI needs to be expanded, since this function can be pretty complex
         // based on what the expected targets could be
         final Random r = MyRandom.getRandom();

src/main/java/forge/card/ability/ai/DigAi.java

@@ -6,7 +6,6 @@ import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
@@ -17,7 +16,7 @@ public class DigAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
 
         final Random r = MyRandom.getRandom();
         boolean randomReturn = r.nextFloat() <= Math.pow(0.9, sa.getActivationsThisTurn());
@@ -55,7 +54,7 @@ public class DigAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Target tgt = sa.getTarget();
 
         if (sa.getTarget() != null) {

src/main/java/forge/card/ability/ai/DigUntilAi.java

@@ -9,7 +9,6 @@ import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.ai.ComputerUtilMana;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
@@ -17,7 +16,7 @@ import forge.util.MyRandom;
 public class DigUntilAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         Card source = sa.getSourceCard();
         double chance = .4; // 40 percent chance with instant speed stuff
         if (SpellAbilityAi.isSorcerySpeed(sa)) {
@@ -69,7 +68,7 @@ public class DigUntilAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
 
         final Target tgt = sa.getTarget();
 

src/main/java/forge/card/ability/ai/DiscardAi.java

@@ -13,7 +13,6 @@ import forge.game.ai.ComputerUtil;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.ai.ComputerUtilMana;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
@@ -21,7 +20,7 @@ import forge.util.MyRandom;
 public class DiscardAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Target tgt = sa.getTarget();
         final Card source = sa.getSourceCard();
         final Cost abCost = sa.getPayCosts();
@@ -130,7 +129,7 @@ public class DiscardAi extends SpellAbilityAi {
 
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Target tgt = sa.getTarget();
         if (tgt != null) {
             Player opp = ai.getOpponent();
@@ -156,7 +155,7 @@ public class DiscardAi extends SpellAbilityAi {
     } // discardTrigger()
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         // Drawback AI improvements
         // if parent draws cards, make sure cards in hand + cards drawn > 0
         final Target tgt = sa.getTarget();

src/main/java/forge/card/ability/ai/DrainManaAi.java

@@ -8,14 +8,13 @@ import forge.card.ability.AbilityUtils;
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.util.MyRandom;
 
 public class DrainManaAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         // AI cannot use this properly until he can use SAs during Humans turn
 
         final Target tgt = sa.getTarget();
@@ -42,7 +41,7 @@ public class DrainManaAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Player opp = ai.getOpponent();
 
         final Target tgt = sa.getTarget();
@@ -69,7 +68,7 @@ public class DrainManaAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         // AI cannot use this properly until he can use SAs during Humans turn
         final Target tgt = sa.getTarget();
         final Card source = sa.getSourceCard();

src/main/java/forge/card/ability/ai/DrawAi.java

@@ -36,7 +36,6 @@ import forge.game.ai.ComputerUtil;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.ai.ComputerUtilMana;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
@@ -44,7 +43,7 @@ import forge.util.MyRandom;
 public class DrawAi extends SpellAbilityAi {
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         return targetAI(ai, sa, false);
     }
 
@@ -52,7 +51,7 @@ public class DrawAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Target tgt = sa.getTarget();
         final Card source = sa.getSourceCard();
         final Cost abCost = sa.getPayCosts();
@@ -72,7 +71,7 @@ public class DrawAi extends SpellAbilityAi {
                 for (final CostPart part : abCost.getCostParts()) {
                     if (part instanceof CostDiscard) {
                         CostDiscard cd = (CostDiscard) part;
-                        PaymentDecision decision = cd.decideAIPayment((AIPlayer) ai, sa, sa.getSourceCard());
+                        PaymentDecision decision = cd.decideAIPayment(ai, sa, sa.getSourceCard());
                         if ( null == decision )
                             return false;
                         for (Card discard : decision.cards) {
@@ -265,7 +264,7 @@ public class DrawAi extends SpellAbilityAi {
 
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         return targetAI(ai, sa, mandatory);
     }
 

src/main/java/forge/card/ability/ai/EffectAi.java

@@ -16,14 +16,13 @@ import forge.game.ai.ComputerUtilCombat;
 import forge.game.phase.CombatUtil;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
 public class EffectAi extends SpellAbilityAi {
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final GameState game = ai.getGame();
         final Random r = MyRandom.getRandom();
         boolean randomReturn = r.nextFloat() <= .6667;
@@ -124,7 +123,7 @@ public class EffectAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         // TODO: Add targeting effects
 
         return true;

src/main/java/forge/card/ability/ai/EncodeAi.java

@@ -19,7 +19,7 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 /**
  * <p>
@@ -42,13 +42,13 @@ public final class EncodeAi extends SpellAbilityAi {
      * @return a boolean.
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         return true;
     }
     
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         return true;
     }
 }

src/main/java/forge/card/ability/ai/EndTurnAi.java

@@ -3,7 +3,7 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 /** 
  * TODO: Write javadoc for this type.
@@ -12,18 +12,18 @@ import forge.game.player.AIPlayer;
 public class EndTurnAi extends SpellAbilityAi  {
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         return mandatory;
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) { return false; }
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) { return false; }
 
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         return false;
     }
 }

src/main/java/forge/card/ability/ai/FightAi.java

@@ -11,7 +11,7 @@ import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.ai.ComputerUtilCombat;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.util.MyRandom;
 
 public class FightAi extends SpellAbilityAi {
@@ -20,7 +20,7 @@ public class FightAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         Target tgt = sa.getTarget();
         tgt.resetTargets();
 
@@ -87,7 +87,7 @@ public class FightAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         return false;
     }
 

src/main/java/forge/card/ability/ai/FlipACoinAi.java

@@ -2,7 +2,7 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class FlipACoinAi extends SpellAbilityAi {
 
@@ -10,7 +10,7 @@ public class FlipACoinAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
 
         if (sa.hasParam("AILogic")) {
             if (sa.getParam("AILogic").equals("Never")) {
@@ -21,7 +21,7 @@ public class FlipACoinAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         return canPlayAI(ai, sa);
     }
 }

src/main/java/forge/card/ability/ai/FogAi.java

@@ -6,7 +6,7 @@ import forge.card.spellability.SpellAbility;
 import forge.game.GameState;
 import forge.game.ai.ComputerUtilCombat;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class FogAi extends SpellAbilityAi {
 
@@ -14,7 +14,7 @@ public class FogAi extends SpellAbilityAi {
          * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
          */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final GameState game = ai.getGame();
         // AI should only activate this during Human's Declare Blockers phase
         if (game.getPhaseHandler().isPlayerTurn(sa.getActivatingPlayer())) {
@@ -39,7 +39,7 @@ public class FogAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         // AI should only activate this during Human's turn
         boolean chance;
         final GameState game = ai.getGame();
@@ -55,7 +55,7 @@ public class FogAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         final GameState game = aiPlayer.getGame();
         boolean chance;
         if (game.getPhaseHandler().isPlayerTurn(sa.getActivatingPlayer().getOpponent())) {

src/main/java/forge/card/ability/ai/GameLossAi.java

@@ -3,12 +3,11 @@ package forge.card.ability.ai;
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 
 public class GameLossAi extends SpellAbilityAi {
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Player opp = ai.getOpponent();
         if (opp.cantLose()) {
             return false;
@@ -29,7 +28,7 @@ public class GameLossAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
 
         // Phage the Untouchable
         // (Final Fortune would need to attach it's delayed trigger to a

src/main/java/forge/card/ability/ai/GameWinAi.java

@@ -3,14 +3,14 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class GameWinAi extends SpellAbilityAi {
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         if (ai.cantWin()) {
             return false;
         }
@@ -25,7 +25,7 @@ public class GameWinAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         return true;
     }
 

src/main/java/forge/card/ability/ai/LifeExchangeAi.java

@@ -5,7 +5,6 @@ import java.util.Random;
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.util.MyRandom;
 
@@ -20,7 +19,7 @@ public class LifeExchangeAi extends SpellAbilityAi {
      * forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         final Random r = MyRandom.getRandom();
         final int myLife = aiPlayer.getLife();
         Player opponent = aiPlayer.getOpponent();

src/main/java/forge/card/ability/ai/LifeGainAi.java

@@ -15,7 +15,7 @@ import forge.game.ai.ComputerUtilCombat;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.ai.ComputerUtilMana;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.util.MyRandom;
 
 /**
@@ -29,7 +29,7 @@ public class LifeGainAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.AbilityFactoryAlterLife.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
 
         final Random r = MyRandom.getRandom();
         final Cost abCost = sa.getPayCosts();
@@ -146,7 +146,7 @@ public class LifeGainAi extends SpellAbilityAi {
      * @return a boolean.
      */
     @Override
-    protected boolean doTriggerAINoCost(final AIPlayer ai, final SpellAbility sa,
+    protected boolean doTriggerAINoCost(final Player ai, final SpellAbility sa,
     final boolean mandatory) {
 
         // If the Target is gaining life, target self.

src/main/java/forge/card/ability/ai/LifeLoseAi.java

@@ -13,14 +13,13 @@ import forge.game.ai.ComputerUtil;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.ai.ComputerUtilMana;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.util.MyRandom;
 
 public class LifeLoseAi extends SpellAbilityAi {
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
 
         final Target tgt = sa.getTarget();
         List<Player> tgtPlayers;
@@ -52,7 +51,7 @@ public class LifeLoseAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.AbilityFactoryAlterLife.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
 
         final Random r = MyRandom.getRandom();
         final Cost abCost = sa.getPayCosts();
@@ -139,7 +138,7 @@ public class LifeLoseAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(final AIPlayer ai, final SpellAbility sa,
+    protected boolean doTriggerAINoCost(final Player ai, final SpellAbility sa,
     final boolean mandatory) {
         final Target tgt = sa.getTarget();
         if (tgt != null) {

src/main/java/forge/card/ability/ai/LifeSetAi.java

@@ -10,14 +10,13 @@ import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.ai.ComputerUtilMana;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.util.MyRandom;
 
 public class LifeSetAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Random r = MyRandom.getRandom();
         // Ability_Cost abCost = sa.getPayCosts();
         final Card source = sa.getSourceCard();
@@ -102,7 +101,7 @@ public class LifeSetAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final int myLife = ai.getLife();
         final Player opponent = ai.getOpponent();
         final int hlife = opponent.getLife();

src/main/java/forge/card/ability/ai/ManaEffectAi.java

@@ -3,12 +3,12 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class ManaEffectAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         return false;
     }
 
@@ -23,7 +23,7 @@ public class ManaEffectAi extends SpellAbilityAi {
      * @return a boolean.
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         return true;
     }
 

src/main/java/forge/card/ability/ai/MillAi.java

@@ -13,7 +13,6 @@ import forge.game.ai.ComputerUtil;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.ai.ComputerUtilMana;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
@@ -21,7 +20,7 @@ import forge.util.MyRandom;
 public class MillAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Card source = sa.getSourceCard();
         final Cost abCost = sa.getPayCosts();
 
@@ -135,13 +134,13 @@ public class MillAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         return targetAI(aiPlayer, sa, true);
     }
 
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         if (!targetAI(aiPlayer, sa, mandatory)) {
             return false;
         }

src/main/java/forge/card/ability/ai/MustAttackAi.java

@@ -3,18 +3,18 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class MustAttackAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         // disabled for the AI for now. Only for Gideon Jura at this time.
         return false;
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         // AI should only activate this during Human's turn
         // TODO - implement AI
         return false;
@@ -24,7 +24,7 @@ public class MustAttackAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
 
         boolean chance;
 

src/main/java/forge/card/ability/ai/MustBlockAi.java

@@ -15,25 +15,25 @@ import forge.game.ai.ComputerUtilCard;
 import forge.game.ai.ComputerUtilCombat;
 import forge.game.phase.CombatUtil;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
 public class MustBlockAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         // disabled for the AI until he/she can make decisions about who to make
         // block
         return false;
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         return false;
     }
 
     @Override
-    protected boolean doTriggerAINoCost(final AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(final Player ai, SpellAbility sa, boolean mandatory) {
         final Card source = sa.getSourceCard();
         final Target abTgt = sa.getTarget();
 

src/main/java/forge/card/ability/ai/PeekAndRevealAi.java

@@ -2,7 +2,7 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 /** 
  * TODO: Write javadoc for this type.
@@ -14,7 +14,7 @@ public class PeekAndRevealAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         // So far this only appears on Triggers, but will expand
         // once things get converted from Dig + NoMove
         return true;

src/main/java/forge/card/ability/ai/PermanentCreatureAi.java

@@ -12,7 +12,7 @@ import forge.card.spellability.SpellAbility;
 import forge.game.GameState;
 import forge.game.ai.ComputerUtil;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
 /** 
@@ -25,7 +25,7 @@ public class PermanentCreatureAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         String logic = sa.getParam("AILogic");
         GameState game = aiPlayer.getGame();
 

src/main/java/forge/card/ability/ai/PermanentNoncreatureAi.java

@@ -4,7 +4,7 @@ import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.game.ai.ComputerUtil;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 /** 
  * AbilityFactory for Creature Spells.
@@ -16,7 +16,7 @@ public class PermanentNoncreatureAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         String logic = sa.getParam("AILogic");
 
         if ("DontCast".equals(logic)) {

src/main/java/forge/card/ability/ai/PhasesAi.java

@@ -10,7 +10,7 @@ import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.GameState;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
@@ -20,7 +20,7 @@ public class PhasesAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         // This still needs to be fleshed out
         final Target tgt = sa.getTarget();
         final Card source = sa.getSourceCard();
@@ -50,7 +50,7 @@ public class PhasesAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         final Target tgt = sa.getTarget();
 
         if (tgt == null) {
@@ -68,7 +68,7 @@ public class PhasesAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         final Target tgt = sa.getTarget();
 
         boolean randomReturn = true;

src/main/java/forge/card/ability/ai/PlayAi.java

@@ -13,14 +13,14 @@ import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.ai.ComputerUtilCard;
 import forge.game.ai.ComputerUtilCost;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
 public class PlayAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getSourceCard();
 
@@ -85,7 +85,7 @@ public class PlayAi extends SpellAbilityAi {
      * @return a boolean.
      */
     @Override
-    protected boolean doTriggerAINoCost(final AIPlayer ai, final SpellAbility sa, final boolean mandatory) {
+    protected boolean doTriggerAINoCost(final Player ai, final SpellAbility sa, final boolean mandatory) {
 
         final Target tgt = sa.getTarget();
         if (tgt != null) {

src/main/java/forge/card/ability/ai/PoisonAi.java

@@ -11,7 +11,6 @@ import forge.card.spellability.Target;
 import forge.game.ai.ComputerUtil;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 
 public class PoisonAi extends SpellAbilityAi {
@@ -25,7 +24,7 @@ public class PoisonAi extends SpellAbilityAi {
      * forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getSourceCard();
         // int humanPoison = AllZone.getHumanPlayer().getPoisonCounters();
@@ -71,7 +70,7 @@ public class PoisonAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
 
         final Target tgt = sa.getTarget();
         if (tgt != null) {

src/main/java/forge/card/ability/ai/ProtectAi.java

@@ -18,7 +18,6 @@ import forge.game.ai.ComputerUtilCard;
 import forge.game.ai.ComputerUtilCombat;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -110,7 +109,7 @@ public class ProtectAi extends SpellAbilityAi {
     } // getProtectCreatures()
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Card hostCard = sa.getSourceCard();
         final GameState game = ai.getGame();
         // if there is no target and host card isn't in play, don't activate
@@ -344,7 +343,7 @@ public class ProtectAi extends SpellAbilityAi {
     } // protectMandatoryTarget()
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         if (sa.getTarget() == null) {
             if (mandatory) {
                 return true;
@@ -357,7 +356,7 @@ public class ProtectAi extends SpellAbilityAi {
     } // protectTriggerAI
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         final Card host = sa.getSourceCard();
         if ((sa.getTarget() == null) || !sa.getTarget().doesTarget()) {
             if (host.isCreature()) {

src/main/java/forge/card/ability/ai/ProtectAllAi.java

@@ -6,12 +6,12 @@ import forge.card.ability.SpellAbilityAi;
 import forge.card.cost.Cost;
 import forge.card.spellability.SpellAbility;
 import forge.game.ai.ComputerUtilCost;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class ProtectAllAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Card hostCard = sa.getSourceCard();
         // if there is no target and host card isn't in play, don't activate
         if ((sa.getTarget() == null) && !hostCard.isInPlay()) {
@@ -42,7 +42,7 @@ public class ProtectAllAi extends SpellAbilityAi {
 
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         return true;
     }
 }

src/main/java/forge/card/ability/ai/PumpAi.java

@@ -24,7 +24,6 @@ import forge.game.ai.ComputerUtilCost;
 import forge.game.ai.ComputerUtilMana;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -47,7 +46,7 @@ public class PumpAi extends PumpAiBase {
          * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
          */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Cost cost = sa.getPayCosts();
         final GameState game = ai.getGame();
         final PhaseHandler ph = game.getPhaseHandler();
@@ -357,7 +356,7 @@ public class PumpAi extends PumpAiBase {
     } // pumpMandatoryTarget()
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Card source = sa.getSourceCard();
         final String numDefense = sa.hasParam("NumDef") ? sa.getParam("NumDef") : "";
         final String numAttack = sa.hasParam("NumAtt") ? sa.getParam("NumAtt") : "";
@@ -400,7 +399,7 @@ public class PumpAi extends PumpAiBase {
     } // pumpTriggerAI
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
 
         final Card source = sa.getSourceCard();
 

src/main/java/forge/card/ability/ai/PumpAllAi.java

@@ -17,7 +17,6 @@ import forge.game.ai.ComputerUtilCard;
 import forge.game.ai.ComputerUtilCombat;
 import forge.game.phase.CombatUtil;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -27,7 +26,7 @@ public class PumpAllAi extends PumpAiBase {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(final AIPlayer ai, final SpellAbility sa) {
+    protected boolean canPlayAI(final Player ai, final SpellAbility sa) {
         String valid = "";
         final Card source = sa.getSourceCard();
         final GameState game = ai.getGame();
@@ -146,7 +145,7 @@ public class PumpAllAi extends PumpAiBase {
     } // pumpAllCanPlayAI()
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         return true;
     }
 
@@ -154,7 +153,7 @@ public class PumpAllAi extends PumpAiBase {
      * @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         return true;
     }
 

src/main/java/forge/card/ability/ai/RearrangeTopOfLibraryAi.java

@@ -4,7 +4,6 @@ package forge.card.ability.ai;
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 
 public class RearrangeTopOfLibraryAi extends SpellAbilityAi {
@@ -12,7 +11,7 @@ public class RearrangeTopOfLibraryAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         return false;
     }
 
@@ -20,7 +19,7 @@ public class RearrangeTopOfLibraryAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
 
         final Target tgt = sa.getTarget();
 

src/main/java/forge/card/ability/ai/RegenerateAi.java

@@ -34,7 +34,6 @@ import forge.game.ai.ComputerUtilCard;
 import forge.game.ai.ComputerUtilCombat;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -57,7 +56,7 @@ public class RegenerateAi extends SpellAbilityAi {
     // **************************************************************
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Card hostCard = sa.getSourceCard();
         final Cost abCost = sa.getPayCosts();
         final GameState game = ai.getGame();
@@ -159,7 +158,7 @@ public class RegenerateAi extends SpellAbilityAi {
     } // regenerateCanPlayAI
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         boolean chance = false;
 
         final Target tgt = sa.getTarget();

src/main/java/forge/card/ability/ai/RegenerateAllAi.java

@@ -14,13 +14,13 @@ import forge.game.ai.ComputerUtil;
 import forge.game.ai.ComputerUtilCombat;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
 public class RegenerateAllAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Card hostCard = sa.getSourceCard();
         boolean chance = false;
         final Cost abCost = sa.getPayCosts();
@@ -84,7 +84,7 @@ public class RegenerateAllAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         boolean chance = true;
 
         return chance;

src/main/java/forge/card/ability/ai/RemoveFromCombatAi.java

@@ -3,18 +3,18 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class RemoveFromCombatAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         // disabled for the AI for now. Only for Gideon Jura at this time.
         return false;
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         // AI should only activate this during Human's turn
 
         // TODO - implement AI
@@ -25,7 +25,7 @@ public class RemoveFromCombatAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         boolean chance;
 
         // TODO - implement AI

src/main/java/forge/card/ability/ai/RepeatAi.java

@@ -4,13 +4,12 @@ package forge.card.ability.ai;
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 
 public class RepeatAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Target tgt = sa.getTarget();
         final Player opp = ai.getOpponent();
         if (tgt != null) {

src/main/java/forge/card/ability/ai/RepeatEachAi.java

@@ -12,7 +12,6 @@ import forge.CounterType;
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -26,7 +25,7 @@ public class RepeatEachAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         String logic = sa.getParam("AILogic");
 
         if ("CloneMyTokens".equals(logic)) {

src/main/java/forge/card/ability/ai/RestartGameAi.java

@@ -2,7 +2,7 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class RestartGameAi extends SpellAbilityAi {
 
@@ -15,7 +15,7 @@ public class RestartGameAi extends SpellAbilityAi {
      * forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         // The only card that uses this is Karn Liberated
 
         // TODO Add Logic, check if AI is losing game state, or life
@@ -26,7 +26,7 @@ public class RestartGameAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         // This trigger AI is completely unused, but return true just in case
         return true;
     }

src/main/java/forge/card/ability/ai/RevealAi.java

@@ -7,12 +7,12 @@ import forge.card.ability.SpellAbilityAi;
 import forge.card.cost.Cost;
 import forge.card.spellability.SpellAbility;
 import forge.game.ai.ComputerUtilCost;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.util.MyRandom;
 
 public class RevealAi extends RevealAiBase {
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         // AI cannot use this properly until he can use SAs during Humans turn
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getSourceCard();
@@ -54,7 +54,7 @@ public class RevealAi extends RevealAiBase {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
 
         if (!revealHandTargetAI(ai, sa/*, false, mandatory*/)) {
             return false;

src/main/java/forge/card/ability/ai/RevealAiBase.java

@@ -4,7 +4,6 @@ package forge.card.ability.ai;
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -38,7 +37,7 @@ public abstract class RevealAiBase extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#chkAIDrawback(java.util.Map, forge.card.spellability.SpellAbility, forge.game.player.Player)
      */
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         revealHandTargetAI(ai, sa);
         return true;
     }

src/main/java/forge/card/ability/ai/RevealHandAi.java

@@ -7,7 +7,7 @@ import forge.card.ability.SpellAbilityAi;
 import forge.card.cost.Cost;
 import forge.card.spellability.SpellAbility;
 import forge.game.ai.ComputerUtilCost;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.util.MyRandom;
 
 public class RevealHandAi extends RevealAiBase {
@@ -16,7 +16,7 @@ public class RevealHandAi extends RevealAiBase {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         // AI cannot use this properly until he can use SAs during Humans turn
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getSourceCard();
@@ -58,7 +58,7 @@ public class RevealHandAi extends RevealAiBase {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
 
         if (!revealHandTargetAI(ai, sa/*, false, mandatory*/)) {
             return false;

src/main/java/forge/card/ability/ai/SacrificeAi.java

@@ -11,7 +11,6 @@ import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.ai.ComputerUtilCard;
 import forge.game.ai.ComputerUtilMana;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -21,20 +20,20 @@ public class SacrificeAi extends SpellAbilityAi {
     // **************************************************************
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
 
         return sacrificeTgtAI(ai, sa);
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         // AI should only activate this during Human's turn
 
         return sacrificeTgtAI(ai, sa);
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         // AI should only activate this during Human's turn
         boolean chance = sacrificeTgtAI(ai, sa);
 

src/main/java/forge/card/ability/ai/SacrificeAllAi.java

@@ -11,14 +11,14 @@ import forge.card.spellability.SpellAbility;
 import forge.game.ai.ComputerUtilCard;
 import forge.game.ai.ComputerUtilCost;
 import forge.game.ai.ComputerUtilMana;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
 public class SacrificeAllAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         // AI needs to be expanded, since this function can be pretty complex
         // based on what the expected targets could be
         final Random r = MyRandom.getRandom();
@@ -76,7 +76,7 @@ public class SacrificeAllAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         //TODO: Add checks for bad outcome
         return true;
     }

src/main/java/forge/card/ability/ai/ScryAi.java

@@ -5,7 +5,7 @@ import java.util.Random;
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.util.MyRandom;
 
 public class ScryAi extends SpellAbilityAi {
@@ -14,7 +14,7 @@ public class ScryAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Target tgt = sa.getTarget();
 
         if (tgt != null) { // It doesn't appear that Scry ever targets
@@ -28,13 +28,13 @@ public class ScryAi extends SpellAbilityAi {
     } // scryTargetAI()
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         return doTriggerAINoCost(ai, sa, false);
     }
 
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         // Card source = sa.getSourceCard();
 
         double chance = .4; // 40 percent chance of milling with instant speed

src/main/java/forge/card/ability/ai/SetStateAi.java

@@ -3,16 +3,16 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class SetStateAi extends SpellAbilityAi {
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         return false;
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         // Gross generalization, but this always considers alternate
         // states more powerful
         return !sa.getSourceCard().isInAlternateState();
@@ -23,7 +23,7 @@ public class SetStateAi extends SpellAbilityAi {
     * @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
     */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         return true;
     }
 }

src/main/java/forge/card/ability/ai/ShuffleAi.java

@@ -2,11 +2,11 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class ShuffleAi extends SpellAbilityAi {
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         // not really sure when the compy would use this; maybe only after a
         // human
         // deliberately put a card on top of their library
@@ -27,7 +27,7 @@ public class ShuffleAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         return shuffleTargetAI(/*sa, false, false*/);
     }
 
@@ -40,7 +40,7 @@ public class ShuffleAi extends SpellAbilityAi {
     } // shuffleTargetAI()
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         if (!shuffleTargetAI(/*sa, false, mandatory*/)) {
             return false;
         }

src/main/java/forge/card/ability/ai/StoreSVarAi.java

@@ -5,12 +5,12 @@ import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.game.ai.ComputerUtil;
 import forge.game.ai.ComputerUtilCombat;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 public class StoreSVarAi extends SpellAbilityAi {
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         //Tree of Redemption
 
         final Card source = sa.getSourceCard();
@@ -23,7 +23,7 @@ public class StoreSVarAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
 
         return true;
     }

src/main/java/forge/card/ability/ai/TapAi.java

@@ -10,13 +10,12 @@ import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.util.MyRandom;
 
 public class TapAi extends TapAiBase {
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
 
         final PhaseHandler phase = ai.getGame().getPhaseHandler();
         final Player turn = phase.getPlayerTurn();

src/main/java/forge/card/ability/ai/TapAiBase.java

@@ -18,7 +18,6 @@ import forge.game.ai.ComputerUtilCard;
 import forge.game.phase.CombatUtil;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -279,7 +278,7 @@ public abstract class TapAiBase extends SpellAbilityAi  {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
 
         final Target tgt = sa.getTarget();
         final Card source = sa.getSourceCard();
@@ -305,7 +304,7 @@ public abstract class TapAiBase extends SpellAbilityAi  {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         final Target tgt = sa.getTarget();
         final Card source = sa.getSourceCard();
 

src/main/java/forge/card/ability/ai/TapAllAi.java

@@ -15,7 +15,6 @@ import forge.card.spellability.Target;
 import forge.game.GameState;
 import forge.game.phase.CombatUtil;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
@@ -26,7 +25,7 @@ public class TapAllAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(final AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(final Player ai, SpellAbility sa) {
         // If tapping all creatures do it either during declare attackers of AIs
         // turn
         // or during upkeep/begin combat?
@@ -117,7 +116,7 @@ public class TapAllAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(final AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(final Player ai, SpellAbility sa, boolean mandatory) {
         final Card source = sa.getSourceCard();
 
         String valid = "";

src/main/java/forge/card/ability/ai/TapOrUntapAi.java

@@ -7,7 +7,7 @@ import forge.Card;
 import forge.card.ability.AbilityUtils;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 import forge.util.MyRandom;
 
 public class TapOrUntapAi extends TapAiBase {
@@ -16,7 +16,7 @@ public class TapOrUntapAi extends TapAiBase {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Target tgt = sa.getTarget();
         final Card source = sa.getSourceCard();
 

src/main/java/forge/card/ability/ai/TapOrUntapAllAi.java

@@ -2,7 +2,7 @@ package forge.card.ability.ai;
 
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
-import forge.game.player.AIPlayer;
+import forge.game.player.Player;
 
 /** 
  * TODO: Write javadoc for this type.
@@ -14,7 +14,7 @@ public class TapOrUntapAllAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         // Only Turnabout currently uses this, it's hardcoded to always return false
         // Looks like Faces of the Past could also use this
         return false;

src/main/java/forge/card/ability/ai/TokenAi.java

@@ -14,7 +14,6 @@ import forge.game.ai.ComputerUtilCost;
 import forge.game.ai.ComputerUtilMana;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
@@ -65,7 +64,7 @@ public class TokenAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Cost cost = sa.getPayCosts();
         final GameState game = ai.getGame();
         readParameters(sa);
@@ -181,7 +180,7 @@ public class TokenAi extends SpellAbilityAi {
     }
 
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         readParameters(sa);
         final Card source = sa.getSourceCard();
         final Target tgt = sa.getTarget();

src/main/java/forge/card/ability/ai/TwoPilesAi.java

@@ -9,7 +9,6 @@ import forge.card.ability.AbilityUtils;
 import forge.card.ability.SpellAbilityAi;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -19,7 +18,7 @@ public class TwoPilesAi extends SpellAbilityAi  {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Card card = sa.getSourceCard();
         ZoneType zone = null;
 
@@ -62,7 +61,7 @@ public class TwoPilesAi extends SpellAbilityAi  {
      * @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         return false;
     }
 }

src/main/java/forge/card/ability/ai/UnattachAllAi.java

@@ -12,7 +12,6 @@ import forge.card.spellability.Target;
 import forge.game.ai.ComputerUtilCard;
 import forge.game.ai.ComputerUtilMana;
 import forge.game.phase.PhaseType;
-import forge.game.player.AIPlayer;
 import forge.game.player.Player;
 import forge.util.MyRandom;
 
@@ -22,7 +21,7 @@ public class UnattachAllAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Random r = MyRandom.getRandom();
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getSourceCard();
@@ -63,7 +62,7 @@ public class UnattachAllAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
      */
     @Override
-    protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Card card = sa.getSourceCard();
         final Player opp = ai.getOpponent();
         // Check if there are any valid targets
@@ -93,7 +92,7 @@ public class UnattachAllAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         // AI should only activate this during Human's turn
         return canPlayAI(ai, sa);
     }