RippleAbility, CascadeAbility are now nested classes (previously they were inlined)

src/main/java/forge/GameActionUtil.java

@@ -77,63 +77,48 @@ import forge.util.MyRandom;
  */
 public final class GameActionUtil {
 
-    private GameActionUtil() {
-        throw new AssertionError();
-    }
     
     /** 
-     * <p>
+     * TODO: Write javadoc for this type.
-     * executePlayCardEffects.
-     * </p>
      *
-     * @param sa
-     *            a {@link forge.card.spellability.SpellAbility} object.
      */
-    public static void executePlayCardEffects(final SpellAbility sa) {
+    private static final class AbilityDestroy extends Ability {
-        // (called in MagicStack.java)
+        private final Card affected;
+        private final boolean canRegenerate;
 
-        GameActionUtil.playCardCascade(sa);
+        public AbilityDestroy(Card sourceCard, Card affected, boolean canRegenerate) {
-        GameActionUtil.playCardRipple(sa);
+            super(sourceCard, SpellManaCost.ZERO);
+            this.affected = affected;
+            this.canRegenerate = canRegenerate;
         }
 
-    /**
-     * <p>
-     * playCardCascade.
-     * </p>
-     * 
-     * @param sa
-     *            a SpellAbility object.
-     */
-    public static void playCardCascade(final SpellAbility sa) {
-        final Card c = sa.getSourceCard();
-        final Player controller = sa.getActivatingPlayer();
-        final Command cascade = new Command() {
-            private static final long serialVersionUID = -845154812215847505L;
-
         @Override
-            public void execute() {
+        public void resolve() {
-
+            final GameState game = Singletons.getModel().getGame(); 
-                if (!c.isCopiedSpell()) {
+            if ( canRegenerate )
-                    final List<Card> maelstromNexii = CardLists.filter(Singletons.getModel().getGame().getCardsIn(ZoneType.Battlefield), CardPredicates.nameEquals("Maelstrom Nexus"));
+                game.getAction().destroy(affected);
-
+            else
-                    for (final Card nexus : maelstromNexii) {
+                game.getAction().destroyNoRegeneration(affected);
-                        if (CardUtil.getThisTurnCast("Card.YouCtrl", nexus).size() == 1) {
-                            this.doCascade(c, controller);
-                        }
         }
     }
 
-                for (String keyword : c.getKeyword()) {
+    private static final class CascadeAbility extends Ability {
-                    if (keyword.equals("Cascade")) {
+        private final Player controller;
-                        this.doCascade(c, controller);
+        private final Card cascCard;
-                    }
-                }
-            } // execute()
 
-            void doCascade(final Card c, final Player controller) {
+        /**
-                final Card cascCard = c;
+         * TODO: Write javadoc for Constructor.
+         * @param sourceCard
+         * @param manaCost
+         * @param controller
+         * @param cascCard
+         */
+        private CascadeAbility(Card sourceCard, SpellManaCost manaCost, Player controller, Card cascCard) {
+            super(sourceCard, manaCost);
+            this.controller = controller;
+            this.cascCard = cascCard;
+        }
 
-                final Ability ability = new Ability(c, SpellManaCost.ZERO) {
         @Override
         public void resolve() {
             final GameState game = Singletons.getModel().getGame(); 
@@ -205,59 +190,84 @@ public final class GameActionUtil {
                 game.getAction().moveToBottomOfLibrary(bottom);
             }
         }
-                };
+    }
+
+    private static final class CascadeExecutor implements Command {
+        private final Card c;
+        private final GameState game;
+        private final Player controller;
+        
+        private static final long serialVersionUID = -845154812215847505L;
+
+        /**
+         * TODO: Write javadoc for Constructor.
+         * @param controller
+         * @param c
+         */
+        private CascadeExecutor(Player controller, Card c, final GameState game) {
+            this.controller = controller;
+            this.c = c;
+            this.game = game;
+        }
+
+        @Override
+        public void execute() {
+            if (!c.isCopiedSpell()) {
+                final List<Card> maelstromNexii = CardLists.filter(Singletons.getModel().getGame().getCardsIn(ZoneType.Battlefield), CardPredicates.nameEquals("Maelstrom Nexus"));
+
+                for (final Card nexus : maelstromNexii) {
+                    if (CardUtil.getThisTurnCast("Card.YouCtrl", nexus).size() == 1) {
+                        this.doCascade(c, controller);
+                    }
+                }
+            }
+
+            for (String keyword : c.getKeyword()) {
+                if (keyword.equals("Cascade")) {
+                    this.doCascade(c, controller);
+                }
+            }
+        } // execute()
+
+        void doCascade(final Card c, final Player controller) {
+            final Card cascCard = c;
+
+            final Ability ability = new CascadeAbility(c, SpellManaCost.ZERO, controller, cascCard);
             final StringBuilder sb = new StringBuilder();
             sb.append(c).append(" - Cascade.");
             ability.setStackDescription(sb.toString());
             ability.setActivatingPlayer(controller);
 
-                Singletons.getModel().getGame().getStack().addSimultaneousStackEntry(ability);
+            game.getStack().addSimultaneousStackEntry(ability);
 
         }
-        };
+    }
-        cascade.execute();
-    } // end playCardCascade
     
     /** 
-     * <p>
+     * TODO: Write javadoc for this type.
-     * playCardRipple.
-     * </p>
      *
-     * @param sa
-     *            a SpellAbility object.
      */
-    public static void playCardRipple(final SpellAbility sa) {
+    private static final class RippleAbility extends Ability {
-        final Card c = sa.getSourceCard();
+        private final Player controller;
-        final Player controller = sa.getActivatingPlayer();
+        private final int rippleCount;
-        final Command ripple = new Command() {
+        private final Card rippleCard;
-            private static final long serialVersionUID = -845154812215847505L;
     
-            @Override
+        /**
-            public void execute() {
+         * TODO: Write javadoc for Constructor.
-
+         * @param sourceCard
-                final List<Card> thrummingStones = controller.getCardsIn(ZoneType.Battlefield, "Thrumming Stone");
+         * @param manaCost
-                for (int i = 0; i < thrummingStones.size(); i++) {
+         * @param controller
-                    c.addExtrinsicKeyword("Ripple:4");
+         * @param rippleCount
+         * @param rippleCard
+         */
+        private RippleAbility(Card sourceCard, SpellManaCost manaCost, Player controller, int rippleCount,
+                Card rippleCard) {
+            super(sourceCard, manaCost);
+            this.controller = controller;
+            this.rippleCount = rippleCount;
+            this.rippleCard = rippleCard;
         }
     
-                final ArrayList<String> a = c.getKeyword();
-                for (int x = 0; x < a.size(); x++) {
-                    if (a.get(x).toString().startsWith("Ripple")) {
-                        final String parse = c.getKeyword().get(x).toString();
-                        final String[] k = parse.split(":");
-                        this.doRipple(c, Integer.valueOf(k[1]), controller);
-                    }
-                }
-            } // execute()
-
-            void doRipple(final Card c, final int rippleCount, final Player controller) {
-                final Card rippleCard = c;
-                boolean activateRipple = false;
-                if (controller.isComputer() || GameActionUtil.showYesNoDialog(c, "Activate Ripple for " + c + "?")) {
-                        activateRipple = true;
-                }
-                if (activateRipple) {
-                    final Ability ability = new Ability(c, SpellManaCost.ZERO) {
         @Override
         public void resolve() {
             final GameState game = Singletons.getModel().getGame();
@@ -326,7 +336,54 @@ public final class GameActionUtil {
                 Singletons.getModel().getGame().getAction().moveToBottomOfLibrary(bottom);
             }
         }
-                    };
+    
+    }
+
+    /** 
+     * TODO: Write javadoc for this type.
+     *
+     */
+    private static final class RippleExecutor implements Command {
+        private final Player controller;
+        private final Card c;
+        private static final long serialVersionUID = -845154812215847505L;
+
+        /**
+         * TODO: Write javadoc for Constructor.
+         * @param controller
+         * @param c
+         */
+        private RippleExecutor(Player controller, Card c) {
+            this.controller = controller;
+            this.c = c;
+        }
+
+        @Override
+        public void execute() {
+
+            final List<Card> thrummingStones = controller.getCardsIn(ZoneType.Battlefield, "Thrumming Stone");
+            for (int i = 0; i < thrummingStones.size(); i++) {
+                c.addExtrinsicKeyword("Ripple:4");
+            }
+
+            final ArrayList<String> a = c.getKeyword();
+            for (int x = 0; x < a.size(); x++) {
+                if (a.get(x).toString().startsWith("Ripple")) {
+                    final String parse = c.getKeyword().get(x).toString();
+                    final String[] k = parse.split(":");
+                    this.doRipple(c, Integer.valueOf(k[1]), controller);
+                }
+            }
+        } // execute()
+
+        void doRipple(final Card c, final int rippleCount, final Player controller) {
+            final Card rippleCard = c;
+            boolean activateRipple = false;
+            if (controller.isComputer() || GameActionUtil.showYesNoDialog(c, "Activate Ripple for " + c + "?")) {
+                    activateRipple = true;
+            }
+            if (activateRipple) {
+                final Ability ability = new RippleAbility(c, SpellManaCost.ZERO, controller, rippleCount, rippleCard);
                 final StringBuilder sb = new StringBuilder();
                 sb.append(c).append(" - Ripple.");
                 ability.setStackDescription(sb.toString());
@@ -337,9 +394,29 @@ public final class GameActionUtil {
 
             }
         }
-        };
+    }
+
+    private GameActionUtil() {
+        throw new AssertionError();
+    }
+
+    /**
+     * <p>
+     * executePlayCardEffects.
+     * </p>
+     * 
+     * @param sa
+     *            a {@link forge.card.spellability.SpellAbility} object.
+     */
+    public static void executePlayCardEffects(final SpellAbility sa) {
+        // (called in MagicStack.java)
+
+        final GameState game = Singletons.getModel().getGame(); 
+        final Command cascade = new CascadeExecutor(sa.getActivatingPlayer(), sa.getSourceCard(), game);
+        cascade.execute();
+        final Command ripple = new RippleExecutor(sa.getActivatingPlayer(), sa.getSourceCard());
         ripple.execute();
-    } // playCardRipple()
+    }
 
     /**
      * <p>
@@ -732,26 +809,14 @@ public final class GameActionUtil {
         }
 
         if (affected.hasStartOfKeyword("When CARDNAME is dealt damage, destroy it.")) {
-            final Ability ability = new Ability(source, SpellManaCost.ZERO) {
+            final Ability ability = new AbilityDestroy(source, affected, true);
-                @Override
+            final Ability ability2 = new AbilityDestroy(source, affected, false);
-                public void resolve() {
-                    Singletons.getModel().getGame().getAction().destroy(affected);
-                }
-            };
-
-            final Ability ability2 = new Ability(source, SpellManaCost.ZERO) {
-                @Override
-                public void resolve() {
-                    Singletons.getModel().getGame().getAction().destroyNoRegeneration(affected);
-                }
-            };
 
             final StringBuilder sb = new StringBuilder();
             sb.append(affected).append(" - destroy");
             ability.setStackDescription(sb.toString());
             ability2.setStackDescription(sb.toString());
-            final int amount = affected
+            final int amount = affected.getAmountOfKeyword("When CARDNAME is dealt damage, destroy it. It can't be regenerated.");
-                    .getAmountOfKeyword("When CARDNAME is dealt damage, destroy it. It can't be regenerated.");
 
             for (int i = 0; i < amount; i++) {
                 Singletons.getModel().getGame().getStack().addSimultaneousStackEntry(ability2);