- Added Drain Power

forge-ai/src/main/java/forge/ai/SpellApiToAi.java

@@ -14,6 +14,7 @@ public enum SpellApiToAi {
     
     static {
         apiToClass.put(ApiType.Abandon, AlwaysPlayAi.class);
+        apiToClass.put(ApiType.ActivateAbility, ActivateAbilityAi.class);
         apiToClass.put(ApiType.AddOrRemoveCounter, CountersPutOrRemoveAi.class);
         apiToClass.put(ApiType.AddPhase, AddPhaseAi.class);
         apiToClass.put(ApiType.AddTurn, AddTurnAi.class);

forge-ai/src/main/java/forge/ai/ability/ActivateAbilityAi.java

@@ -0,0 +1,100 @@
+package forge.ai.ability;
+
+import forge.ai.SpellAbilityAi;
+import forge.game.ability.AbilityUtils;
+import forge.game.card.Card;
+import forge.game.card.CardLists;
+import forge.game.player.Player;
+import forge.game.spellability.SpellAbility;
+import forge.game.spellability.TargetRestrictions;
+import forge.game.zone.ZoneType;
+import forge.util.MyRandom;
+
+import java.util.List;
+import java.util.Random;
+
+public class ActivateAbilityAi extends SpellAbilityAi {
+
+    @Override
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
+        // AI cannot use this properly until he can use SAs during Humans turn
+
+        final TargetRestrictions tgt = sa.getTargetRestrictions();
+        final Card source = sa.getHostCard();
+        final Player opp = ai.getOpponent();
+        final Random r = MyRandom.getRandom();
+        boolean randomReturn = r.nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+
+        List<Card> list = CardLists.getType(opp.getCardsIn(ZoneType.Battlefield), sa.getParamOrDefault("Type", "Card"));
+        if (list.isEmpty()) {
+            return false;
+        }
+
+        if (tgt == null) {
+            final List<Player> defined = AbilityUtils.getDefinedPlayers(source, sa.getParam("Defined"), sa);
+
+            if (!defined.contains(opp)) {
+                return false;
+            }
+        } else {
+            sa.resetTargets();
+            sa.getTargets().add(opp);
+        }
+
+        return randomReturn;
+    }
+
+    @Override
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
+        final Player opp = ai.getOpponent();
+
+        final TargetRestrictions tgt = sa.getTargetRestrictions();
+        final Card source = sa.getHostCard();
+
+        if (null == tgt) {
+            if (mandatory) {
+                return true;
+            } else {
+                final List<Player> defined = AbilityUtils.getDefinedPlayers(source, sa.getParam("Defined"), sa);
+
+                if (!defined.contains(opp)) {
+                    return false;
+                }
+            }
+
+            return true;
+        } else {
+            sa.resetTargets();
+            sa.getTargets().add(opp);
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
+        // AI cannot use this properly until he can use SAs during Humans turn
+        final TargetRestrictions tgt = sa.getTargetRestrictions();
+        final Card source = sa.getHostCard();
+
+        boolean randomReturn = true;
+
+        if (tgt == null) {
+            final List<Player> defined = AbilityUtils.getDefinedPlayers(source, sa.getParam("Defined"), sa);
+
+            if (defined.contains(ai)) {
+                return false;
+            }
+        } else {
+            sa.resetTargets();
+            sa.getTargets().add(ai.getOpponent());
+        }
+
+        return randomReturn;
+    }
+
+    @Override
+    public SpellAbility chooseSingleSpellAbility(Player player, SpellAbility sa, List<SpellAbility> spells) {
+        return spells.get(0);
+    }
+}

forge-ai/src/main/java/forge/ai/ability/ChooseGenericEffectAi.java

@@ -30,8 +30,9 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
     @Override
     public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         return canPlayAI(aiPlayer, sa);
-    }    
-    
+    }
+
+    @Override
     public SpellAbility chooseSingleSpellAbility(Player player, SpellAbility sa, List<SpellAbility> spells) {
         final String logic = sa.getParam("AILogic");
         if ("Random".equals(logic)) {

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

@@ -60,5 +60,34 @@ public class LifeExchangeAi extends SpellAbilityAi {
         return ((r.nextFloat() < .6667) && chance);
     }
 
+    /**
+     * <p>
+     * exchangeLifeDoTriggerAINoCost.
+     * </p>
+     * @param sa
+     *            a {@link forge.game.spellability.SpellAbility} object.
+     * @param mandatory
+     *            a boolean.
+     * @param af
+     *            a {@link forge.game.ability.AbilityFactory} object.
+     *
+     * @return a boolean.
+     */
+    @Override
+    protected boolean doTriggerAINoCost(final Player ai, final SpellAbility sa,
+    final boolean mandatory) {
+
+        final TargetRestrictions tgt = sa.getTargetRestrictions();
+        Player opp = ai.getOpponent();
+        if (tgt != null) {
+            sa.resetTargets();
+            if (sa.canTarget(opp) && (mandatory || ai.getLife() < opp.getLife())) {
+                sa.getTargets().add(opp);
+            } else {
+                return false;
+            }
+        }
+        return true;
+    }
 
 }