getStackDescription routines now use common routines for string collection

any spelleffect class can use common routines to get defined targets

src/main/java/forge/card/abilityfactory/SpellEffect.java

@@ -1,9 +1,13 @@
 package forge.card.abilityfactory;
 
+import java.util.List;
 import java.util.Map;
 
+import forge.Card;
 import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
+import forge.card.spellability.Target;
+import forge.game.player.Player;
 
 /**
  * <p>
@@ -16,21 +20,67 @@ import forge.card.spellability.SpellAbility;
 
     public abstract class SpellEffect {
         public abstract void resolve(final Map<String, String> params, final SpellAbility sa);
-        protected abstract String getStackDescription(final Map<String, String> params, final SpellAbility sa);
+        @SuppressWarnings("unused")
+        protected String getStackDescription(final Map<String, String> params, final SpellAbility sa) {
+         // If not overriden, let the spell description also be the stack description
+            return sa.getDescription();
+        }
 
 
         /**
-         * TODO: Write javadoc for this method.
+         * Returns this effect description with needed prelude and epilogue
          * @param params
          * @param commonSpell
          * @return
          */
         public final String getStackDescriptionWithSubs(final Map<String, String> params, final SpellAbility sa) {
-            final String s1 = this.getStackDescription(params, sa);
+            StringBuilder sb = new StringBuilder();
+            
+            // prelude for when this is root ability
+            if (!(sa instanceof AbilitySub)) {
+                sb.append(sa.getSourceCard()).append(" -");
+            }
+            sb.append(" ");
+
+            // Own description
+            String stackDesc = params.get("StackDescription");
+            String spellDesc = params.get("SpellDescription");
+            if ( stackDesc != null ) {
+                if ( !"None".equalsIgnoreCase(stackDesc) ) // by typing "none" they want to suppress output
+                    sb.append( stackDesc.replace("CARDNAME", sa.getSourceCard().getName()));
+            } else if ( spellDesc != null ) {
+                sb.append( spellDesc.replace("CARDNAME", sa.getSourceCard().getName()) );
+            } else
+                sb.append(this.getStackDescription(params, sa));
+            
+            
+            // This inlcudes all subAbilities
             final AbilitySub abSub = sa.getSubAbility();
             if (abSub != null) {
-                return s1 + abSub.getStackDescription();
+                sb.append(abSub.getStackDescription());
             }
-            return s1;
+            return sb.toString();
         }
+
+        protected List<Card> getTargetCards(SpellAbility sa, final Map<String, String> params) {
+            final Target tgt = sa.getTarget();
+            return tgt != null ? tgt.getTargetCards() : AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
+        }
+
+        protected List<Player> getTargetPlayers(SpellAbility sa, final Map<String, String> params) {
+            final Target tgt = sa.getTarget();
+            return tgt != null ? tgt.getTargetPlayers() : AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
+        }
+        
+        protected List<SpellAbility> getTargetSpellAbilities(SpellAbility sa, final Map<String, String> params) {
+            final Target tgt = sa.getTarget();
+            return tgt != null ? tgt.getTargetSAs() : AbilityFactory.getDefinedSpellAbilities(sa.getSourceCard(), params.get("Defined"), sa);
+        }
+        
+        protected List<Object> getTargetObjects(SpellAbility sa, final Map<String, String> params) {
+            final Target tgt = sa.getTarget();
+            return tgt != null ? tgt.getTargets() : AbilityFactory.getDefinedObjects(sa.getSourceCard(), params.get("Defined"), sa);
+        }
+
+
     }

src/main/java/forge/card/abilityfactory/effects/AddTurnEffect.java

@@ -1,11 +1,11 @@
 package forge.card.abilityfactory.effects;
 
 import java.util.ArrayList;
+import java.util.List;
 
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.phase.ExtraTurn;
@@ -13,6 +13,30 @@ import forge.game.player.Player;
 
 public class AddTurnEffect extends SpellEffect {
     
+    @Override
+    protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
+    
+        final StringBuilder sb = new StringBuilder();
+        final int numTurns = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("NumTurns"), sa);
+    
+        List<Player> tgtPlayers = getTargetPlayers(sa, params);
+    
+        
+        for (final Player player : tgtPlayers) {
+            sb.append(player).append(" ");
+        }
+    
+        sb.append("takes ");
+        sb.append(numTurns > 1 ? numTurns : "an");
+        sb.append(" extra turn");
+        
+        if (numTurns > 1) {
+            sb.append("s");
+        }
+        sb.append(" after this one.");
+        return sb.toString();
+    }
+
     @Override
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
         final int numTurns = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("NumTurns"), sa);
@@ -41,43 +65,4 @@ public class AddTurnEffect extends SpellEffect {
         }
     }
 
-    @Override
-    protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-
-        final StringBuilder sb = new StringBuilder();
-        final int numTurns = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("NumTurns"), sa);
-    
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-    
-        ArrayList<Player> tgtPlayers;
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-    
-        for (final Player player : tgtPlayers) {
-            sb.append(player).append(" ");
-        }
-    
-        sb.append("takes ");
-        if (numTurns > 1) {
-            sb.append(numTurns);
-        } else {
-            sb.append("an");
-        }
-        sb.append(" extra turn");
-        if (numTurns > 1) {
-            sb.append("s");
-        }
-        sb.append(" after this one.");
-        return sb.toString();
-    }
-
 }

src/main/java/forge/card/abilityfactory/effects/AnimateAllEffect.java

@@ -12,7 +12,6 @@ import forge.Command;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.replacement.ReplacementEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.card.staticability.StaticAbility;
@@ -25,23 +24,7 @@ public class AnimateAllEffect extends AnimateEffectBase
 {
     @Override
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-        final StringBuilder sb = new StringBuilder();
+        return "Animate all valid cards."; 
-
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
-
-        String desc = "";
-        if (params.containsKey("SpellDescription")) {
-            desc = params.get("SpellDescription");
-        } else {
-            desc = "Animate all valid cards.";
-        }
-
-        sb.append(desc);
-        return sb.toString();
     }
 
     @Override

src/main/java/forge/card/abilityfactory/effects/AnimateEffect.java

@@ -11,7 +11,6 @@ import forge.Command;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.replacement.ReplacementEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.card.staticability.StaticAbility;
@@ -321,86 +320,70 @@ public class AnimateEffect extends AnimateEffectBase {
     
         final StringBuilder sb = new StringBuilder();
     
-        if (sa instanceof AbilitySub) {
+        final Target tgt = sa.getTarget();
+        final List<Card> tgts = tgt != null ? tgt.getTargetCards() :  AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
+
+        for (final Card c : tgts) {
+            sb.append(c).append(" ");
+        }
+        sb.append("become");
+        if (tgts.size() == 1) {
+            sb.append("s a");
+        }
+        // if power is -1, we'll assume it's not just setting toughness
+        if (power != -1) {
+            sb.append(" ").append(power).append("/").append(toughness);
+        }
+
+        if (colors.size() > 0) {
             sb.append(" ");
+        }
+        if (colors.contains("ChosenColor")) {
+            sb.append("color of that player's choice");
         } else {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
+            for (int i = 0; i < colors.size(); i++) {
-        }
+                sb.append(colors.get(i));
-    
+                if (i < (colors.size() - 1)) {
-        if (params.containsKey("StackDescription")) {
-            sb.append(params.get("StackDescription").replaceAll("CARDNAME", host.getName()));
-        }
-        else {
-    
-            final Target tgt = sa.getTarget();
-            ArrayList<Card> tgts;
-            if (tgt != null) {
-                tgts = tgt.getTargetCards();
-            } else {
-                tgts = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-            }
-    
-            for (final Card c : tgts) {
-                sb.append(c).append(" ");
-            }
-            sb.append("become");
-            if (tgts.size() == 1) {
-                sb.append("s a");
-            }
-            // if power is -1, we'll assume it's not just setting toughness
-            if (power != -1) {
-                sb.append(" ").append(power).append("/").append(toughness);
-            }
-    
-            if (colors.size() > 0) {
-                sb.append(" ");
-            }
-            if (colors.contains("ChosenColor")) {
-                sb.append("color of that player's choice");
-            } else {
-                for (int i = 0; i < colors.size(); i++) {
-                    sb.append(colors.get(i));
-                    if (i < (colors.size() - 1)) {
-                        sb.append(" and ");
-                    }
-                }
-            }
-            sb.append(" ");
-            if (types.contains("ChosenType")) {
-                sb.append("type of player's choice ");
-            } else {
-                for (int i = types.size() - 1; i >= 0; i--) {
-                    sb.append(types.get(i));
-                    sb.append(" ");
-                }
-            }
-            if (keywords.size() > 0) {
-                sb.append("with ");
-            }
-            for (int i = 0; i < keywords.size(); i++) {
-                sb.append(keywords.get(i));
-                if (i < (keywords.size() - 1)) {
                     sb.append(" and ");
                 }
             }
-            // sb.append(abilities)
+        }
-            // sb.append(triggers)
+        sb.append(" ");
-            if (!permanent) {
+        if (types.contains("ChosenType")) {
-                if (params.containsKey("UntilEndOfCombat")) {
+            sb.append("type of player's choice ");
-                    sb.append(" until end of combat.");
+        } else {
-                } else if (params.containsKey("UntilHostLeavesPlay")) {
+            for (int i = types.size() - 1; i >= 0; i--) {
-                    sb.append(" until ").append(host).append(" leaves the battlefield.");
+                sb.append(types.get(i));
-                } else if (params.containsKey("UntilYourNextUpkeep")) {
+                sb.append(" ");
-                    sb.append(" until your next upkeep.");
-                } else if (params.containsKey("UntilControllerNextUntap")) {
-                    sb.append(" until its controller's next untap step.");
-                } else {
-                    sb.append(" until end of turn.");
-                }
-            } else {
-                sb.append(".");
             }
         }
+        if (keywords.size() > 0) {
+            sb.append("with ");
+        }
+        for (int i = 0; i < keywords.size(); i++) {
+            sb.append(keywords.get(i));
+            if (i < (keywords.size() - 1)) {
+                sb.append(" and ");
+            }
+        }
+        // sb.append(abilities)
+        // sb.append(triggers)
+        if (!permanent) {
+            if (params.containsKey("UntilEndOfCombat")) {
+                sb.append(" until end of combat.");
+            } else if (params.containsKey("UntilHostLeavesPlay")) {
+                sb.append(" until ").append(host).append(" leaves the battlefield.");
+            } else if (params.containsKey("UntilYourNextUpkeep")) {
+                sb.append(" until your next upkeep.");
+            } else if (params.containsKey("UntilControllerNextUntap")) {
+                sb.append(" until its controller's next untap step.");
+            } else {
+                sb.append(" until end of turn.");
+            }
+        } else {
+            sb.append(".");
+        }
+     
     
         return sb.toString();
     }

src/main/java/forge/card/abilityfactory/effects/ChooseCardEffect.java

@@ -8,10 +8,8 @@ import forge.CardLists;
 import forge.CardUtil;
 import forge.Singletons;
 import forge.CardPredicates.Presets;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.cardfactory.CardFactoryUtil;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -23,22 +21,7 @@ public class ChooseCardEffect extends SpellEffect {
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
 
-        if (sa instanceof AbilitySub) {
+        for (final Player p : getTargetPlayers(sa, params)) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
-    
-        ArrayList<Player> tgtPlayers;
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-    
-        for (final Player p : tgtPlayers) {
             sb.append(p).append(" ");
         }
         sb.append("chooses a card.");
@@ -51,14 +34,9 @@ public class ChooseCardEffect extends SpellEffect {
         final Card host = sa.getSourceCard();
         final ArrayList<Card> chosen = new ArrayList<Card>();
 
-        ArrayList<Player> tgtPlayers;
-
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-            tgtPlayers = tgt.getTargetPlayers();
+
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
         ZoneType choiceZone = ZoneType.Battlefield;
         if (params.containsKey("ChoiceZone")) {
             choiceZone = ZoneType.smartValueOf(params.get("ChoiceZone"));

src/main/java/forge/card/abilityfactory/effects/ChooseCardNameEffect.java

@@ -10,10 +10,8 @@ import forge.Card;
 import forge.CardLists;
 import forge.Singletons;
 import forge.CardPredicates.Presets;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.cardfactory.CardFactoryUtil;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -29,22 +27,7 @@ public class ChooseCardNameEffect extends SpellEffect {
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
     
-        if (sa instanceof AbilitySub) {
+        for (final Player p : getTargetPlayers(sa, params)) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
-    
-        ArrayList<Player> tgtPlayers;
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-    
-        for (final Player p : tgtPlayers) {
             sb.append(p).append(" ");
         }
         sb.append("names a card.");
@@ -56,14 +39,8 @@ public class ChooseCardNameEffect extends SpellEffect {
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
         final Card host = sa.getSourceCard();
 
-        ArrayList<Player> tgtPlayers;
-
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
         String valid = "Card";
         String validDesc = "card";

src/main/java/forge/card/abilityfactory/effects/ChooseColorEffect.java

@@ -8,10 +8,8 @@ import forge.CardLists;
 import forge.CardPredicates;
 import forge.Constant;
 import forge.Singletons;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.cardfactory.CardFactoryUtil;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -24,22 +22,7 @@ public class ChooseColorEffect extends SpellEffect {
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
     
-        if (!(sa instanceof AbilitySub)) {
+        for (final Player p : getTargetPlayers(sa, params)) {
-            sb.append(sa.getSourceCard()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-    
-        ArrayList<Player> tgtPlayers;
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-    
-        for (final Player p : tgtPlayers) {
             sb.append(p).append(" ");
         }
         sb.append("chooses a color");
@@ -55,14 +38,9 @@ public class ChooseColorEffect extends SpellEffect {
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
         final Card card = sa.getSourceCard();
 
-        ArrayList<Player> tgtPlayers;
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
 
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
         for (final Player p : tgtPlayers) {
             if ((tgt == null) || p.canBeTargetedBy(sa)) {

src/main/java/forge/card/abilityfactory/effects/ChooseGenericEffect.java

@@ -1,8 +1,8 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.List;
 
 import com.google.common.collect.BiMap;
 import com.google.common.collect.HashBiMap;
@@ -22,31 +22,10 @@ public class ChooseGenericEffect extends SpellEffect {
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
     
-        if (!(sa instanceof AbilitySub)) {
+        for (final Player p : getTargetPlayers(sa, params)) {
-            sb.append(sa.getSourceCard()).append(" - ");
+            sb.append(p).append(" ");
-        } else {
-            sb.append(" ");
         }
-    
+        sb.append("chooses from a list.");
-        if (params.containsKey("StackDescription")) {
-            sb.append(params.get("StackDescription"));
-        }
-        else {
-            ArrayList<Player> tgtPlayers;
-    
-            final Target tgt = sa.getTarget();
-            if (tgt != null) {
-                tgtPlayers = tgt.getTargetPlayers();
-            } else {
-                tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-            }
-    
-            for (final Player p : tgtPlayers) {
-                sb.append(p).append(" ");
-            }
-            sb.append("chooses from a list.");
-        }
-
 
         return sb.toString();
     }
@@ -60,14 +39,9 @@ public class ChooseGenericEffect extends SpellEffect {
             choices.put(s, theseParams.get("ChoiceDescription"));
         }
 
-        ArrayList<Player> tgtPlayers;
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
 
         final Target tgt = sa.getTarget();
-        if (!params.containsKey("Defined")) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
         for (final Player p : tgtPlayers) {
             if (tgt != null && !p.canBeTargetedBy(sa)) {

src/main/java/forge/card/abilityfactory/effects/ChooseNumberEffect.java

@@ -1,16 +1,14 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 import java.util.Random;
 
 import javax.swing.JOptionPane;
 
 import forge.Card;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.cardfactory.CardFactoryUtil;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -26,22 +24,7 @@ public class ChooseNumberEffect extends SpellEffect
     protected String getStackDescription(Map<String, String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
         
-        if (sa instanceof AbilitySub) {
+        for (final Player p : getTargetPlayers(sa, params)) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
-        
-        ArrayList<Player> tgtPlayers;
-        
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-        
-        for (final Player p : tgtPlayers) {
             sb.append(p).append(" ");
         }
         sb.append("chooses a number.");
@@ -82,14 +65,8 @@ public class ChooseNumberEffect extends SpellEffect
             }
         }
         
-        ArrayList<Player> tgtPlayers;
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-        
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
         
         for (final Player p : tgtPlayers) {
             if ((tgt == null) || p.canBeTargetedBy(sa)) {

src/main/java/forge/card/abilityfactory/effects/ChoosePlayerEffect.java

@@ -1,12 +1,12 @@
 package forge.card.abilityfactory.effects;
 
 import java.util.ArrayList;
+import java.util.List;
 
 import forge.Card;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -18,22 +18,7 @@ public class ChoosePlayerEffect extends SpellEffect {
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
 
-        if (sa instanceof AbilitySub) {
+        for (final Player p : getTargetPlayers(sa, params)) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
-        
-        ArrayList<Player> tgtPlayers;
-        
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-        
-        for (final Player p : tgtPlayers) {
             sb.append(p).append(" ");
         }
         sb.append("chooses a player.");
@@ -45,14 +30,9 @@ public class ChoosePlayerEffect extends SpellEffect {
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
         final Card card = sa.getSourceCard();
         
-        ArrayList<Player> tgtPlayers;
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
         
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
         
         final ArrayList<Player> choices = params.containsKey("Choices") ? AbilityFactory.getDefinedPlayers(
                 sa.getSourceCard(), params.get("Choices"), sa) : new ArrayList<Player>(Singletons.getModel().getGame().getPlayers());

src/main/java/forge/card/abilityfactory/effects/ChooseTypeEffect.java

@@ -2,16 +2,15 @@ package forge.card.abilityfactory.effects;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 
 import forge.Card;
 import forge.CardLists;
 import forge.CardUtil;
 import forge.Constant;
 import forge.Singletons;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.cardfactory.CardFactoryUtil;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -25,22 +24,7 @@ public class ChooseTypeEffect extends SpellEffect {
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
 
-        if (!(sa instanceof AbilitySub)) {
+        for (final Player p : getTargetPlayers(sa, params)) {
-            sb.append(sa.getSourceCard()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-        
-        ArrayList<Player> tgtPlayers;
-        
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-        
-        for (final Player p : tgtPlayers) {
             sb.append(p).append(" ");
         }
         sb.append("chooses a type.");
@@ -57,14 +41,8 @@ public class ChooseTypeEffect extends SpellEffect {
             invalidTypes.addAll(Arrays.asList(params.get("InvalidTypes").split(",")));
         }
 
-        ArrayList<Player> tgtPlayers;
-        
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
         
         for (final Player p : tgtPlayers) {
             if ((tgt == null) || p.canBeTargetedBy(sa)) {

src/main/java/forge/card/abilityfactory/effects/ClashEffect.java

@@ -57,19 +57,4 @@ public class ClashEffect extends SpellEffect {
         Singletons.getModel().getGame().getTriggerHandler().runTrigger(TriggerType.Clashed, runParams);
     }
 
-    // *************************************************************************
-    // ************************* FlipACoin *************************************
-    // *************************************************************************
-
-    /**
-     * <p>
-     * flipGetStackDescription.
-     * </p>
-     * 
-     * @param af
-     *            a {@link forge.card.abilityfactory.AbilityFactory} object.
-     * @param sa
-     *            a {@link forge.card.spellability.SpellAbility} object.
-     * @return a {@link java.lang.String} object.
-     */
 }

src/main/java/forge/card/abilityfactory/effects/CloneEffect.java

@@ -2,6 +2,7 @@ package forge.card.abilityfactory.effects;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 import java.util.Map;
 
 import forge.Card;
@@ -12,7 +13,6 @@ import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.AbilityFactoryAttach;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.cardfactory.CardFactoryUtil;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.card.trigger.Trigger;
@@ -23,21 +23,9 @@ public class CloneEffect extends SpellEffect {
 
     @Override
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-         final StringBuilder sb = new StringBuilder();
+        final StringBuilder sb = new StringBuilder();
         
-        if (sa instanceof AbilitySub) {
+        final List<Card> tgts = getTargetCards(sa, params);
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        }
-    
-        final Target tgt = sa.getTarget();
-        ArrayList<Card> tgts;
-        if (tgt != null) {
-            tgts = tgt.getTargetCards();
-        } else {
-            tgts = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-        }
         
         sb.append(sa.getSourceCard());
         sb.append(" becomes a copy of ");

src/main/java/forge/card/abilityfactory/effects/ControlExchangeEffect.java

@@ -6,7 +6,6 @@ import java.util.Map;
 import forge.Card;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -19,7 +18,6 @@ public class ControlExchangeEffect extends SpellEffect {
      */
     @Override
     protected String getStackDescription(Map<String, String> params, SpellAbility sa) {
-        final StringBuilder sb = new StringBuilder();
         Card object1 = null;
         Card object2 = null;
         final Target tgt = sa.getTarget();
@@ -33,14 +31,7 @@ public class ControlExchangeEffect extends SpellEffect {
             object2 = tgts.get(1);
         }
 
-        if (sa instanceof AbilitySub) {
+        return object1 + " exchanges controller with " + object2;
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
-    
-        sb.append(object1 + " exchanges controller with " + object2);
-        return sb.toString();
     }
 
     /* (non-Javadoc)

src/main/java/forge/card/abilityfactory/effects/ControlGainEffect.java

@@ -12,7 +12,6 @@ import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.spellability.Ability;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -26,20 +25,8 @@ public class ControlGainEffect extends SpellEffect {
     protected String getStackDescription(Map<String, String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
     
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-    
-        ArrayList<Card> tgtCards;
 
         final Target tgt = sa.getTarget();
-        if ((tgt != null) && !params.containsKey("Defined")) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         ArrayList<Player> newController = AbilityFactory.getDefinedPlayers(sa.getSourceCard(),
                 params.get("NewController"), sa);
@@ -52,7 +39,7 @@ public class ControlGainEffect extends SpellEffect {
     
         sb.append(newController).append(" gains control of ");
     
-        for (final Card c : tgtCards) {
+        for (final Card c : getTargetCards(sa, params)) {
             sb.append(" ");
             if (c.isFaceDown()) {
                 sb.append("Morph");
@@ -62,11 +49,6 @@ public class ControlGainEffect extends SpellEffect {
         }
         sb.append(".");
     
-        final AbilitySub abSub = sa.getSubAbility();
-        if (abSub != null) {
-            sb.append(abSub.getStackDescription());
-        }
-    
         return sb.toString();
     }
 
@@ -111,11 +93,8 @@ public class ControlGainEffect extends SpellEffect {
         if (params.containsKey("AllValid")) {
             tgtCards = Singletons.getModel().getGame().getCardsIn(ZoneType.Battlefield);
             tgtCards = AbilityFactory.filterListByType(tgtCards, params.get("AllValid"), sa);
-        } else if ((tgt != null) && !params.containsKey("Defined")) {
+        } else 
-            tgtCards.addAll(tgt.getTargetCards());
+            tgtCards = getTargetCards(sa, params);
-        } else {
-            tgtCards.addAll(AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa));
-        }
     
         ArrayList<Player> controllers = new ArrayList<Player>();
     

src/main/java/forge/card/abilityfactory/effects/CopyPermanentEffect.java

@@ -3,6 +3,7 @@ package forge.card.abilityfactory.effects;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Iterator;
+import java.util.List;
 
 import forge.Card;
 import forge.CardCharacteristicName;
@@ -12,7 +13,6 @@ import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.cardfactory.CardFactoryUtil;
 import forge.card.spellability.Ability;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.item.CardDb;
@@ -24,20 +24,7 @@ public class CopyPermanentEffect extends SpellEffect {
         final StringBuilder sb = new StringBuilder();
 
 
-        if (!(sa instanceof AbilitySub)) {
+        final List<Card> tgtCards = getTargetCards(sa, params);
-            sb.append(sa.getSourceCard()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-    
-        ArrayList<Card> tgtCards;
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
         sb.append("Copy ");
         final Iterator<Card> it = tgtCards.iterator();

src/main/java/forge/card/abilityfactory/effects/CopySpellEffect.java

@@ -2,20 +2,56 @@ package forge.card.abilityfactory.effects;
 
 import java.util.ArrayList;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 
 import forge.Card;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
-import forge.card.spellability.Target;
 import forge.game.player.Player;
 import forge.gui.GuiChoose;
 
 public class CopySpellEffect extends SpellEffect {
     
+    /**
+     * <p>
+     * copySpellStackDescription.
+     * </p>
+     * 
+     * @param af
+     *            a {@link forge.card.abilityfactory.AbilityFactory} object.
+     * @param sa
+     *            a {@link forge.card.spellability.SpellAbility} object.
+     * @return a {@link java.lang.String} object.
+     */
+    @Override
+    protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
+        final StringBuilder sb = new StringBuilder();
+        final List<SpellAbility> tgtSpells = getTargetSpellAbilities(sa, params);
+        
+        sb.append("Copy ");
+        // TODO Someone fix this Description when Copying Charms
+        final Iterator<SpellAbility> it = tgtSpells.iterator();
+        while (it.hasNext()) {
+            sb.append(it.next().getSourceCard());
+            if (it.hasNext()) {
+                sb.append(", ");
+            }
+        }
+        int amount = 1;
+        if (params.containsKey("Amount")) {
+            amount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("Amount"), sa);
+        }
+        if (amount > 1) {
+            sb.append(amount).append(" times");
+        }
+        sb.append(".");
+        // TODO probably add an optional "You may choose new targets..."
+        return sb.toString();
+    }
+
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellEffect#resolve(java.util.Map, forge.card.spellability.SpellAbility)
      */
@@ -33,14 +69,8 @@ public class CopySpellEffect extends SpellEffect {
             controller = AbilityFactory.getDefinedPlayers(card, params.get("Controller"), sa).get(0);
         }
 
-        ArrayList<SpellAbility> tgtSpells;
+        final List<SpellAbility> tgtSpells = getTargetSpellAbilities(sa, params);
 
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtSpells = tgt.getTargetSAs();
-        } else {
-            tgtSpells = AbilityFactory.getDefinedSpellAbilities(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
         if (tgtSpells.size() == 0) {
             return;
@@ -98,55 +128,4 @@ public class CopySpellEffect extends SpellEffect {
         }
     } // end resolve
 
-    /**
-     * <p>
-     * copySpellStackDescription.
-     * </p>
-     * 
-     * @param af
-     *            a {@link forge.card.abilityfactory.AbilityFactory} object.
-     * @param sa
-     *            a {@link forge.card.spellability.SpellAbility} object.
-     * @return a {@link java.lang.String} object.
-     */
-    @Override
-    protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-        final StringBuilder sb = new StringBuilder();
-    
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-    
-        ArrayList<SpellAbility> tgtSpells;
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtSpells = tgt.getTargetSAs();
-        } else {
-            tgtSpells = AbilityFactory.getDefinedSpellAbilities(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-    
-        sb.append("Copy ");
-        // TODO Someone fix this Description when Copying Charms
-        final Iterator<SpellAbility> it = tgtSpells.iterator();
-        while (it.hasNext()) {
-            sb.append(it.next().getSourceCard());
-            if (it.hasNext()) {
-                sb.append(", ");
-            }
-        }
-        int amount = 1;
-        if (params.containsKey("Amount")) {
-            amount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("Amount"), sa);
-        }
-        if (amount > 1) {
-            sb.append(amount).append(" times");
-        }
-        sb.append(".");
-        // TODO probably add an optional "You may choose new targets..."
-        return sb.toString();
-    }
-
 } // end class AbilityFactory_Copy

src/main/java/forge/card/abilityfactory/effects/CounterEffect.java

@@ -1,27 +1,24 @@
 package forge.card.abilityfactory.effects;
 
 import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 
 import forge.Card;
 import forge.Singletons;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.cardfactory.CardFactoryUtil;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.SpellAbilityStackInstance;
 import forge.card.spellability.SpellPermanent;
-import forge.card.spellability.Target;
 
 public class CounterEffect extends SpellEffect {
     @Override
-    public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
+    protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-        // TODO Before this resolves we should see if any of our targets are
+    
-        // still on the stack
+        final StringBuilder sb = new StringBuilder();
-        ArrayList<SpellAbility> sas;
+        final List<SpellAbility> sas;
     
-        final Target tgt = sa.getTarget();
         if (params.containsKey("AllType")) {
             sas = new ArrayList<SpellAbility>();
             for (int i=0; i < Singletons.getModel().getGame().getStack().size(); i++) {
@@ -36,12 +33,52 @@ public class CounterEffect extends SpellEffect {
                 }
                 sas.add(spell);
             }
-        } else if (tgt != null) {
+        } else 
-            sas = tgt.getTargetSAs();
+            sas = getTargetSpellAbilities(sa, params);
-        } else {
+    
-            sas = AbilityFactory.getDefinedSpellAbilities(sa.getSourceCard(), params.get("Defined"), sa);
+        sb.append("countering");
+    
+        boolean isAbility = false;
+        for (final SpellAbility tgtSA : sas) {
+            sb.append(" ");
+            sb.append(tgtSA.getSourceCard());
+            isAbility = tgtSA.isAbility();
+            if (isAbility) {
+                sb.append("'s ability");
+            }
         }
     
+        if (isAbility && params.containsKey("DestroyPermanent")) {
+            sb.append(" and destroy it");
+        }
+    
+        sb.append(".");
+        return sb.toString();
+    } // end counterStackDescription
+
+    @Override
+    public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
+        // TODO Before this resolves we should see if any of our targets are
+        // still on the stack
+        final List<SpellAbility> sas;
+    
+        if (params.containsKey("AllType")) {
+            sas = new ArrayList<SpellAbility>();
+            for (int i=0; i < Singletons.getModel().getGame().getStack().size(); i++) {
+                SpellAbility spell = Singletons.getModel().getGame().getStack().peekAbility(i);
+                if (params.get("AllType").equals("Spell") && !spell.isSpell()) {
+                    continue;
+                }
+                if (params.containsKey("AllValid")) {
+                    if (!spell.getSourceCard().isValid(params.get("AllValid"), sa.getActivatingPlayer(), sa.getSourceCard())) {
+                        continue;
+                    }
+                }
+                sas.add(spell);
+            }
+        } else 
+            sas = getTargetSpellAbilities(sa, params);
+    
         if (params.containsKey("ForgetOtherTargets")) {
             if (params.get("ForgetOtherTargets").equals("True")) {
                 sa.getSourceCard().clearRemembered();
@@ -75,60 +112,6 @@ public class CounterEffect extends SpellEffect {
         }
     } // end counterResolve
 
-    @Override
-    protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-
-        final StringBuilder sb = new StringBuilder();
-
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-
-        ArrayList<SpellAbility> sas;
-
-        final Target tgt = sa.getTarget();
-        if (params.containsKey("AllType")) {
-            sas = new ArrayList<SpellAbility>();
-            for (int i=0; i < Singletons.getModel().getGame().getStack().size(); i++) {
-                SpellAbility spell = Singletons.getModel().getGame().getStack().peekAbility(i);
-                if (params.get("AllType").equals("Spell") && !spell.isSpell()) {
-                    continue;
-                }
-                if (params.containsKey("AllValid")) {
-                    if (!spell.getSourceCard().isValid(params.get("AllValid"), sa.getActivatingPlayer(), sa.getSourceCard())) {
-                        continue;
-                    }
-                }
-                sas.add(spell);
-            }
-        } else if (tgt != null) {
-            sas = tgt.getTargetSAs();
-        } else {
-            sas = AbilityFactory.getDefinedSpellAbilities(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-
-        sb.append("countering");
-
-        boolean isAbility = false;
-        for (final SpellAbility tgtSA : sas) {
-            sb.append(" ");
-            sb.append(tgtSA.getSourceCard());
-            isAbility = tgtSA.isAbility();
-            if (isAbility) {
-                sb.append("'s ability");
-            }
-        }
-
-        if (isAbility && params.containsKey("DestroyPermanent")) {
-            sb.append(" and destroy it");
-        }
-
-        sb.append(".");
-        return sb.toString();
-    } // end counterStackDescription
-
     /**
      * <p>
      * removeFromStack.

src/main/java/forge/card/abilityfactory/effects/CountersMoveEffect.java

@@ -1,12 +1,12 @@
 package forge.card.abilityfactory.effects;
 
 import java.util.ArrayList;
+import java.util.List;
 
 import forge.Card;
 import forge.Counters;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 
@@ -17,12 +17,6 @@ public class CountersMoveEffect extends SpellEffect {
         final StringBuilder sb = new StringBuilder();
         final Card host = sa.getSourceCard();
     
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        }
-    
         Card source = null;
         ArrayList<Card> srcCards;
         final Target tgt = sa.getTarget();
@@ -34,12 +28,7 @@ public class CountersMoveEffect extends SpellEffect {
         if (srcCards.size() > 0) {
             source = srcCards.get(0);
         }
-        ArrayList<Card> tgtCards;
+        final List<Card> tgtCards = getTargetCards(sa, params);
-        if (!params.containsKey("Defined") && tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(host, params.get("Defined"), sa);
-        }
     
         final Counters cType = Counters.valueOf(params.get("CounterType"));
         final int amount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("CounterNum"), sa);

src/main/java/forge/card/abilityfactory/effects/CountersProliferateEffect.java

@@ -14,7 +14,6 @@ import forge.Counters;
 import forge.Singletons;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.cardfactory.CardFactoryUtil;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.control.input.Input;
 import forge.game.player.Player;
@@ -28,11 +27,6 @@ public class CountersProliferateEffect extends SpellEffect {
     @Override
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
         sb.append("Proliferate.");
         sb.append(" (You choose any number of permanents and/or players with ");
         sb.append("counters on them, then give each another counter of a kind already there.)");

src/main/java/forge/card/abilityfactory/effects/CountersPutAllEffect.java

@@ -8,7 +8,6 @@ import forge.Counters;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -16,6 +15,28 @@ import forge.game.zone.ZoneType;
 
 public class CountersPutAllEffect extends SpellEffect  { 
 
+    @Override
+    protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
+        final StringBuilder sb = new StringBuilder();
+    
+        final Counters cType = Counters.valueOf(params.get("CounterType"));
+        final int amount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("CounterNum"), sa);
+        final String zone = params.containsKey("ValidZone") ? params.get("ValidZone") : "Battlefield";
+    
+        sb.append("Put ").append(amount).append(" ").append(cType.getName()).append(" counter");
+        if (amount != 1) {
+            sb.append("s");
+        }
+        sb.append(" on each valid ");
+        if (zone.matches("Battlefield")) {
+            sb.append("permanent.");
+        } else {
+            sb.append("card in ").append(zone).append(".");
+        }
+    
+        return sb.toString();
+    }
+
     @Override
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
         final String type = params.get("CounterType");
@@ -42,32 +63,4 @@ public class CountersPutAllEffect extends SpellEffect  {
         }
     }
 
-    @Override
-    protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-        final StringBuilder sb = new StringBuilder();
-    
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-    
-        final Counters cType = Counters.valueOf(params.get("CounterType"));
-        final int amount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("CounterNum"), sa);
-        final String zone = params.containsKey("ValidZone") ? params.get("ValidZone") : "Battlefield";
-    
-        sb.append("Put ").append(amount).append(" ").append(cType.getName()).append(" counter");
-        if (amount != 1) {
-            sb.append("s");
-        }
-        sb.append(" on each valid ");
-        if (zone.matches("Battlefield")) {
-            sb.append("permanent.");
-        } else {
-            sb.append("card in ").append(zone).append(".");
-        }
-
-        return sb.toString();
-    }
-
 }

src/main/java/forge/card/abilityfactory/effects/CountersPutEffect.java

@@ -2,13 +2,13 @@ package forge.card.abilityfactory.effects;
 
 import java.util.ArrayList;
 import java.util.Iterator;
+import java.util.List;
 
 import forge.Card;
 import forge.Counters;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.zone.Zone;
@@ -16,6 +16,44 @@ import forge.game.zone.ZoneType;
 import forge.gui.GuiChoose;
 
 public class CountersPutEffect extends SpellEffect {
+    @Override
+    protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
+        final StringBuilder sb = new StringBuilder();
+        final Card card = sa.getSourceCard();
+    
+
+        final Counters cType = Counters.valueOf(params.get("CounterType"));
+        final int amount = AbilityFactory.calculateAmount(card, params.get("CounterNum"), sa);
+        sb.append("Put ");
+        if (params.containsKey("UpTo")) {
+            sb.append("up to ");
+        }
+        sb.append(amount).append(" ").append(cType.getName()).append(" counter");
+        if (amount != 1) {
+            sb.append("s");
+        }
+        sb.append(" on ");
+        final Target tgt = sa.getTarget();
+        final List<Card> tgtCards = tgt != null ? tgt.getTargetCards() :  AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
+
+        final Iterator<Card> it = tgtCards.iterator();
+        while (it.hasNext()) {
+            final Card tgtC = it.next();
+            if (tgtC.isFaceDown()) {
+                sb.append("Morph");
+            } else {
+                sb.append(tgtC);
+            }
+
+            if (it.hasNext()) {
+                sb.append(", ");
+            }
+        }
+        sb.append(".");
+    
+        return sb.toString();
+    }
+
     @Override
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
         final Card card = sa.getSourceCard();
@@ -63,55 +101,4 @@ public class CountersPutEffect extends SpellEffect {
         }
     }
 
-    @Override
-    protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-        final StringBuilder sb = new StringBuilder();
-        final Card card = sa.getSourceCard();
-    
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(card.getName()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-    
-        if (params.containsKey("StackDescription")) {
-            sb.append(params.get("StackDescription"));
-        } else {
-            final Counters cType = Counters.valueOf(params.get("CounterType"));
-            final int amount = AbilityFactory.calculateAmount(card, params.get("CounterNum"), sa);
-            sb.append("Put ");
-            if (params.containsKey("UpTo")) {
-                sb.append("up to ");
-            }
-            sb.append(amount).append(" ").append(cType.getName()).append(" counter");
-            if (amount != 1) {
-                sb.append("s");
-            }
-            sb.append(" on ");
-            ArrayList<Card> tgtCards;
-            final Target tgt = sa.getTarget();
-            if (tgt != null) {
-                tgtCards = tgt.getTargetCards();
-            } else {
-                tgtCards = AbilityFactory.getDefinedCards(card, params.get("Defined"), sa);
-            }
-            final Iterator<Card> it = tgtCards.iterator();
-            while (it.hasNext()) {
-                final Card tgtC = it.next();
-                if (tgtC.isFaceDown()) {
-                    sb.append("Morph");
-                } else {
-                    sb.append(tgtC);
-                }
-    
-                if (it.hasNext()) {
-                    sb.append(", ");
-                }
-            }
-            sb.append(".");
-        }
-
-        return sb.toString();
-    }
-
 }

src/main/java/forge/card/abilityfactory/effects/CountersRemoveAllEffect.java

@@ -8,7 +8,6 @@ import forge.Counters;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -19,12 +18,6 @@ public class CountersRemoveAllEffect extends SpellEffect {
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
 
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-    
         final Counters cType = Counters.valueOf(params.get("CounterType"));
         final int amount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("CounterNum"), sa);
         final String zone = params.containsKey("ValidZone") ? params.get("ValidZone") : "Battlefield";

src/main/java/forge/card/abilityfactory/effects/CountersRemoveEffect.java

@@ -9,7 +9,6 @@ import forge.Counters;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.zone.Zone;
@@ -17,6 +16,43 @@ import forge.game.zone.ZoneType;
 import forge.gui.GuiChoose;
 
 public class CountersRemoveEffect extends SpellEffect { 
+    @Override
+    protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
+        final StringBuilder sb = new StringBuilder();
+    
+        final String counterName = params.get("CounterType");
+    
+        final int amount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("CounterNum"), sa);
+    
+        sb.append("Remove ");
+        if (params.containsKey("UpTo")) {
+            sb.append("up to ");
+        }
+        if ("Any".matches(counterName)) {
+            if (amount == 1) {
+                sb.append("a counter");
+            }
+            else {
+                sb.append(amount).append(" ").append(" counter");
+            }
+        }
+        else {
+            sb.append(amount).append(" ").append(Counters.valueOf(counterName).getName()).append(" counter");
+        }
+        if (amount != 1) {
+            sb.append("s");
+        }
+        sb.append(" from");
+    
+        for (final Card c : getTargetCards(sa, params)) {
+            sb.append(" ").append(c);
+        }
+    
+        sb.append(".");
+    
+        return sb.toString();
+    }
+
     @Override
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
 
@@ -27,20 +63,13 @@ public class CountersRemoveEffect extends SpellEffect {
             counterAmount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("CounterNum"), sa);
         }
 
-        ArrayList<Card> tgtCards;
-
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(card, params.get("Defined"), sa);
-        }
         
         boolean rememberRemoved = false;
         if (params.containsKey("RememberRemoved")) {
             rememberRemoved = true;
         }
-        for (final Card tgtCard : tgtCards) {
+        for (final Card tgtCard : getTargetCards(sa, params)) {
             if ((tgt == null) || tgtCard.canBeTargetedBy(sa)) {
                 final Zone zone = Singletons.getModel().getGame().getZoneOf(tgtCard);
                 if (params.get("CounterNum").equals("All")) {
@@ -129,56 +158,4 @@ public class CountersRemoveEffect extends SpellEffect {
         }
     }
 
-    @Override
-    protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-        final Card card = sa.getSourceCard();
-        final StringBuilder sb = new StringBuilder();
-    
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(card).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-    
-        final String counterName = params.get("CounterType");
-    
-        final int amount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("CounterNum"), sa);
-    
-        sb.append("Remove ");
-        if (params.containsKey("UpTo")) {
-            sb.append("up to ");
-        }
-        if ("Any".matches(counterName)) {
-            if (amount == 1) {
-                sb.append("a counter");
-            }
-            else {
-                sb.append(amount).append(" ").append(" counter");
-            }
-        }
-        else {
-            sb.append(amount).append(" ").append(Counters.valueOf(counterName).getName()).append(" counter");
-        }
-        if (amount != 1) {
-            sb.append("s");
-        }
-        sb.append(" from");
-    
-        ArrayList<Card> tgtCards;
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(card, params.get("Defined"), sa);
-        }
-        for (final Card c : tgtCards) {
-            sb.append(" ").append(c);
-        }
-    
-        sb.append(".");
-    
-        return sb.toString();
-    }
-
 }

src/main/java/forge/card/abilityfactory/effects/DamageAllEffect.java

@@ -8,7 +8,6 @@ import forge.CardLists;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -39,27 +38,20 @@ public class DamageAllEffect extends SpellEffect {
         final String damage = params.get("NumDmg");
         final int dmg = AbilityFactory.calculateAmount(sa.getSourceCard(), damage, sa); 
     
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard().getName()).append(" -");
-        }
-        sb.append(" ");
 
-        if (params.containsKey("StackDescription")) {
+    
-            sb.append(params.get("StackDescription"));
+        final ArrayList<Card> definedSources = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("DamageSource"), sa);
+        final Card source = definedSources.get(0);
+
+        if (source != sa.getSourceCard()) {
+            sb.append(source.toString()).append(" deals");
         } else {
-            final ArrayList<Card> definedSources = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("DamageSource"), sa);
+            sb.append("Deals");
-            final Card source = definedSources.get(0);
-    
-            if (source != sa.getSourceCard()) {
-                sb.append(source.toString()).append(" deals");
-            } else {
-                sb.append("Deals");
-            }
-    
-            sb.append(" ").append(dmg).append(" damage to ").append(desc);
         }
 
-        return sb.toString();
+        sb.append(" ").append(dmg).append(" damage to ").append(desc);
+
+            return sb.toString();
     }
 
     /**

src/main/java/forge/card/abilityfactory/effects/DamageDealEffect.java

@@ -2,13 +2,13 @@ package forge.card.abilityfactory.effects;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 import forge.Card;
 import forge.CardUtil;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.game.player.Player;
 
@@ -24,66 +24,53 @@ public class DamageDealEffect extends SpellEffect {
         final String damage = params.get("NumDmg");
         final int dmg = AbilityFactory.calculateAmount(sa.getSourceCard(), damage, sa); 
 
-        ArrayList<Object> tgts;
-        if (sa.getTarget() == null) {
-            tgts = AbilityFactory.getDefinedObjects(sa.getSourceCard(), params.get("Defined"), sa);
-        } else {
-            tgts = sa.getTarget().getTargets();
-        }
 
+        List<Object> tgts = getTargetObjects(sa, params);
         if (tgts.size() > 0) {
-            if (!(sa instanceof AbilitySub)) {
-                sb.append(sa.getSourceCard().getName()).append(" -");
-            }
-            sb.append(" ");
 
-            if (params.containsKey("StackDescription")) {
+            final String conditionDesc = params.get("ConditionDescription");
-                sb.append(params.get("StackDescription"));
+            if (conditionDesc != null) {
+                sb.append(conditionDesc).append(" ");
             }
-            else {
+
-                final String conditionDesc = params.get("ConditionDescription");
+            final ArrayList<Card> definedSources = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("DamageSource"), sa);
-                if (conditionDesc != null) {
+            final Card source = definedSources.get(0);
-                    sb.append(conditionDesc).append(" ");
+
+            if (source != sa.getSourceCard()) {
+                sb.append(source.toString()).append(" deals");
+            } else {
+                sb.append("Deals");
+            }
+
+            sb.append(" ").append(dmg).append(" damage ");
+            
+            if (params.containsKey("DivideEvenly")) {
+                sb.append("divided evenly (rounded down) ");
+            }
+            
+            sb.append("to");
+
+            for (int i = 0; i < tgts.size(); i++) {
+                sb.append(" ");
+
+                final Object o = tgts.get(i);
+                if ((o instanceof Card) || (o instanceof Player)) {
+                    sb.append(o.toString());
                 }
+            }
 
-                final ArrayList<Card> definedSources = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("DamageSource"), sa);
+            if (params.containsKey("Radiance")) {
-                final Card source = definedSources.get(0);
+                sb.append(" and each other ").append(params.get("ValidTgts"))
-    
+                        .append(" that shares a color with ");
-                if (source != sa.getSourceCard()) {
+                if (tgts.size() > 1) {
-                    sb.append(source.toString()).append(" deals");
+                    sb.append("them");
                 } else {
-                    sb.append("Deals");
+                    sb.append("it");
                 }
-    
-                sb.append(" ").append(dmg).append(" damage ");
-                
-                if (params.containsKey("DivideEvenly")) {
-                    sb.append("divided evenly (rounded down) ");
-                }
-                
-                sb.append("to");
-    
-                for (int i = 0; i < tgts.size(); i++) {
-                    sb.append(" ");
-    
-                    final Object o = tgts.get(i);
-                    if ((o instanceof Card) || (o instanceof Player)) {
-                        sb.append(o.toString());
-                    }
-                }
-    
-                if (params.containsKey("Radiance")) {
-                    sb.append(" and each other ").append(params.get("ValidTgts"))
-                            .append(" that shares a color with ");
-                    if (tgts.size() > 1) {
-                        sb.append("them");
-                    } else {
-                        sb.append("it");
-                    }
-                }
-    
-                sb.append(". ");
             }
+
+            sb.append(". ");
+
         }
 
         return sb.toString();

src/main/java/forge/card/abilityfactory/effects/DamageEachEffect.java

@@ -10,9 +10,7 @@ import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.cardfactory.CardFactoryUtil;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
-import forge.card.spellability.Target;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -27,21 +25,6 @@ public class DamageEachEffect extends SpellEffect {
         final String damage = params.get("NumDmg");
         final int iDmg = AbilityFactory.calculateAmount(sa.getSourceCard(), damage, sa); 
         
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
-    
-        ArrayList<Player> tgtPlayers;
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("DefinedPlayers"), sa);
-        }
-    
         String desc = params.get("ValidCards");
         if (params.containsKey("ValidDescription")) {
             desc = params.get("ValidDescription");
@@ -58,7 +41,7 @@ public class DamageEachEffect extends SpellEffect {
             sb.append(params.get("StackDescription"));
         } else {
             sb.append("Each ").append(desc).append(" deals ").append(dmg).append(" to ");
-            for (final Player p : tgtPlayers) {
+            for (final Player p : getTargetPlayers(sa, params)) {
                 sb.append(p);
             }
             if (params.containsKey("DefinedCards")) {

src/main/java/forge/card/abilityfactory/effects/DamagePreventAllEffect.java

@@ -8,15 +8,11 @@ import forge.Card;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
 public class DamagePreventAllEffect extends SpellEffect {
-    /* (non-Javadoc)
-     * @see forge.card.abilityfactory.SpellEffect#getStackDescription(java.util.Map, forge.card.spellability.SpellAbility)
-     */
     
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellEffect#resolve(java.util.Map, forge.card.spellability.SpellAbility)
@@ -56,20 +52,11 @@ public class DamagePreventAllEffect extends SpellEffect {
     @Override
     protected String getStackDescription(Map<String, String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
-        final Card host = sa.getAbilityFactory().getHostCard();
-    
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(host).append(" - ");
-        }
-    
         String desc = sa.getDescription();
     
         if (desc.contains(":")) {
             desc = desc.split(":")[1];
         }
-    
         sb.append(desc);
     
         return sb.toString();

src/main/java/forge/card/abilityfactory/effects/DamagePreventEffect.java

@@ -1,13 +1,13 @@
 package forge.card.abilityfactory.effects;
 
 import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 
 import forge.Card;
 import forge.CardUtil;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.game.player.Player;
 
@@ -16,20 +16,8 @@ public class DamagePreventEffect extends SpellEffect
     @Override
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
-        final Card host = sa.getAbilityFactory().getHostCard();
     
-        ArrayList<Object> tgts;
+        final List<Object> tgts = getTargetObjects(sa, params);
-        if (sa.getTarget() == null) {
-            tgts = AbilityFactory.getDefinedObjects(sa.getSourceCard(), params.get("Defined"), sa);
-        } else {
-            tgts = sa.getTarget().getTargets();
-        }
-    
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(host).append(" - ");
-        }
 
         sb.append("Prevent the next ");
         sb.append(params.get("Amount"));

src/main/java/forge/card/abilityfactory/effects/DebuffAllEffect.java

@@ -10,7 +10,6 @@ import forge.CardLists;
 import forge.Command;
 import forge.Singletons;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
@@ -21,23 +20,11 @@ public class DebuffAllEffect extends SpellEffect {
      */
     @Override
     protected String getStackDescription(Map<String, String> params, SpellAbility sa) {
-        final StringBuilder sb = new StringBuilder();
+        if (params.containsKey("DebuffAllDescription")) {
-
+            return params.get("DebuffAllDescription");
-        String desc = "";
-        if (params.containsKey("SpellDescription")) {
-            desc = params.get("SpellDescription");
-        } else if (params.containsKey("DebuffAllDescription")) {
-            desc = params.get("DebuffAllDescription");
         }
 
-        if (sa instanceof AbilitySub) {
+        return "";
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
-
-        sb.append(desc);
-        return sb.toString();
     } // debuffAllStackDescription()
 
     /**

src/main/java/forge/card/abilityfactory/effects/DebuffEffect.java

@@ -8,34 +8,21 @@ import java.util.List;
 import forge.Card;
 import forge.Command;
 import forge.Singletons;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
-import forge.card.spellability.Target;
 
 public class DebuffEffect extends SpellEffect {
     
     @Override
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-        final Card host = sa.getAbilityFactory().getHostCard();
         final List<String> kws = params.containsKey("Keywords") ? Arrays.asList(params.get("Keywords").split(" & ")) : new ArrayList<String>();
         final StringBuilder sb = new StringBuilder();
     
-        ArrayList<Card> tgtCards;
+        final List<Card> tgtCards = getTargetCards(sa, params);
-        final Target tgt = sa.getTarget();
+
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         if (tgtCards.size() > 0) {
-            if (sa instanceof AbilitySub) {
+
-                sb.append(" ");
-            } else {
-                sb.append(host).append(" - ");
-            }
     
             final Iterator<Card> it = tgtCards.iterator();
             while (it.hasNext()) {
@@ -68,19 +55,9 @@ public class DebuffEffect extends SpellEffect {
 
     @Override
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
-        final Card host = sa.getAbilityFactory().getHostCard();
-
         final List<String> kws = params.containsKey("Keywords") ? Arrays.asList(params.get("Keywords").split(" & ")) : new ArrayList<String>();
 
-        ArrayList<Card> tgtCards;
+        for (final Card tgtC : getTargetCards(sa, params)) {
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(host, params.get("Defined"), sa);
-        }
-
-        for (final Card tgtC : tgtCards) {
             final ArrayList<String> hadIntrinsic = new ArrayList<String>();
             if (tgtC.isInPlay() && tgtC.canBeTargetedBy(sa)) {
                 for (final String kw : kws) {

src/main/java/forge/card/abilityfactory/effects/DelayedTriggerEffect.java

@@ -2,7 +2,6 @@ package forge.card.abilityfactory.effects;
 
 import forge.Singletons;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.trigger.Trigger;
 import forge.card.trigger.TriggerHandler;
@@ -14,21 +13,11 @@ public class DelayedTriggerEffect extends SpellEffect {
      */
     @Override
     protected String getStackDescription(java.util.Map<String,String> mapParams, SpellAbility sa) {
-        final StringBuilder sb = new StringBuilder();
+        if (mapParams.containsKey("TriggerDescription")) {
-
+            return mapParams.get("TriggerDescription");
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
         }
 
-        if (mapParams.containsKey("SpellDescription")) {
+        return "";
-            sb.append(mapParams.get("SpellDescription"));
-        } else if (mapParams.containsKey("TriggerDescription")) {
-            sb.append(mapParams.get("TriggerDescription"));
-        }
-
-        return sb.toString();
 
     }
 

src/main/java/forge/card/abilityfactory/effects/DestroyAllEffect.java

@@ -9,7 +9,6 @@ import forge.CardLists;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -17,6 +16,37 @@ import forge.game.zone.ZoneType;
 
 public class DestroyAllEffect extends SpellEffect {
     
+    @Override
+    protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
+    
+        final StringBuilder sb = new StringBuilder();
+        final boolean noRegen = params.containsKey("NoRegen");
+    
+
+        final String conditionDesc = params.get("ConditionDescription");
+        if (conditionDesc != null) {
+            sb.append(conditionDesc).append(" ");
+        }
+
+        ArrayList<Card> tgtCards;
+
+        final Target tgt = sa.getTarget();
+        if (tgt != null) {
+            tgtCards = tgt.getTargetCards();
+        } else {
+            tgtCards = new ArrayList<Card>();
+            tgtCards.add(sa.getSourceCard());
+        }
+
+        sb.append(sa.getSourceCard().getName()).append(" - Destroy permanents.");
+
+        if (noRegen) {
+            sb.append(" They can't be regenerated");
+        }
+
+        return sb.toString();
+    }
+
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellEffect#resolve(java.util.Map, forge.card.spellability.SpellAbility)
      */
@@ -77,43 +107,4 @@ public class DestroyAllEffect extends SpellEffect {
         }
     }
 
-    @Override
-    protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-    
-        final StringBuilder sb = new StringBuilder();
-        final String name = sa.getAbilityFactory().getHostCard().getName();
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-        final boolean noRegen = params.containsKey("NoRegen");
-    
-        if (params.containsKey("SpellDescription")) {
-            sb.append(params.get("SpellDescription"));
-        } else {
-            final String conditionDesc = params.get("ConditionDescription");
-            if (conditionDesc != null) {
-                sb.append(conditionDesc).append(" ");
-            }
-    
-            ArrayList<Card> tgtCards;
-    
-            final Target tgt = sa.getTarget();
-            if (tgt != null) {
-                tgtCards = tgt.getTargetCards();
-            } else {
-                tgtCards = new ArrayList<Card>();
-                tgtCards.add(sa.getSourceCard());
-            }
-    
-            sb.append(name).append(" - Destroy permanents.");
-    
-            if (noRegen) {
-                sb.append(" They can't be regenerated");
-            }
-        }
-        return sb.toString();
-    }
-
 } 

src/main/java/forge/card/abilityfactory/effects/DestroyEffect.java

@@ -2,12 +2,12 @@ package forge.card.abilityfactory.effects;
 
 import java.util.ArrayList;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 
 import forge.Card;
 import forge.CardUtil;
 import forge.Singletons;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
@@ -21,27 +21,13 @@ public class DestroyEffect extends SpellEffect {
     protected String getStackDescription(Map<String, String> params, SpellAbility sa) {
         final boolean noRegen = params.containsKey("NoRegen");
         final StringBuilder sb = new StringBuilder();
-        final Card host = sa.getAbilityFactory().getHostCard();
 
         final String conditionDesc = params.get("ConditionDescription");
         if (conditionDesc != null) {
             sb.append(conditionDesc).append(" ");
         }
 
-        ArrayList<Card> tgtCards;
+        final List<Card> tgtCards = getTargetCards(sa, params);
-
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(host).append(" - ");
-        }
 
         if (params.containsKey("Sacrifice")) {
             sb.append("Sacrifice ");
@@ -104,15 +90,10 @@ public class DestroyEffect extends SpellEffect {
         final boolean noRegen = params.containsKey("NoRegen");
         final boolean sac = params.containsKey("Sacrifice");
 
-        ArrayList<Card> tgtCards;
+        final List<Card> tgtCards = getTargetCards(sa, params);
         final ArrayList<Card> untargetedCards = new ArrayList<Card>();
 
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
         if (params.containsKey("Radiance")) {
             for (final Card c : CardUtil.getRadiance(card, tgtCards.get(0),

src/main/java/forge/card/abilityfactory/effects/DigEffect.java

@@ -13,7 +13,6 @@ import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.cardfactory.CardFactoryUtil;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -29,25 +28,9 @@ public class DigEffect extends SpellEffect {
         final StringBuilder sb = new StringBuilder();
         final int numToDig = AbilityFactory.calculateAmount(host, params.get("DigNum"), sa);
     
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
     
-        if (params.containsKey("StackDescription")) {
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-            sb.append(params.get("StackDescription"));
-            return sb.toString();
-        }
     
-        ArrayList<Player> tgtPlayers;
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         sb.append(host.getController()).append(" looks at the top ").append(numToDig);
         sb.append(" card");
@@ -104,14 +87,8 @@ public class DigEffect extends SpellEffect {
             }
         }
 
-        ArrayList<Player> tgtPlayers;
-
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
         if (params.containsKey("Choser")) {
             final ArrayList<Player> chosers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(),

src/main/java/forge/card/abilityfactory/effects/DigUntilEffect.java

@@ -9,7 +9,6 @@ import forge.Card;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -25,7 +24,6 @@ public class DigUntilEffect extends SpellEffect {
          */
     @Override
     protected String getStackDescription(Map<String, String> params, SpellAbility sa) {
-        final Card host = sa.getSourceCard();
         final StringBuilder sb = new StringBuilder();
     
         String desc = "Card";
@@ -38,22 +36,7 @@ public class DigUntilEffect extends SpellEffect {
             untilAmount = AbilityFactory.calculateAmount(sa.getAbilityFactory().getHostCard(), params.get("Amount"), sa);
         }
 
-        if (!(sa instanceof AbilitySub)) {
+        for (final Player pl : getTargetPlayers(sa, params)) {
-            sb.append(host).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-    
-        ArrayList<Player> tgtPlayers;
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-    
-        for (final Player pl : tgtPlayers) {
             sb.append(pl).append(" ");
         }
     
@@ -110,21 +93,14 @@ public class DigUntilEffect extends SpellEffect {
 
         final boolean remember = params.containsKey("RememberFound");
 
-        ArrayList<Player> tgtPlayers;
-
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(host, params.get("Defined"), sa);
-        }
 
         final ZoneType foundDest = ZoneType.smartValueOf(params.get("FoundDestination"));
         final int foundLibPos = AbilityFactory.calculateAmount(host, params.get("FoundLibraryPosition"), sa);
         final ZoneType revealedDest = ZoneType.smartValueOf(params.get("RevealedDestination"));
         final int revealedLibPos = AbilityFactory.calculateAmount(host, params.get("RevealedLibraryPosition"), sa);
 
-        for (final Player p : tgtPlayers) {
+        for (final Player p : getTargetPlayers(sa, params)) {
             if ((tgt == null) || p.canBeTargetedBy(sa)) {
                 final List<Card> found = new ArrayList<Card>();
                 final List<Card> revealed = new ArrayList<Card>();

src/main/java/forge/card/abilityfactory/effects/DiscardEffect.java

@@ -12,7 +12,6 @@ import forge.CardUtil;
 import forge.GameActionUtil;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.cardfactory.CardFactoryUtil;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.ComputerUtil;
@@ -26,20 +25,8 @@ public class DiscardEffect extends RevealEffectBase {
         final String mode = params.get("Mode");
         final StringBuilder sb = new StringBuilder();
     
-        ArrayList<Player> tgtPlayers;
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
     
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-    
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
     
         final String conditionDesc = params.get("ConditionDescription");
         if (conditionDesc != null) {
@@ -103,18 +90,11 @@ public class DiscardEffect extends RevealEffectBase {
         final Card source = sa.getSourceCard();
         final String mode = params.get("Mode");
     
-        ArrayList<Player> tgtPlayers;
-    
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         final List<Card> discarded = new ArrayList<Card>();
     
-        for (final Player p : tgtPlayers) {
+        for (final Player p : getTargetPlayers(sa, params)) {
             if ((tgt == null) || p.canBeTargetedBy(sa)) {
                 if (mode.equals("Defined")) {
                     final ArrayList<Card> toDiscard = AbilityFactory.getDefinedCards(source, params.get("DefinedCards"),

src/main/java/forge/card/abilityfactory/effects/DrainManaEffect.java

@@ -1,65 +1,36 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
+import java.util.List;
-import java.util.Iterator;
+
+import org.apache.commons.lang3.StringUtils;
 
-import forge.Card;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
 
 public class DrainManaEffect extends SpellEffect {
+    @Override
+    protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
+        final StringBuilder sb = new StringBuilder();
+    
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
+
+        sb.append(StringUtils.join(tgtPlayers, ", "));
+        sb.append(" empties his or her mana pool.");
+    
+        return sb.toString();
+    }
+
     @Override
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
-        final Card card = sa.getSourceCard();
-
-        ArrayList<Player> tgtPlayers;
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(card, params.get("Defined"), sa);
-        }
     
-        for (final Player p : tgtPlayers) {
+        for (final Player p : getTargetPlayers(sa, params)) {
             if ((tgt == null) || p.canBeTargetedBy(sa)) {
                 p.getManaPool().clearPool(false);
             }
         }
     }
 
-    @Override
-    protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-        final StringBuilder sb = new StringBuilder();
-    
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
-    
-        ArrayList<Player> tgtPlayers;
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-    
-        final Iterator<Player> it = tgtPlayers.iterator();
-        while (it.hasNext()) {
-            sb.append(it.next());
-            if (it.hasNext()) {
-                sb.append(", ");
-            }
-        }
-    
-        sb.append(" empties his or her mana pool.");
-    
-        return sb.toString();
-    }
-
 } 

src/main/java/forge/card/abilityfactory/effects/DrawEffect.java

@@ -1,14 +1,13 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.List;
 
+import org.apache.commons.lang3.StringUtils;
+
 import forge.Card;
 import forge.GameActionUtil;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -20,34 +19,17 @@ public class DrawEffect extends SpellEffect {
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
     
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-    
         final String conditionDesc = params.get("ConditionDescription");
         if (conditionDesc != null) {
             sb.append(conditionDesc).append(" ");
         }
     
-        ArrayList<Player> tgtPlayers;
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
     
-        final Target tgt = sa.getTarget();
-        if (!params.containsKey("Defined") && tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
-        if (tgtPlayers.size() > 0) {
+        if (!tgtPlayers.isEmpty()) {
-            final Iterator<Player> it = tgtPlayers.iterator();
+            
-            while (it.hasNext()) {
+            sb.append(StringUtils.join(tgtPlayers, " and "));
-                sb.append(it.next().toString());
-                if (it.hasNext()) {
-                    sb.append(" and ");
-                }
-            }
             
             int numCards = 1;
             if (params.containsKey("NumCards")) {
@@ -81,19 +63,12 @@ public class DrawEffect extends SpellEffect {
             numCards = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("NumCards"), sa);
         }
 
-        ArrayList<Player> tgtPlayers;
-
         final Target tgt = sa.getTarget();
-        if (!params.containsKey("Defined") && tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(source, params.get("Defined"), sa);
-        }
 
         final boolean optional = params.containsKey("OptionalDecider");
         final boolean slowDraw = params.containsKey("NextUpkeep");
 
-        for (final Player p : tgtPlayers) {
+        for (final Player p : getTargetPlayers(sa, params)) {
             if ((tgt == null) || p.canBeTargetedBy(sa)) {
                 if (optional) {
                     if (p.isComputer()) {

src/main/java/forge/card/abilityfactory/effects/EffectEffect.java

@@ -9,7 +9,6 @@ import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.replacement.ReplacementEffect;
 import forge.card.replacement.ReplacementHandler;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.trigger.Trigger;
 import forge.card.trigger.TriggerHandler;
@@ -20,17 +19,7 @@ public class EffectEffect extends SpellEffect {
 
     @Override
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-        final StringBuilder sb = new StringBuilder();
+        return sa.getDescription();
-    
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        }
-    
-        sb.append(sa.getDescription());
-    
-        return sb.toString();
     }
 
     /**

src/main/java/forge/card/abilityfactory/effects/FightEffect.java

@@ -15,42 +15,38 @@ public class FightEffect extends SpellEffect {
     @Override
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
-        if (params.containsKey("StackDescription")) {
-            sb.append(params.get("StackDescription").replaceAll("CARDNAME", sa.getSourceCard().getName()));
-        }
-        else {
-            Card fighter1 = null;
-            Card fighter2 = null;
-            final Target tgt = sa.getTarget();
-            ArrayList<Card> tgts = null;
-            if (tgt != null) {
-                tgts = tgt.getTargetCards();
-                if (tgts.size() > 0) {
-                    fighter1 = tgts.get(0);
-                }
-            }
-            if (params.containsKey("Defined")) {
-                ArrayList<Card> defined = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-                // Allow both fighters to come from defined list if first fighter not already found
-                if (defined.size() > 1 && fighter1 == null) {
-                    fighter1 = defined.get(0);
-                    fighter2 = defined.get(1);
-                }
-                else {
-                    fighter2 = defined.get(0);
-                }
-            } else if (tgts.size() > 1) {
-                fighter2 = tgts.get(1);
-            }
 
-            if (sa instanceof AbilitySub) {
+        Card fighter1 = null;
-                sb.append(" ");
+        Card fighter2 = null;
-            } else {
+        final Target tgt = sa.getTarget();
-                sb.append(sa.getSourceCard()).append(" - ");
+        ArrayList<Card> tgts = null;
+        if (tgt != null) {
+            tgts = tgt.getTargetCards();
+            if (tgts.size() > 0) {
+                fighter1 = tgts.get(0);
             }
-    
-            sb.append(fighter1 + " fights " + fighter2);
         }
+        if (params.containsKey("Defined")) {
+            ArrayList<Card> defined = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
+            // Allow both fighters to come from defined list if first fighter not already found
+            if (defined.size() > 1 && fighter1 == null) {
+                fighter1 = defined.get(0);
+                fighter2 = defined.get(1);
+            }
+            else {
+                fighter2 = defined.get(0);
+            }
+        } else if (tgts.size() > 1) {
+            fighter2 = tgts.get(1);
+        }
+
+        if (sa instanceof AbilitySub) {
+            sb.append(" ");
+        } else {
+            sb.append(sa.getSourceCard()).append(" - ");
+        }
+
+        sb.append(fighter1 + " fights " + fighter2);
         return sb.toString();
     }
 

src/main/java/forge/card/abilityfactory/effects/FlipCoinEffect.java

@@ -24,12 +24,6 @@ public class FlipCoinEffect extends SpellEffect {
 
         final StringBuilder sb = new StringBuilder();
 
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-
         sb.append(player).append(" flips a coin.");
         return sb.toString();
     }

src/main/java/forge/card/abilityfactory/effects/FogEffect.java

@@ -2,7 +2,6 @@ package forge.card.abilityfactory.effects;
 
 import forge.Singletons;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 
 public class FogEffect extends SpellEffect {
@@ -10,17 +9,7 @@ public class FogEffect extends SpellEffect {
 
     @Override
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-        final StringBuilder sb = new StringBuilder();
+        return sa.getSourceCard().getController() + " prevents all combat damage this turn.";
-    
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-    
-        sb.append(sa.getSourceCard().getController());
-        sb.append(" prevents all combat damage this turn.");
-        return sb.toString();
     }
 
 

src/main/java/forge/card/abilityfactory/effects/GameLossEffect.java

@@ -1,14 +1,11 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 
 import forge.Card;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
-import forge.card.spellability.Target;
 import forge.game.GameLossReason;
 import forge.game.player.Player;
 
@@ -20,23 +17,9 @@ public class GameLossEffect extends SpellEffect {
     @Override
     protected String getStackDescription(Map<String, String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
-        final Card source = sa.getSourceCard();
 
-        if (!(sa instanceof AbilitySub)) {
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-            sb.append(source.getName()).append(" - ");
+        for (final Player p : tgtPlayers) {
-        } else {
-            sb.append(" ");
-        }
-    
-        final Target tgt = sa.getTarget();
-        ArrayList<Player> players = null;
-        if (sa.getTarget() != null) {
-            players = tgt.getTargetPlayers();
-        } else {
-            players = AbilityFactory.getDefinedPlayers(source, params.get("Defined"), sa);
-        }
-    
-        for (final Player p : players) {
             sb.append(p.getName()).append(" ");
         }
     
@@ -48,15 +31,7 @@ public class GameLossEffect extends SpellEffect {
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
         final Card card = sa.getAbilityFactory().getHostCard();
 
-        final Target tgt = sa.getTarget();
+        for (final Player p : getTargetPlayers(sa, params)) {
-        ArrayList<Player> players = null;
-        if (sa.getTarget() != null) {
-            players = tgt.getTargetPlayers();
-        } else {
-            players = AbilityFactory.getDefinedPlayers(card, params.get("Defined"), sa);
-        }
-
-        for (final Player p : players) {
             p.loseConditionMet(GameLossReason.SpellEffect, card.getName());
         }
     }

src/main/java/forge/card/abilityfactory/effects/GameWinEffect.java

@@ -1,12 +1,9 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
 import java.util.Map;
 
 import forge.Card;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.game.player.Player;
 
@@ -18,29 +15,11 @@ public class GameWinEffect extends SpellEffect {
      */
     @Override
     public void resolve(Map<String, String> params, SpellAbility sa) {
-
         final Card card = sa.getAbilityFactory().getHostCard();
 
-        final ArrayList<Player> players = AbilityFactory.getDefinedPlayers(card, params.get("Defined"), sa);
+        for (final Player p : getTargetPlayers(sa, params)) {
-
-        for (final Player p : players) {
             p.altWinBySpellEffect(card.getName());
         }
     }
 
-    @Override
-    protected String getStackDescription(java.util.Map<String, String> params, SpellAbility sa) {
-        final StringBuilder sb = new StringBuilder();
-
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-
-        // Let the spell description also be the stack description
-        sb.append(sa.getDescription());
-
-        return sb.toString();
-    }
 }

src/main/java/forge/card/abilityfactory/effects/LifeExchangeEffect.java

@@ -1,14 +1,11 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 
 import forge.Card;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
-import forge.card.spellability.Target;
 import forge.game.player.Player;
 
 public class LifeExchangeEffect extends SpellEffect {
@@ -30,21 +27,8 @@ public class LifeExchangeEffect extends SpellEffect {
     protected String getStackDescription(Map<String, String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
         final Player activatingPlayer = sa.getActivatingPlayer();
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
 
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" -");
-        }
-    
-        ArrayList<Player> tgtPlayers;
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         if (tgtPlayers.size() == 1) {
             sb.append(activatingPlayer).append(" exchanges life totals with ");
@@ -66,14 +50,7 @@ public class LifeExchangeEffect extends SpellEffect {
         Player p1;
         Player p2;
     
-        ArrayList<Player> tgtPlayers;
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-    
-        final Target tgt = sa.getTarget();
-        if ((tgt != null) && !params.containsKey("Defined")) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         if (tgtPlayers.size() == 1) {
             p1 = sa.getActivatingPlayer();

src/main/java/forge/card/abilityfactory/effects/LifeGainEffect.java

@@ -1,27 +1,15 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
 import java.util.Map;
 
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
 
 public class LifeGainEffect extends SpellEffect {
 
-    // *************************************************************************
-    // ************************ EXCHANGE LIFE **********************************
-    // *************************************************************************
-    
-        
-    
-    // *************************************************************************
-    // ************************* LOSE LIFE *************************************
-    // *************************************************************************
-    
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.AbilityFactoryAlterLife.SpellEffect#getStackDescription(java.util.Map, forge.card.spellability.SpellAbility)
      */
@@ -30,36 +18,16 @@ public class LifeGainEffect extends SpellEffect {
         final StringBuilder sb = new StringBuilder();
         final int amount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("LifeAmount"), sa);
     
-        if (!(sa instanceof AbilitySub)) {
+        final String conditionDesc = params.get("ConditionDescription");
-            sb.append(sa.getSourceCard().getName()).append(" - ");
+        if (conditionDesc != null) {
-        } else {
+            sb.append(conditionDesc).append(" ");
-            sb.append(" ");
         }
 
-        if (params.containsKey("StackDescription")) {
+        for (final Player player : getTargetPlayers(sa, params)) {
-            sb.append(params.get("StackDescription"));
+            sb.append(player).append(" ");
         }
-        else {
-            final String conditionDesc = params.get("ConditionDescription");
-            if (conditionDesc != null) {
-                sb.append(conditionDesc).append(" ");
-            }
 
-            ArrayList<Player> tgtPlayers;
+        sb.append("gains ").append(amount).append(" life.");
-    
-            final Target tgt = sa.getTarget();
-            if (tgt != null && !params.containsKey("Defined")) {
-                tgtPlayers = tgt.getTargetPlayers();
-            } else {
-                tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-            }
-    
-            for (final Player player : tgtPlayers) {
-                sb.append(player).append(" ");
-            }
-    
-            sb.append("gains ").append(amount).append(" life.");
-        }
     
         return sb.toString();
     }
@@ -69,19 +37,11 @@ public class LifeGainEffect extends SpellEffect {
      */
     @Override
     public void resolve(Map<String, String> params, SpellAbility sa) {
-
-    
         final int lifeAmount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("LifeAmount"), sa);
-        ArrayList<Player> tgtPlayers;
     
         final Target tgt = sa.getTarget();
-        if ((tgt != null) && !params.containsKey("Defined")) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
-        for (final Player p : tgtPlayers) {
+        for (final Player p : getTargetPlayers(sa, params)) {
             if ((tgt == null) || p.canBeTargetedBy(sa)) {
                 p.gainLife(lifeAmount, sa.getSourceCard());
             }

src/main/java/forge/card/abilityfactory/effects/LifeLoseEffect.java

@@ -1,11 +1,9 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
 import java.util.Map;
 
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -21,26 +19,13 @@ public class LifeLoseEffect extends SpellEffect {
         final StringBuilder sb = new StringBuilder();
         final int amount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("LifeAmount"), sa);
 
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
     
         final String conditionDesc = params.get("ConditionDescription");
         if (conditionDesc != null) {
             sb.append(conditionDesc).append(" ");
         }
     
-        ArrayList<Player> tgtPlayers;
+        for (final Player player : getTargetPlayers(sa, params)) {
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-    
-        for (final Player player : tgtPlayers) {
             sb.append(player).append(" ");
         }
     
@@ -59,16 +44,8 @@ public class LifeLoseEffect extends SpellEffect {
     
         final int lifeAmount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("LifeAmount"), sa);
 
-        ArrayList<Player> tgtPlayers;
-    
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
+        for (final Player p : getTargetPlayers(sa, params)) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-    
-        for (final Player p : tgtPlayers) {
             if ((tgt == null) || p.canBeTargetedBy(sa)) {
                 lifeLost += p.loseLife(lifeAmount, sa.getSourceCard());
             }

src/main/java/forge/card/abilityfactory/effects/LifeSetEffect.java

@@ -1,11 +1,10 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -18,16 +17,9 @@ public class LifeSetEffect extends SpellEffect {
     @Override
     public void resolve(Map<String, String> params, SpellAbility sa) {
         final int lifeAmount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("LifeAmount"), sa);
-        ArrayList<Player> tgtPlayers;
-    
         final Target tgt = sa.getTarget();
-        if ((tgt != null) && !params.containsKey("Defined")) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
-        for (final Player p : tgtPlayers) {
+        for (final Player p : getTargetPlayers(sa, params)) {
             if ((tgt == null) || p.canBeTargetedBy(sa)) {
                 p.setLife(lifeAmount, sa.getSourceCard());
             }
@@ -42,25 +34,14 @@ public class LifeSetEffect extends SpellEffect {
         final StringBuilder sb = new StringBuilder();
         final int amount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("LifeAmount"), sa);
     
-        if (!(sa instanceof AbilitySub)) {
+
-            sb.append(sa.getSourceCard()).append(" -");
-        } else {
-            sb.append(" ");
-        }
     
         final String conditionDesc = params.get("ConditionDescription");
         if (conditionDesc != null) {
             sb.append(conditionDesc).append(" ");
         }
     
-        ArrayList<Player> tgtPlayers;
+        List<Player> tgtPlayers = getTargetPlayers(sa, params);
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         for (final Player player : tgtPlayers) {
             sb.append(player).append(" ");

src/main/java/forge/card/abilityfactory/effects/MillEffect.java

@@ -1,13 +1,11 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
 import forge.Card;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -25,21 +23,14 @@ public class MillEffect extends SpellEffect {
             source.clearRemembered();
         }
 
-        ArrayList<Player> tgtPlayers;
-
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
         ZoneType destination = ZoneType.smartValueOf(params.get("Destination"));
         if (destination == null) {
             destination = ZoneType.Graveyard;
         }
 
-        for (final Player p : tgtPlayers) {
+        for (final Player p : getTargetPlayers(sa, params)) {
             if ((tgt == null) || p.canBeTargetedBy(sa)) {
                 final List<Card> milled = p.mill(numCards, destination, bottom);
                 if (params.containsKey("RememberMilled")) {
@@ -61,54 +52,34 @@ public class MillEffect extends SpellEffect {
         final StringBuilder sb = new StringBuilder();
         final int numCards = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("NumCards"), sa);
     
-        ArrayList<Player> tgtPlayers;
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-    
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-    
         final String conditionDesc = params.get("ConditionDescription");
         if (conditionDesc != null) {
             sb.append(conditionDesc).append(" ");
         }
     
-        if (params.containsKey("StackDescription")) {
-            if (params.get("StackDescription").equals("None")) {
-                sb.append("");
-            } else {
-            sb.append(params.get("StackDescription"));
-            }
-        } else {
-            for (final Player p : tgtPlayers) {
-                sb.append(p.toString()).append(" ");
-            }
 
-            final ZoneType dest = ZoneType.smartValueOf(params.get("Destination"));
+        for (final Player p : tgtPlayers) {
-            if ((dest == null) || dest.equals(ZoneType.Graveyard)) {
+            sb.append(p.toString()).append(" ");
-                sb.append("mills ");
-            } else if (dest.equals(ZoneType.Exile)) {
-                sb.append("exiles ");
-            } else if (dest.equals(ZoneType.Ante)) {
-                sb.append("antes ");
-            }
-            sb.append(numCards);
-            sb.append(" card");
-            if (numCards != 1) {
-                sb.append("s");
-            }
-            final String millPosition = params.containsKey("FromBottom") ? "bottom" : "top";
-            sb.append(" from the " + millPosition + " of his or her library.");
         }
 
+        final ZoneType dest = ZoneType.smartValueOf(params.get("Destination"));
+        if ((dest == null) || dest.equals(ZoneType.Graveyard)) {
+            sb.append("mills ");
+        } else if (dest.equals(ZoneType.Exile)) {
+            sb.append("exiles ");
+        } else if (dest.equals(ZoneType.Ante)) {
+            sb.append("antes ");
+        }
+        sb.append(numCards);
+        sb.append(" card");
+        if (numCards != 1) {
+            sb.append("s");
+        }
+        final String millPosition = params.containsKey("FromBottom") ? "bottom" : "top";
+        sb.append(" from the " + millPosition + " of his or her library.");
+
+
         return sb.toString();
     }
 }

src/main/java/forge/card/abilityfactory/effects/MustAttackEffect.java

@@ -1,13 +1,11 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 
 import forge.Card;
 import forge.GameEntity;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -22,22 +20,11 @@ public class MustAttackEffect extends SpellEffect {
         final Card host = sa.getSourceCard();
         final StringBuilder sb = new StringBuilder();
 
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
     
         // end standard pre-
     
-        ArrayList<Player> tgtPlayers;
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
     
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         String defender = null;
         if (params.get("Defender").equals("Self")) {
@@ -56,14 +43,8 @@ public class MustAttackEffect extends SpellEffect {
 
     @Override
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
-        ArrayList<Player> tgtPlayers;
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-
         final Target tgt = sa.getTarget();
-        if ((tgt != null) && !params.containsKey("Defined")) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
         for (final Player p : tgtPlayers) {
             if ((tgt == null) || p.canBeTargetedBy(sa)) {

src/main/java/forge/card/abilityfactory/effects/MustBlockEffect.java

@@ -1,11 +1,11 @@
 package forge.card.abilityfactory.effects;
 
 import java.util.ArrayList;
+import java.util.List;
 
 import forge.Card;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 
@@ -47,22 +47,9 @@ public class MustBlockEffect extends SpellEffect {
         final Card host = sa.getSourceCard();
         final StringBuilder sb = new StringBuilder();
     
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
-    
         // end standard pre-
     
-        ArrayList<Card> tgtCards;
+        final List<Card> tgtCards = getTargetCards(sa, params);
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         String attacker = null;
         if (params.containsKey("DefinedAttacker")) {

src/main/java/forge/card/abilityfactory/effects/PhasesEffect.java

@@ -1,15 +1,13 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
+import java.util.List;
-import java.util.Iterator;
 import java.util.Map;
 
+import org.apache.commons.lang3.StringUtils;
+
 import forge.Card;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
-import forge.card.spellability.Target;
 
 public class PhasesEffect extends SpellEffect {
         
@@ -26,29 +24,8 @@ public class PhasesEffect extends SpellEffect {
     protected String getStackDescription(Map<String, String> params, SpellAbility sa) {
         // when getStackDesc is called, just build exactly what is happening
         final StringBuilder sb = new StringBuilder();
-        final Card source = sa.getSourceCard();
+        final List<Card> tgtCards = getTargetCards(sa, params);
-    
+        sb.append(StringUtils.join(tgtCards, ", "));
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
-    
-        ArrayList<Card> tgtCards;
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(source, params.get("Defined"), sa);
-        }
-    
-        final Iterator<Card> it = tgtCards.iterator();
-        while (it.hasNext()) {
-            sb.append(it.next());
-            if (it.hasNext()) {
-                sb.append(", ");
-            }
-        }
         sb.append(" Phases Out.");
         return sb.toString();
     }
@@ -65,15 +42,7 @@ public class PhasesEffect extends SpellEffect {
      */
     @Override
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
-        final Card card = sa.getSourceCard();
+        final List<Card> tgtCards = getTargetCards(sa, params);
-        final Target tgt = sa.getTarget();
-        ArrayList<Card> tgtCards = null;
-
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(card, params.get("Defined"), sa);
-        }
 
         for (final Card tgtC : tgtCards) {
             if (!tgtC.isPhasedOut()) {

src/main/java/forge/card/abilityfactory/effects/PlayEffect.java

@@ -1,10 +1,11 @@
 package forge.card.abilityfactory.effects;
 
 import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
+import org.apache.commons.lang3.StringUtils;
+
 import com.google.common.base.Predicate;
 
 import forge.Card;
@@ -18,11 +19,9 @@ import forge.card.cardfactory.CardFactoryUtil;
 import forge.card.cost.Cost;
 import forge.card.cost.CostMana;
 import forge.card.cost.CostPart;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.Spell;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.SpellAbilityRestriction;
-import forge.card.spellability.Target;
 import forge.game.player.ComputerUtil;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
@@ -34,31 +33,13 @@ public class PlayEffect extends SpellEffect {
     protected String getStackDescription(Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
 
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
         sb.append("Play ");
-        ArrayList<Card> tgtCards;
+        final List<Card> tgtCards = getTargetCards(sa, params); 
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         if (params.containsKey("Valid")) {
             sb.append("cards");
         } else {
-            final Iterator<Card> it = tgtCards.iterator();
+            sb.append(StringUtils.join(tgtCards, ", "));
-            while (it.hasNext()) {
-                sb.append(it.next());
-                if (it.hasNext()) {
-                    sb.append(", ");
-                }
-            }
         }
         if (params.containsKey("WithoutManaCost")) {
             sb.append(" without paying the mana cost");
@@ -86,7 +67,6 @@ public class PlayEffect extends SpellEffect {
         final Player controller = activator;
         List<Card> tgtCards = new ArrayList<Card>();
 
-        final Target tgt = sa.getTarget();
         if (params.containsKey("Valid")) {
             ZoneType zone = ZoneType.Hand;
             if (params.containsKey("ValidZone")) {
@@ -94,11 +74,8 @@ public class PlayEffect extends SpellEffect {
             }
             tgtCards = Singletons.getModel().getGame().getCardsIn(zone);
             tgtCards = AbilityFactory.filterListByType(tgtCards, params.get("Valid"), sa);
-        } else if (params.containsKey("Defined")) {
+        } else 
-            tgtCards = new ArrayList<Card>(AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa));
+            tgtCards = getTargetCards(sa, params);
-        } else if (tgt != null) {
-            tgtCards = new ArrayList<Card>(tgt.getTargetCards());
-        }
 
         if (tgtCards.isEmpty()) {
             return;

src/main/java/forge/card/abilityfactory/effects/PoisonEffect.java

@@ -1,12 +1,12 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
+import java.util.List;
-import java.util.Iterator;
 import java.util.Map;
 
+import org.apache.commons.lang3.StringUtils;
+
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -25,16 +25,8 @@ import forge.game.player.Player;
         public void resolve(Map<String, String> params, SpellAbility sa) {
             final int amount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("Num"), sa);
         
-            ArrayList<Player> tgtPlayers;
-        
             final Target tgt = sa.getTarget();
-            if (tgt != null) {
+            for (final Player p : getTargetPlayers(sa, params)) {
-                tgtPlayers = tgt.getTargetPlayers();
-            } else {
-                tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-            }
-        
-            for (final Player p : tgtPlayers) {
                 if ((tgt == null) || p.canBeTargetedBy(sa)) {
                     p.addPoisonCounters(amount, sa.getSourceCard());
                 }
@@ -49,38 +41,16 @@ import forge.game.player.Player;
             final StringBuilder sb = new StringBuilder();
             final int amount = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("Num"), sa);
         
-            if (!(sa instanceof AbilitySub)) {
-                sb.append(sa.getSourceCard()).append(" - ");
-            } else {
-                sb.append(" ");
-            }
         
             final String conditionDesc = params.get("ConditionDescription");
             if (conditionDesc != null) {
                 sb.append(conditionDesc).append(" ");
             }
         
-            ArrayList<Player> tgtPlayers;
+            final List<Player> tgtPlayers = getTargetPlayers(sa, params);
         
-            final Target tgt = sa.getTarget();
+            sb.append(StringUtils.join(tgtPlayers, ", "));
-            if (tgt != null) {
+            sb.append(" ");
-                tgtPlayers = tgt.getTargetPlayers();
-            } else {
-                tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-            }
-        
-            if (tgtPlayers.size() > 0) {
-                final Iterator<Player> it = tgtPlayers.iterator();
-                while (it.hasNext()) {
-                    final Player p = it.next();
-                    sb.append(p);
-                    if (it.hasNext()) {
-                        sb.append(", ");
-                    } else {
-                        sb.append(" ");
-                    }
-                }
-            }
         
             sb.append("get");
             if (tgtPlayers.size() < 2) {

src/main/java/forge/card/abilityfactory/effects/ProtectAllEffect.java

@@ -12,9 +12,7 @@ import forge.Command;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
-import forge.card.spellability.Target;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.gui.GuiChoose;
@@ -23,35 +21,16 @@ public class ProtectAllEffect extends SpellEffect {
     
     @Override
     protected String getStackDescription(Map<String,String> params, SpellAbility sa) {
-        final Card host = sa.getAbilityFactory().getHostCard();
-
         final StringBuilder sb = new StringBuilder();
 
-        ArrayList<Card> tgtCards;
+        final List<Card> tgtCards = getTargetCards(sa, params);
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
         if (tgtCards.size() > 0) {
-
+            sb.append("Valid card gain protection");
-            if (sa instanceof AbilitySub) {
+            if (!params.containsKey("Permanent")) {
-                sb.append(" ");
+                sb.append(" until end of turn");
-            } else {
-                sb.append(host).append(" - ");
-            }
-
-            if (params.containsKey("SpellDescription")) {
-                sb.append(params.get("SpellDescription"));
-            } else {
-                sb.append("Valid card gain protection");
-                if (!params.containsKey("Permanent")) {
-                    sb.append(" until end of turn");
-                }
-                sb.append(".");
             }
+            sb.append(".");
         }
 
         return sb.toString();

src/main/java/forge/card/abilityfactory/effects/ProtectEffect.java

@@ -15,7 +15,6 @@ import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.cardfactory.CardFactoryUtil;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -29,7 +28,6 @@ public class ProtectEffect extends SpellEffect {
          */
     @Override
     protected String getStackDescription(Map<String, String> params, SpellAbility sa) {
-        final Card host = sa.getAbilityFactory().getHostCard();
 
         final ArrayList<String> gains = AbilityFactory.getProtectionList(params);
         final boolean choose = (params.containsKey("Choices")) ? true : false;
@@ -37,22 +35,11 @@ public class ProtectEffect extends SpellEffect {
 
         final StringBuilder sb = new StringBuilder();
 
-        ArrayList<Card> tgtCards;
+        List<Card> tgtCards = getTargetCards(sa, params);
-        final Target tgt = sa.getTarget();
+
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
         if (tgtCards.size() > 0) {
 
-            if (sa instanceof AbilitySub) {
-                sb.append(" ");
-            } else {
-                sb.append(host).append(" - ");
-            }
-
             final Iterator<Card> it = tgtCards.iterator();
             while (it.hasNext()) {
                 final Card tgtC = it.next();
@@ -152,14 +139,9 @@ public class ProtectEffect extends SpellEffect {
             }
         }
 
-        ArrayList<Card> tgtCards;
+        final List<Card> tgtCards = getTargetCards(sa, params);
         final ArrayList<Card> untargetedCards = new ArrayList<Card>();
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(host, params.get("Defined"), sa);
-        }
 
         if (params.containsKey("Radiance") && (tgt != null)) {
             for (final Card c : CardUtil.getRadiance(host, tgtCards.get(0),
@@ -168,10 +150,8 @@ public class ProtectEffect extends SpellEffect {
             }
         }
 
-        final int size = tgtCards.size();
-        for (int j = 0; j < size; j++) {
-            final Card tgtC = tgtCards.get(j);
 
+        for (final Card tgtC : tgtCards) {
             // only pump things in play
             if (!tgtC.isInPlay()) {
                 continue;

src/main/java/forge/card/abilityfactory/effects/PumpAllEffect.java

@@ -11,7 +11,6 @@ import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
-import forge.card.spellability.Target;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -21,17 +20,11 @@ public class PumpAllEffect extends SpellEffect {
         final StringBuilder sb = new StringBuilder();
 
         String desc = "";
-        if (params.containsKey("SpellDescription")) {
+        if (params.containsKey("PumpAllDescription")) {
-            desc = params.get("SpellDescription");
-        } else if (params.containsKey("PumpAllDescription")) {
             desc = params.get("PumpAllDescription");
         }
 
-        if (!(sa instanceof AbilitySub)) {
+
-            sb.append(sa.getSourceCard()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
         sb.append(desc);
 
         final AbilitySub abSub = sa.getSubAbility();
@@ -45,16 +38,9 @@ public class PumpAllEffect extends SpellEffect {
     @Override
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
         List<Card> list;
-        ArrayList<Player> tgtPlayers = null;
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
         final ArrayList<ZoneType> affectedZones = new ArrayList<ZoneType>();
     
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else if (params.containsKey("Defined")) {
-            // use it
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         if (params.containsKey("PumpZone")) {
             for (final String zone : params.get("PumpZone").split(",")) {
@@ -87,13 +73,12 @@ public class PumpAllEffect extends SpellEffect {
         final int a = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("NumAtt"), sa); 
         final int d = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("NumDef"), sa); 
     
-        for (final Card c : list) {
+        for (final Card tgtC : list) {
-            final Card tgtC = c;
     
             // only pump things in the affected zones.
             boolean found = false;
             for (final ZoneType z : affectedZones) {
-                if (c.isInZone(z)) {
+                if (tgtC.isInZone(z)) {
                     found = true;
                     break;
                 }

src/main/java/forge/card/abilityfactory/effects/PumpEffect.java

@@ -13,7 +13,6 @@ import forge.GameEntity;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -126,61 +125,46 @@ public class PumpEffect extends SpellEffect {
 
         if (tgts.size() > 0) {
 
-            if (sa instanceof AbilitySub) {
+            for (final GameEntity c : tgts) {
-                sb.append(" ");
+                sb.append(c).append(" ");
-            } else {
-                sb.append(sa.getSourceCard()).append(" - ");
             }
 
-            if (params.containsKey("StackDescription")) {
+            if (params.containsKey("Radiance")) {
-                if (params.get("StackDescription").equals("None")) {
+                sb.append(" and each other ").append(params.get("ValidTgts"))
-                    sb.append("");
+                        .append(" that shares a color with ");
+                if (tgts.size() > 1) {
+                    sb.append("them ");
                 } else {
-                sb.append(params.get("StackDescription"));
+                    sb.append("it ");
                 }
             }
 
-            else {
+            final List<String> keywords = params.containsKey("KW") ? Arrays.asList(params.get("KW").split(" & ")) : new ArrayList<String>();
-                for (final GameEntity c : tgts) {
+            final int atk = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("NumAtt"), sa); 
-                    sb.append(c).append(" ");
+            final int def = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("NumDef"), sa); 
-                }
 
-                if (params.containsKey("Radiance")) {
+            sb.append("gains ");
-                    sb.append(" and each other ").append(params.get("ValidTgts"))
+            if ((atk != 0) || (def != 0)) {
-                            .append(" that shares a color with ");
+                if (atk >= 0) {
-                    if (tgts.size() > 1) {
+                    sb.append("+");
-                        sb.append("them ");
-                    } else {
-                        sb.append("it ");
-                    }
                 }
-
+                sb.append(atk);
-                final List<String> keywords = params.containsKey("KW") ? Arrays.asList(params.get("KW").split(" & ")) : new ArrayList<String>();
+                sb.append("/");
-                final int atk = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("NumAtt"), sa); 
+                if (def >= 0) {
-                final int def = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("NumDef"), sa); 
+                   sb.append("+");
-
-                sb.append("gains ");
-                if ((atk != 0) || (def != 0)) {
-                    if (atk >= 0) {
-                        sb.append("+");
-                    }
-                    sb.append(atk);
-                    sb.append("/");
-                    if (def >= 0) {
-                       sb.append("+");
-                    }
-                    sb.append(def);
-                    sb.append(" ");
-                }
-
-                for (int i = 0; i < keywords.size(); i++) {
-                    sb.append(keywords.get(i)).append(" ");
-                }
-
-                if (!params.containsKey("Permanent")) {
-                    sb.append("until end of turn.");
                 }
+                sb.append(def);
+                sb.append(" ");
             }
+
+            for (int i = 0; i < keywords.size(); i++) {
+                sb.append(keywords.get(i)).append(" ");
+            }
+
+            if (!params.containsKey("Permanent")) {
+                sb.append("until end of turn.");
+            }
+
         }
 
         return sb.toString();

src/main/java/forge/card/abilityfactory/effects/RearrangeTopOfLibraryEffect.java

@@ -8,7 +8,6 @@ import forge.GameActionUtil;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -25,25 +24,14 @@ public class RearrangeTopOfLibraryEffect extends SpellEffect {
     @Override
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         int numCards = 0;
-        ArrayList<Player> tgtPlayers;
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
         boolean shuffle = false;
         Card host = sa.getAbilityFactory().getHostCard();
     
-        final Target tgt = sa.getTarget();
-        if ((tgt != null) && !params.containsKey("Defined")) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-    
         numCards = AbilityFactory.calculateAmount(host, params.get("NumCards"), sa);
         shuffle = params.containsKey("MayShuffle");
     
         final StringBuilder ret = new StringBuilder();
-        if (!(sa instanceof AbilitySub)) {
-            ret.append(host.getName());
-            ret.append(" - ");
-        }
         ret.append("Look at the top ");
         ret.append(numCards);
         ret.append(" cards of ");
@@ -84,22 +72,17 @@ public class RearrangeTopOfLibraryEffect extends SpellEffect {
     @Override
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
         int numCards = 0;
-        ArrayList<Player> tgtPlayers = new ArrayList<Player>();
         Card host = sa.getAbilityFactory().getHostCard();
         boolean shuffle = false;
 
         if (sa.getActivatingPlayer().isHuman()) {
             final Target tgt = sa.getTarget();
-            if ((tgt != null) && !params.containsKey("Defined")) {
+
-                tgtPlayers = tgt.getTargetPlayers();
-            } else {
-                tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-            }
 
             numCards = AbilityFactory.calculateAmount(host, params.get("NumCards"), sa);
             shuffle = params.containsKey("MayShuffle");
 
-            for (final Player p : tgtPlayers) {
+            for (final Player p : getTargetPlayers(sa, params)) {
                 if ((tgt == null) || p.canBeTargetedBy(sa)) {
                     rearrangeTopOfLibrary(host, p, numCards, shuffle);
                 }

src/main/java/forge/card/abilityfactory/effects/RegenerateAllEffect.java

@@ -7,31 +7,13 @@ import forge.CardLists;
 import forge.Command;
 import forge.Singletons;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
 public class RegenerateAllEffect extends SpellEffect {
     @Override
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-        final StringBuilder sb = new StringBuilder();
+        return "Regenerate all valid cards.";
-        final Card host = sa.getAbilityFactory().getHostCard();
-    
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(host).append(" - ");
-        }
-    
-        String desc = "";
-        if (params.containsKey("SpellDescription")) {
-            desc = params.get("SpellDescription");
-        } else {
-            desc = "Regenerate all valid cards.";
-        }
-    
-        sb.append(desc);
-        return sb.toString();
     }
 
     @Override

src/main/java/forge/card/abilityfactory/effects/RegenerateEffect.java

@@ -1,15 +1,13 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 
 import forge.Card;
 import forge.Command;
 import forge.Singletons;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 
@@ -22,24 +20,11 @@ public class RegenerateEffect extends SpellEffect
     @Override
     protected String getStackDescription(Map<String, String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
-        final Card host = sa.getAbilityFactory().getHostCard();
+        final List<Card> tgtCards = getTargetCards(sa, params);
-    
-        ArrayList<Card> tgtCards;
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         if (tgtCards.size() > 0) {
-            if (sa instanceof AbilitySub) {
-                sb.append(" ");
-            } else {
-                sb.append(host).append(" - ");
-            }
-    
             sb.append("Regenerate ");
+            
             final Iterator<Card> it = tgtCards.iterator();
             while (it.hasNext()) {
                 final Card tgtC = it.next();
@@ -61,17 +46,9 @@ public class RegenerateEffect extends SpellEffect
 
     @Override
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
-        final Card hostCard = sa.getAbilityFactory().getHostCard();
-
-        ArrayList<Card> tgtCards;
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(hostCard, params.get("Defined"), sa);
-        }
 
-        for (final Card tgtC : tgtCards) {
+        for (final Card tgtC : getTargetCards(sa, params)) {
             final Command untilEOT = new Command() {
                 private static final long serialVersionUID = 1922050611313909200L;
 

src/main/java/forge/card/abilityfactory/effects/RemoveFromCombatEffect.java

@@ -1,12 +1,12 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.commons.lang3.StringUtils;
 
 import forge.Card;
 import forge.Singletons;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 
@@ -16,29 +16,10 @@ public class RemoveFromCombatEffect extends SpellEffect {
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
     
-        if (sa instanceof AbilitySub) {
+        final List<Card> tgtCards = getTargetCards(sa, params);
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
-    
-        // end standard pre-
-    
-        ArrayList<Card> tgtCards;
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         sb.append("Remove ");
-    
+        sb.append(StringUtils.join(tgtCards, ", "));
-        for (final Card c : tgtCards) {
-            sb.append(c);
-        }
-    
         sb.append(" from combat.");
     
         return sb.toString();
@@ -47,16 +28,8 @@ public class RemoveFromCombatEffect extends SpellEffect {
     @Override
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
 
-        ArrayList<Card> tgtCards;
-
         final Target tgt = sa.getTarget();
-        if ((tgt != null) && !params.containsKey("Defined")) {
+        for (final Card c : getTargetCards(sa, params)) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-
-        for (final Card c : tgtCards) {
             if ((tgt == null) || c.canBeTargetedBy(sa)) {
                 Singletons.getModel().getGame().getCombat().removeFromCombat(c);
             }

src/main/java/forge/card/abilityfactory/effects/RepeatEffect.java

@@ -33,25 +33,7 @@ public class RepeatEffect extends SpellEffect {
     
     @Override
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-        final StringBuilder sb = new StringBuilder();
+        return "Repeat something. Somebody should really write a better StackDescription!";
-        final Card host = sa.getSourceCard();
-
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(host.getName()).append(" -");
-        }
-
-        sb.append(" ");
-
-        if (params.containsKey("StackDescription")) {
-            final String desc = params.get("StackDescription");
-            if (!desc.equals("None")) {
-                sb.append(params.get("StackDescription"));
-            }
-        } else {
-            sb.append("Repeat something. Somebody should really write a better StackDescription!");
-        }
-
-        return sb.toString();
     } // end repeatStackDescription()
 
     /**

src/main/java/forge/card/abilityfactory/effects/RevealEffect.java

@@ -6,8 +6,6 @@ import java.util.List;
 import forge.Card;
 import forge.CardLists;
 import forge.CardUtil;
-import forge.card.abilityfactory.AbilityFactory;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -20,16 +18,9 @@ public class RevealEffect extends RevealEffectBase {
         final Card host = sa.getAbilityFactory().getHostCard();
         final boolean anyNumber = params.containsKey("AnyNumber");
 
-        ArrayList<Player> tgtPlayers;
-
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
-        for (final Player p : tgtPlayers) {
+        for (final Player p : getTargetPlayers(sa, params)) {
             if ((tgt == null) || p.canBeTargetedBy(sa)) {
                 final List<Card> handChoices = p.getCardsIn(ZoneType.Hand);
                 if (handChoices.size() > 0) {
@@ -67,20 +58,7 @@ public class RevealEffect extends RevealEffectBase {
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
 
-        if (sa instanceof AbilitySub) {
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
-    
-        ArrayList<Player> tgtPlayers;
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
         if (tgtPlayers.size() > 0) {
             sb.append(tgtPlayers.get(0)).append(" reveals ");

src/main/java/forge/card/abilityfactory/effects/RevealHandEffect.java

@@ -1,14 +1,11 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
 import java.util.List;
 
 import javax.swing.JOptionPane;
 
 import forge.Card;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -21,20 +18,9 @@ public class RevealHandEffect extends SpellEffect {
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
 
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
     
-        ArrayList<Player> tgtPlayers;
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
     
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
         sb.append(sa.getActivatingPlayer()).append(" looks at ");
     
@@ -54,16 +40,9 @@ public class RevealHandEffect extends SpellEffect {
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
         final Card host = sa.getAbilityFactory().getHostCard();
     
-        ArrayList<Player> tgtPlayers;
-    
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
-        for (final Player p : tgtPlayers) {
+        for (final Player p : getTargetPlayers(sa, params)) {
             if ((tgt == null) || p.canBeTargetedBy(sa)) {
                 final List<Card> hand = p.getCardsIn(ZoneType.Hand);
                 if (sa.getActivatingPlayer().isHuman()) {

src/main/java/forge/card/abilityfactory/effects/SacrificeAllEffect.java

@@ -7,7 +7,6 @@ import forge.Card;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
@@ -17,15 +16,8 @@ public class SacrificeAllEffect extends SpellEffect {
         // when getStackDesc is called, just build exactly what is happening
     
         final StringBuilder sb = new StringBuilder();
-        final Card host = sa.getAbilityFactory().getHostCard();
 
     
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(host).append(" - ");
-        }
-    
         final String conditionDesc = params.get("ConditionDescription");
         if (conditionDesc != null) {
             sb.append(conditionDesc).append(" ");

src/main/java/forge/card/abilityfactory/effects/SacrificeEffect.java

@@ -8,9 +8,7 @@ import forge.CardUtil;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
-import forge.card.spellability.Target;
 import forge.game.player.ComputerUtil;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
@@ -25,14 +23,7 @@ public class SacrificeEffect extends SpellEffect {
         // Expand Sacrifice keyword here depending on what we need out of it.
         final String num = params.containsKey("Amount") ? params.get("Amount") : "1";
         final int amount = AbilityFactory.calculateAmount(card, num, sa);
-
+        final List<Player> tgts = getTargetPlayers(sa, params);
-        final Target tgt = sa.getTarget();
-        ArrayList<Player> tgts;
-        if (tgt != null) {
-            tgts = tgt.getTargetPlayers();
-        } else {
-            tgts = AbilityFactory.getDefinedPlayers(card, params.get("Defined"), sa);
-        }
 
         String valid = params.get("SacValid");
         if (valid == null) {
@@ -84,24 +75,12 @@ public class SacrificeEffect extends SpellEffect {
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
     
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        }
-    
         final String conditionDesc = params.get("ConditionDescription");
         if (conditionDesc != null) {
             sb.append(conditionDesc).append(" ");
         }
     
-        final Target tgt = sa.getTarget();
+        final List<Player> tgts = getTargetPlayers(sa, params);
-        ArrayList<Player> tgts;
-        if (tgt != null) {
-            tgts = tgt.getTargetPlayers();
-        } else {
-            tgts = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         String valid = params.get("SacValid");
         if (valid == null) {

src/main/java/forge/card/abilityfactory/effects/ScryEffect.java

@@ -1,10 +1,9 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
+import java.util.List;
 
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -15,20 +14,7 @@ public class ScryEffect extends SpellEffect {
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
 
-        if (!(sa instanceof AbilitySub)) {
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
-
-        ArrayList<Player> tgtPlayers;
-
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
         for (final Player p : tgtPlayers) {
             sb.append(p.toString()).append(" ");
@@ -51,14 +37,8 @@ public class ScryEffect extends SpellEffect {
             num = AbilityFactory.calculateAmount(sa.getSourceCard(), params.get("ScryNum"), sa);
         }
     
-        ArrayList<Player> tgtPlayers;
-    
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         for (final Player p : tgtPlayers) {
             if ((tgt == null) || p.canBeTargetedBy(sa)) {

src/main/java/forge/card/abilityfactory/effects/SetStateAllEffect.java

@@ -8,7 +8,6 @@ import forge.CardLists;
 import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -112,15 +111,8 @@ public class SetStateAllEffect extends SpellEffect {
 
     @Override
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
-        final Card host = sa.getAbilityFactory().getHostCard();
         final StringBuilder sb = new StringBuilder();
 
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(host).append(" - ");
-        }
-
         if (params.containsKey("Mode")) {
             sb.append(params.get("Mode"));
         } else {

src/main/java/forge/card/abilityfactory/effects/SetStateEffect.java

@@ -1,42 +1,25 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
 import java.util.Iterator;
+import java.util.List;
 
 import forge.Card;
 import forge.CardCharacteristicName;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
-import forge.card.spellability.Target;
 
 public class SetStateEffect extends SpellEffect {
     
     @Override
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
-        final Card host = sa.getAbilityFactory().getHostCard();
 
         final String conditionDesc = params.get("ConditionDescription");
         if (conditionDesc != null) {
             sb.append(conditionDesc).append(" ");
         }
 
-        ArrayList<Card> tgtCards;
+        final List<Card> tgtCards = getTargetCards(sa, params); 
-
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(host).append(" - ");
-        }
 
         if (params.containsKey("Flip")) {
             sb.append("Flip");
@@ -63,14 +46,9 @@ public class SetStateEffect extends SpellEffect {
 
     @Override
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
-        ArrayList<Card> tgtCards;
-        final Card host = sa.getAbilityFactory().getHostCard(); 
 
-        if (sa.getTarget() != null) {
+        final Card host = sa.getAbilityFactory().getHostCard(); 
-            tgtCards = sa.getTarget().getTargetCards();
+        final List<Card> tgtCards = getTargetCards(sa, params); 
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(host, params.get("Defined"), sa);
-        }
 
         final boolean remChanged = params.containsKey("RememberChanged");
 

src/main/java/forge/card/abilityfactory/effects/ShuffleEffect.java

@@ -1,13 +1,11 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
 import java.util.Iterator;
+import java.util.List;
 
 import forge.Card;
 import forge.GameActionUtil;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -18,14 +16,9 @@ public class ShuffleEffect extends SpellEffect {
         final Card host = sa.getSourceCard();
         final boolean optional = params.containsKey("Optional");
 
-        ArrayList<Player> tgtPlayers;
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params); 
 
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
         for (final Player p : tgtPlayers) {
             if ((tgt == null) || p.canBeTargetedBy(sa)) {
@@ -42,25 +35,13 @@ public class ShuffleEffect extends SpellEffect {
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
     
-        if (!(sa instanceof AbilitySub)) {
-            sb.append(sa.getSourceCard().getName()).append(" - ");
-        } else {
-            sb.append(" ");
-        }
 
         final String conditionDesc = params.get("ConditionDescription");
         if (conditionDesc != null) {
             sb.append(conditionDesc).append(" ");
         }
     
-        ArrayList<Player> tgtPlayers;
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         if (tgtPlayers.size() > 0) {
             final Iterator<Player> it = tgtPlayers.iterator();

src/main/java/forge/card/abilityfactory/effects/TapAllEffect.java

@@ -1,6 +1,5 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
@@ -10,7 +9,6 @@ import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
-import forge.card.spellability.Target;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -21,17 +19,11 @@ public class TapAllEffect extends SpellEffect {
      */
     @Override
     protected String getStackDescription(Map<String, String> params, SpellAbility sa) {
-        final StringBuilder sb = new StringBuilder();
-    
         if (sa instanceof AbilitySub) {
-            sb.append(" ");
+            return "Tap all valid cards.";
-            sb.append("Tap all valid cards.");
         } else {
-            sb.append(sa.getSourceCard()).append(" - ");
+            return params.get("SpellDescription");
-            sb.append(params.get("SpellDescription"));
         }
-    
-        return sb.toString();
     }
 
     @Override
@@ -44,15 +36,7 @@ public class TapAllEffect extends SpellEffect {
     
         List<Card> cards = null;
     
-        ArrayList<Player> tgtPlayers = null;
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else if (params.containsKey("Defined")) {
-            // use it
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         if ((tgtPlayers == null) || tgtPlayers.isEmpty()) {
             cards = Singletons.getModel().getGame().getCardsIn(ZoneType.Battlefield);

src/main/java/forge/card/abilityfactory/effects/TapEffect.java

@@ -1,13 +1,12 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
+import java.util.List;
-import java.util.Iterator;
 import java.util.Map;
 
+import org.apache.commons.lang3.StringUtils;
+
 import forge.Card;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 
@@ -24,13 +23,8 @@ public class TapEffect extends SpellEffect {
             card.clearRemembered();
         }
 
-        ArrayList<Card> tgtCards;
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
+        final List<Card> tgtCards = getTargetCards(sa, params);
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(card, params.get("Defined"), sa);
-        }
 
         for (final Card tgtC : tgtCards) {
             if (tgt != null && !tgtC.canBeTargetedBy(sa)) {
@@ -50,32 +44,9 @@ public class TapEffect extends SpellEffect {
     protected String getStackDescription(java.util.Map<String,String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
     
-        final Card hostCard = sa.getSourceCard();
-    
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
-    
         sb.append("Tap ");
-    
+        final List<Card> tgtCards = getTargetCards(sa, params);
-        ArrayList<Card> tgtCards;
+        sb.append(StringUtils.join(tgtCards, ", "));
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(hostCard, params.get("Defined"), sa);
-        }
-    
-        final Iterator<Card> it = tgtCards.iterator();
-        while (it.hasNext()) {
-            sb.append(it.next());
-            if (it.hasNext()) {
-                sb.append(", ");
-            }
-        }
-    
         sb.append(".");
         return sb.toString();
     }

src/main/java/forge/card/abilityfactory/effects/TapOrUntapEffect.java

@@ -1,13 +1,12 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
+import java.util.List;
-import java.util.Iterator;
 import java.util.Map;
 
+import org.apache.commons.lang3.StringUtils;
+
 import forge.Card;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.gui.GuiChoose;
@@ -22,44 +21,20 @@ public class TapOrUntapEffect extends SpellEffect {
         // when getStackDesc is called, just build exactly what is happening
         final StringBuilder sb = new StringBuilder();
 
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
     
         sb.append("Tap or untap ");
     
-        ArrayList<Card> tgtCards;
+        final List<Card> tgtCards = getTargetCards(sa, params);
-        final Target tgt = sa.getTarget();
+        sb.append(StringUtils.join(tgtCards, ", "));
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-    
-        final Iterator<Card> it = tgtCards.iterator();
-        while (it.hasNext()) {
-            sb.append(it.next());
-            if (it.hasNext()) {
-                sb.append(", ");
-            }
-        }
         sb.append(".");
         return sb.toString();
     }
 
     @Override
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
-        final Card card = sa.getSourceCard();
+        final List<Card> tgtCards = getTargetCards(sa, params);
 
-        ArrayList<Card> tgtCards;
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtCards = tgt.getTargetCards();
-        } else {
-            tgtCards = AbilityFactory.getDefinedCards(card, params.get("Defined"), sa);
-        }
 
         for (final Card tgtC : tgtCards) {
             if (tgtC.isInPlay() && ((tgt == null) || tgtC.canBeTargetedBy(sa))) {

src/main/java/forge/card/abilityfactory/effects/TokenEffect.java

@@ -27,7 +27,6 @@ import forge.Singletons;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.cardfactory.CardFactoryUtil;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.trigger.Trigger;
 import forge.card.trigger.TriggerHandler;
@@ -114,36 +113,25 @@ public class TokenEffect extends SpellEffect {
 
         readParameters(params);
 
-        if (sa instanceof AbilitySub) {
+        final int finalPower = AbilityFactory.calculateAmount(host, this.tokenPower, sa);
-            sb.append(" ");
+        final int finalToughness = AbilityFactory.calculateAmount(host, this.tokenToughness, sa);
+        final int finalAmount = AbilityFactory.calculateAmount(host, this.tokenAmount, sa);
+
+        final String substitutedName = this.tokenName.equals("ChosenType") ? host.getChosenType() : this.tokenName;
+
+        sb.append("Put (").append(finalAmount).append(") ").append(finalPower).append("/").append(finalToughness);
+        sb.append(" ").append(substitutedName).append(" token");
+        if (finalAmount != 1) {
+            sb.append("s");
+        }
+        sb.append(" onto the battlefield");
+
+        if (this.tokenOwner.equals("Opponent")) {
+            sb.append(" under your opponent's control.");
         } else {
-            sb.append(host.getName()).append(" - ");
+            sb.append(".");
         }
 
-        if (params.containsKey("StackDescription")) {
-            sb.append(params.get("StackDescription"));
-        }
-        else {
-
-            final int finalPower = AbilityFactory.calculateAmount(host, this.tokenPower, sa);
-            final int finalToughness = AbilityFactory.calculateAmount(host, this.tokenToughness, sa);
-            final int finalAmount = AbilityFactory.calculateAmount(host, this.tokenAmount, sa);
-
-            final String substitutedName = this.tokenName.equals("ChosenType") ? host.getChosenType() : this.tokenName;
-
-            sb.append("Put (").append(finalAmount).append(") ").append(finalPower).append("/").append(finalToughness);
-            sb.append(" ").append(substitutedName).append(" token");
-            if (finalAmount != 1) {
-                sb.append("s");
-            }
-            sb.append(" onto the battlefield");
-
-            if (this.tokenOwner.equals("Opponent")) {
-                sb.append(" under your opponent's control.");
-            } else {
-                sb.append(".");
-            }
-        }
         return sb.toString();
     }
 

src/main/java/forge/card/abilityfactory/effects/TwoPilesEffect.java

@@ -27,20 +27,7 @@ public class TwoPilesEffect extends SpellEffect {
     protected String getStackDescription(Map<String, String> params, SpellAbility sa) {
         final StringBuilder sb = new StringBuilder();
     
-        if (sa instanceof AbilitySub) {
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
-    
-        ArrayList<Player> tgtPlayers;
-    
-        final Target tgt = sa.getTarget();
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
     
         String valid = "";
         if (params.containsKey("ValidCards")) {
@@ -74,14 +61,8 @@ public class TwoPilesEffect extends SpellEffect {
             valid = params.get("ValidCards");
         }
 
-        ArrayList<Player> tgtPlayers;
-
         final Target tgt = sa.getTarget();
-        if (tgt != null) {
+        final List<Player> tgtPlayers = getTargetPlayers(sa, params);
-            tgtPlayers = tgt.getTargetPlayers();
-        } else {
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
 
         Player separator = card.getController();
         if (params.containsKey("Separator")) {

src/main/java/forge/card/abilityfactory/effects/UntapAllEffect.java

@@ -1,17 +1,14 @@
 package forge.card.abilityfactory.effects;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
 import forge.Card;
 import forge.CardLists;
 import forge.Singletons;
-import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
-import forge.card.spellability.Target;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -22,16 +19,11 @@ public class UntapAllEffect extends SpellEffect {
      */
     @Override
     protected String getStackDescription(Map<String, String> params, SpellAbility sa) {
-        final StringBuilder sb = new StringBuilder();
-
         if (sa instanceof AbilitySub) {
-            sb.append(" ");
+            return "Untap all valid cards.";
-            sb.append("Untap all valid cards.");
         } else {
-            sb.append(sa.getSourceCard()).append(" - ");
+            return params.get("SpellDescription");
-            sb.append(params.get("SpellDescription"));
         }
-        return sb.toString();
     }
 
     @Override
@@ -41,21 +33,13 @@ public class UntapAllEffect extends SpellEffect {
         String valid = "";
         List<Card> list = null;
     
-        ArrayList<Player> tgtPlayers = null;
+        List<Player> tgtPlayers = getTargetPlayers(sa, params);
     
         if (params.containsKey("ValidCards")) {
             valid = params.get("ValidCards");
         }
     
-        final Target tgt = sa.getTarget();
+        if (tgtPlayers.isEmpty()) {
-        if (tgt != null) {
-            tgtPlayers = tgt.getTargetPlayers();
-        } else if (params.containsKey("Defined")) {
-            // use it
-            tgtPlayers = AbilityFactory.getDefinedPlayers(sa.getSourceCard(), params.get("Defined"), sa);
-        }
-    
-        if ((tgtPlayers == null) || tgtPlayers.isEmpty()) {
             list = Singletons.getModel().getGame().getCardsIn(ZoneType.Battlefield);
         } else {
             list = tgtPlayers.get(0).getCardsIn(ZoneType.Battlefield);

src/main/java/forge/card/abilityfactory/effects/UntapEffect.java

@@ -1,10 +1,11 @@
 package forge.card.abilityfactory.effects;
 
 import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
+import org.apache.commons.lang3.StringUtils;
+
 import forge.Card;
 import forge.CardLists;
 import forge.Singletons;
@@ -12,7 +13,6 @@ import forge.CardPredicates.Presets;
 import forge.card.abilityfactory.AbilityFactory;
 import forge.card.abilityfactory.SpellEffect;
 import forge.card.cardfactory.CardFactoryUtil;
-import forge.card.spellability.AbilitySub;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
 import forge.game.player.Player;
@@ -27,13 +27,6 @@ public class UntapEffect extends SpellEffect {
     protected String getStackDescription(Map<String, String> params, SpellAbility sa) {
         // when getStackDesc is called, just build exactly what is happening
         final StringBuilder sb = new StringBuilder();
-        final Card hostCard = sa.getSourceCard();
-    
-        if (sa instanceof AbilitySub) {
-            sb.append(" ");
-        } else {
-            sb.append(sa.getSourceCard()).append(" - ");
-        }
     
         sb.append("Untap ");
     
@@ -41,21 +34,8 @@ public class UntapEffect extends SpellEffect {
             sb.append("up to ").append(params.get("Amount")).append(" ");
             sb.append(params.get("UntapType")).append("s");
         } else {
-            ArrayList<Card> tgtCards = new ArrayList<Card>();
+            List<Card> tgtCards = getTargetCards(sa, params);
-            final Target tgt = sa.getTarget();
+            sb.append(StringUtils.join(tgtCards, ", "));
-            if (tgt != null) {
-                tgtCards = tgt.getTargetCards();
-            } else {
-                tgtCards = AbilityFactory.getDefinedCards(hostCard, params.get("Defined"), sa);
-            }
-    
-            final Iterator<Card> it = tgtCards.iterator();
-            while (it.hasNext()) {
-                sb.append(it.next());
-                if (it.hasNext()) {
-                    sb.append(", ");
-                }
-            }
         }
         sb.append(".");
         return sb.toString();
@@ -63,18 +43,13 @@ public class UntapEffect extends SpellEffect {
 
     @Override
     public void resolve(java.util.Map<String,String> params, SpellAbility sa) {
-        final Card card = sa.getSourceCard();
         final Target tgt = sa.getTarget();
-        ArrayList<Card> tgtCards = null;
     
         if (params.containsKey("UntapUpTo")) {
             untapChooseUpTo(sa, params);
         } else {
-            if (tgt != null) {
+            
-                tgtCards = tgt.getTargetCards();
+            final List<Card> tgtCards = getTargetCards(sa, params);
-            } else {
-                tgtCards = AbilityFactory.getDefinedCards(card, params.get("Defined"), sa);
-            }
     
             for (final Card tgtC : tgtCards) {
                 if (tgtC.isInPlay() && ((tgt == null) || tgtC.canBeTargetedBy(sa))) {