checkstyle

src/main/java/forge/ComputerUtil_Attack2.java

@@ -1,23 +1,25 @@
 package forge;
 
-import forge.Constant.Zone;
-import forge.card.cardFactory.CardFactoryUtil;
-import forge.card.trigger.Trigger;
-
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Random;
 
+import forge.Constant.Zone;
+import forge.card.cardFactory.CardFactoryUtil;
+import forge.card.trigger.Trigger;
+
 //doesHumanAttackAndWin() uses the global variable AllZone.getComputerPlayer()
 /**
- * <p>ComputerUtil_Attack2 class.</p>
+ * <p>
+ * ComputerUtil_Attack2 class.
+ * </p>
  * 
  * @author Forge
  * @version $Id$
  */
 public class ComputerUtil_Attack2 {
 
-    //possible attackers and blockers
+    // possible attackers and blockers
     private CardList attackers;
     private CardList blockers;
     private CardList playerCreatures;
@@ -26,30 +28,42 @@ public class ComputerUtil_Attack2 {
     private Random random = MyRandom.random;
     private final int randomInt = random.nextInt();
 
-    private CardList humanList;   //holds human player creatures
+    private CardList humanList; // holds human player creatures
-    private CardList computerList; //holds computer creatures
+    private CardList computerList; // holds computer creatures
 
-    private int aiAggression = 0; // added by Masher, how aggressive the ai attack will be depending on circumstances
+    private int aiAggression = 0; // added by Masher, how aggressive the ai
+                                  // attack will be depending on circumstances
 
     /**
-     * <p>Constructor for ComputerUtil_Attack2.</p>
+     * <p>
+     * Constructor for ComputerUtil_Attack2.
+     * </p>
      * 
-     * @param possibleAttackers an array of {@link forge.Card} objects.
+     * @param possibleAttackers
-     * @param possibleBlockers an array of {@link forge.Card} objects.
+     *            an array of {@link forge.Card} objects.
-     * @param blockerLife a int.
+     * @param possibleBlockers
+     *            an array of {@link forge.Card} objects.
+     * @param blockerLife
+     *            a int.
      */
-    public ComputerUtil_Attack2(Card[] possibleAttackers, Card[] possibleBlockers, int blockerLife) {
+    public ComputerUtil_Attack2(final Card[] possibleAttackers, final Card[] possibleBlockers, final int blockerLife) {
         this(new CardList(possibleAttackers), new CardList(possibleBlockers), blockerLife);
     }
 
     /**
-     * <p>Constructor for ComputerUtil_Attack2.</p>
+     * <p>
+     * Constructor for ComputerUtil_Attack2.
+     * </p>
      * 
-     * @param possibleAttackers a {@link forge.CardList} object.
+     * @param possibleAttackers
-     * @param possibleBlockers a {@link forge.CardList} object.
+     *            a {@link forge.CardList} object.
-     * @param blockerLife a int.
+     * @param possibleBlockers
+     *            a {@link forge.CardList} object.
+     * @param blockerLife
+     *            a int.
      */
-    public ComputerUtil_Attack2(final CardList possibleAttackers, CardList possibleBlockers, int blockerLife) {
+    public ComputerUtil_Attack2(final CardList possibleAttackers,
+            final CardList possibleBlockers, final int blockerLife) {
         humanList = new CardList(possibleBlockers.toArray());
         humanList = humanList.getType("Creature");
 
@@ -61,18 +75,21 @@ public class ComputerUtil_Attack2 {
         attackers = getPossibleAttackers(possibleAttackers);
         blockers = getPossibleBlockers(possibleBlockers, attackers);
         this.blockerLife = blockerLife;
-    } //constructor
+    } // constructor
 
     /**
-     * <p>sortAttackers.</p>
+     * <p>
+     * sortAttackers.
+     * </p>
      * 
-     * @param in a {@link forge.CardList} object.
+     * @param in
+     *            a {@link forge.CardList} object.
      * @return a {@link forge.CardList} object.
      */
     public final CardList sortAttackers(final CardList in) {
         CardList list = new CardList();
 
-        //Cards with triggers should come first (for Battle Cry)
+        // Cards with triggers should come first (for Battle Cry)
         for (Card attacker : in) {
             ArrayList<Trigger> registeredTriggers = attacker.getTriggers();
             for (Trigger trigger : registeredTriggers) {
@@ -90,19 +107,23 @@ public class ComputerUtil_Attack2 {
         }
 
         return list;
-    } //sortAttackers()
+    } // sortAttackers()
 
-    //Is there any reward for attacking? (for 0/1 creatures there is not)
+    // Is there any reward for attacking? (for 0/1 creatures there is not)
     /**
-     * <p>isEffectiveAttacker.</p>
+     * <p>
+     * isEffectiveAttacker.
+     * </p>
      * 
-     * @param attacker a {@link forge.Card} object.
+     * @param attacker
-     * @param combat a {@link forge.Combat} object.
+     *            a {@link forge.Card} object.
+     * @param combat
+     *            a {@link forge.Combat} object.
      * @return a boolean.
      */
-    public final boolean isEffectiveAttacker(final Card attacker, Combat combat) {
+    public final boolean isEffectiveAttacker(final Card attacker, final Combat combat) {
 
-        //if the attacker will die when attacking don't attack
+        // if the attacker will die when attacking don't attack
         if (attacker.getNetDefense() + CombatUtil.predictToughnessBonusOfAttacker(attacker, null, combat) <= 0) {
             return false;
         }
@@ -116,7 +137,7 @@ public class ComputerUtil_Attack2 {
 
         CardList controlledByCompy = AllZone.getComputerPlayer().getAllCards();
 
-        for(Card c : controlledByCompy) {
+        for (Card c : controlledByCompy) {
             for (Trigger trigger : c.getTriggers()) {
                 if (CombatUtil.combatTriggerWillTrigger(attacker, null, trigger, combat)) {
                     return true;
@@ -128,12 +149,15 @@ public class ComputerUtil_Attack2 {
     }
 
     /**
-     * <p>getPossibleAttackers.</p>
+     * <p>
+     * getPossibleAttackers.
+     * </p>
      * 
-     * @param in a {@link forge.CardList} object.
+     * @param in
+     *            a {@link forge.CardList} object.
      * @return a {@link forge.CardList} object.
      */
-    public CardList getPossibleAttackers(CardList in) {
+    public final CardList getPossibleAttackers(final CardList in) {
         CardList list = new CardList(in.toArray());
         list = list.filter(new CardListFilter() {
             public boolean addCard(final Card c) {
@@ -141,16 +165,20 @@ public class ComputerUtil_Attack2 {
             }
         });
         return list;
-    } //getPossibleAttackers()
+    } // getPossibleAttackers()
 
     /**
-     * <p>getPossibleBlockers.</p>
+     * <p>
+     * getPossibleBlockers.
+     * </p>
      * 
-     * @param blockers a {@link forge.CardList} object.
+     * @param blockers
-     * @param attackers a {@link forge.CardList} object.
+     *            a {@link forge.CardList} object.
+     * @param attackers
+     *            a {@link forge.CardList} object.
      * @return a {@link forge.CardList} object.
      */
-    public final CardList getPossibleBlockers(CardList blockers, CardList attackers) {
+    public final CardList getPossibleBlockers(final CardList blockers, CardList attackers) {
         CardList possibleBlockers = new CardList(blockers.toArray());
         final CardList attackerList = new CardList(attackers.toArray());
         possibleBlockers = possibleBlockers.filter(new CardListFilter() {
@@ -167,24 +195,28 @@ public class ComputerUtil_Attack2 {
             }
         });
         return possibleBlockers;
-    }//getPossibleBlockers()
+    } // getPossibleBlockers()
 
-    //this checks to make sure that the computer player
+    // this checks to make sure that the computer player
-    //doesn't lose when the human player attacks
+    // doesn't lose when the human player attacks
-    //this method is used by getAttackers()
+    // this method is used by getAttackers()
     /**
-     * <p>notNeededAsBlockers.</p>
+     * <p>
+     * notNeededAsBlockers.
+     * </p>
      * 
-     * @param attackers a {@link forge.CardList} object.
+     * @param attackers
-     * @param combat a {@link forge.Combat} object.
+     *            a {@link forge.CardList} object.
+     * @param combat
+     *            a {@link forge.Combat} object.
      * @return a {@link forge.CardList} object.
      */
-    public final CardList notNeededAsBlockers(CardList attackers, Combat combat) {
+    public final CardList notNeededAsBlockers(final CardList attackers, Combat combat) {
         CardList notNeededAsBlockers = new CardList(attackers.toArray());
         CardListUtil.sortAttackLowFirst(attackers);
         int blockersNeeded = attackers.size();
 
-        //don't hold back creatures that can't block any of the human creatures
+        // don't hold back creatures that can't block any of the human creatures
         CardList list = getPossibleBlockers(attackers, humanList);
 
         for (int i = 0; i < list.size(); i++) {
@@ -201,9 +233,11 @@ public class ComputerUtil_Attack2 {
             return notNeededAsBlockers;
         }
 
-        // Increase the total number of blockers needed by 1 if Finest Hour in play
+        // Increase the total number of blockers needed by 1 if Finest Hour in
+        // play
         // (human will get an extra first attack with a creature that untaps)
-        // In addition, if the computer guesses it needs no blockers, make sure that
+        // In addition, if the computer guesses it needs no blockers, make sure
+        // that
         // it won't be surprised by Exalted
         int humanExaltedBonus = countExaltedBonus(AllZone.getHumanPlayer());
 
@@ -212,93 +246,112 @@ public class ComputerUtil_Attack2 {
 
             if ((blockersNeeded == 0 || nFinestHours > 0) && humanList.size() > 0) {
                 //
-                // total attack = biggest creature + exalted, *2 if Rafiq is in play
+                // total attack = biggest creature + exalted, *2 if Rafiq is in
+                // play
                 int humanBaseAttack = getAttack(humanList.get(0)) + humanExaltedBonus;
                 if (nFinestHours > 0) {
-                    // For Finest Hour, one creature could attack and get the bonus TWICE
+                    // For Finest Hour, one creature could attack and get the
+                    // bonus TWICE
                     humanBaseAttack = humanBaseAttack + humanExaltedBonus;
                 }
-                int totalExaltedAttack = AllZoneUtil.isCardInPlay("Rafiq of the Many", AllZone.getHumanPlayer()) ?
+                int totalExaltedAttack = AllZoneUtil.isCardInPlay("Rafiq of the Many",
-                        2 * humanBaseAttack : humanBaseAttack;
+                        AllZone.getHumanPlayer()) ? 2 * humanBaseAttack : humanBaseAttack;
                 if ((AllZone.getComputerPlayer().getLife() - 3) <= totalExaltedAttack) {
-                    // We will lose if there is an Exalted attack -- keep one blocker
+                    // We will lose if there is an Exalted attack -- keep one
-                    if (blockersNeeded == 0 && notNeededAsBlockers.size() > 0)
+                    // blocker
+                    if (blockersNeeded == 0 && notNeededAsBlockers.size() > 0) {
                         notNeededAsBlockers.remove(0);
+                    }
 
-                    // Finest Hour allows a second Exalted attack: keep a blocker for that too
+                    // Finest Hour allows a second Exalted attack: keep a
-                    if (nFinestHours > 0 && notNeededAsBlockers.size() > 0)
+                    // blocker for that too
+                    if (nFinestHours > 0 && notNeededAsBlockers.size() > 0) {
                         notNeededAsBlockers.remove(0);
+                    }
                 }
             }
         }
 
-        //re-add creatures with vigilance
+        // re-add creatures with vigilance
         for (Card c : attackers) {
-            if (c.hasKeyword("Vigilance"))
+            if (c.hasKeyword("Vigilance")) {
                 notNeededAsBlockers.add(c);
+            }
         }
 
         return notNeededAsBlockers;
     }
 
-    //this uses a global variable, which isn't perfect
+    // this uses a global variable, which isn't perfect
     /**
-     * <p>doesHumanAttackAndWin.</p>
+     * <p>
+     * doesHumanAttackAndWin.
+     * </p>
      * 
-     * @param nBlockingCreatures a int.
+     * @param nBlockingCreatures
+     *            a int.
      * @return a boolean.
      */
-    public boolean doesHumanAttackAndWin(int nBlockingCreatures) {
+    public final boolean doesHumanAttackAndWin(final int nBlockingCreatures) {
         int totalAttack = 0;
         int stop = humanList.size() - nBlockingCreatures;
 
-        for (int i = 0; i < stop; i++)
+        for (int i = 0; i < stop; i++) {
             totalAttack += getAttack(humanList.get(i));
+        }
 
-        //originally -3 so the computer will try to stay at 3 life
+        // originally -3 so the computer will try to stay at 3 life
-        //0 now to prevent the AI from not attacking when it's got low life
+        // 0 now to prevent the AI from not attacking when it's got low life
-        //(seems to happen too often)
+        // (seems to happen too often)
         return AllZone.getComputerPlayer().getLife() <= totalAttack;
     }
 
     /**
-     * <p>doAssault.</p>
+     * <p>
+     * doAssault.
+     * </p>
      * 
      * @return a boolean.
      */
     private boolean doAssault() {
-        //Beastmaster Ascension
+        // Beastmaster Ascension
         if (AllZoneUtil.isCardInPlay("Beastmaster Ascension", AllZone.getComputerPlayer()) && attackers.size() > 1) {
-            CardList beastions = AllZone.getComputerPlayer().getCardsIn(Constant.Zone.Battlefield).
+            CardList beastions = AllZone.getComputerPlayer().getCardsIn(Constant.Zone.Battlefield)
-                    getName("Beastmaster Ascension");
+                    .getName("Beastmaster Ascension");
             int minCreatures = 7;
             for (Card beastion : beastions) {
                 int counters = beastion.getCounters(Counters.QUEST);
                 minCreatures = Math.min(minCreatures, 7 - counters);
             }
-            if (attackers.size() >= minCreatures)
+            if (attackers.size() >= minCreatures) {
                 return true;
+            }
         }
 
-        //I think this is right but the assault code may still be a little off
+        // I think this is right but the assault code may still be a little off
         CardListUtil.sortAttackLowFirst(attackers);
 
         int totalAttack = 0;
-        //presumes the Human will block
+        // presumes the Human will block
-        for (int i = 0; i < (attackers.size() - blockers.size()); i++)
+        for (int i = 0; i < (attackers.size() - blockers.size()); i++) {
             totalAttack += getAttack(attackers.get(i));
+        }
 
         return blockerLife <= totalAttack;
-    }//doAssault()
+    } // doAssault()
 
     /**
-     * <p>chooseDefender.</p>
+     * <p>
+     * chooseDefender.
+     * </p>
      * 
-     * @param c a {@link forge.Combat} object.
+     * @param c
-     * @param bAssault a boolean.
+     *            a {@link forge.Combat} object.
+     * @param bAssault
+     *            a boolean.
      */
-    public void chooseDefender(Combat c, boolean bAssault) {
+    public final void chooseDefender(final Combat c, final boolean bAssault) {
-        // TODO: split attackers to different planeswalker/human
+        // TODO split attackers to different planeswalker/human
         // AI will only attack one Defender per combat for now
         ArrayList<Object> defs = c.getDefenders();
 
@@ -307,39 +360,39 @@ public class ComputerUtil_Attack2 {
         int n = MyRandom.random.nextInt(defs.size());
 
         Object entity = AllZone.getComputerPlayer().getMustAttackEntity();
-        if(null != entity) {
+        if (null != entity) {
-        	ArrayList<Object> defenders = AllZone.getCombat().getDefenders();
+            ArrayList<Object> defenders = AllZone.getCombat().getDefenders();
-        	n = defenders.indexOf(entity);
+            n = defenders.indexOf(entity);
-        	if(-1 == n) {
+            if (-1 == n) {
-        		System.out.println("getMustAttackEntity() returned something not in defenders.");
+                System.out.println("getMustAttackEntity() returned something not in defenders.");
-        		c.setCurrentDefender(0);
+                c.setCurrentDefender(0);
-        	}
+            } else {
-        	else {
+                c.setCurrentDefender(n);
-        		c.setCurrentDefender(n);
+            }
-        	}
+        } else {
-        }
-        else {
             if (defs.size() == 1 || bAssault) {
                 c.setCurrentDefender(0);
+            } else {
+                c.setCurrentDefender(n);
             }
-            else c.setCurrentDefender(n);
         }
 
         return;
     }
 
-
     /**
-     * <p>Getter for the field <code>attackers</code>.</p>
+     * <p>
+     * Getter for the field <code>attackers</code>.
+     * </p>
      * 
      * @return a {@link forge.Combat} object.
      */
     public Combat getAttackers() {
-        //if this method is called multiple times during a turn,
+        // if this method is called multiple times during a turn,
-        //it will always return the same value
+        // it will always return the same value
-        //randomInt is used so that the computer doesn't always
+        // randomInt is used so that the computer doesn't always
-        //do the same thing on turn 3 if he had the same creatures in play
+        // do the same thing on turn 3 if he had the same creatures in play
-        //I know this is a little confusing
+        // I know this is a little confusing
         random.setSeed(AllZone.getPhase().getTurn() + randomInt);
 
         Combat combat = new Combat();
@@ -354,16 +407,15 @@ public class ComputerUtil_Attack2 {
 
         CardList attackersLeft = new CardList(attackers.toArray());
 
-        //Attackers that don't really have a choice
+        // Attackers that don't really have a choice
         for (Card attacker : attackers) {
             if ((attacker.hasKeyword("CARDNAME attacks each turn if able.")
                     || attacker.hasKeyword("At the beginning of the end step, destroy CARDNAME.")
                     || attacker.hasKeyword("At the beginning of the end step, exile CARDNAME.")
                     || attacker.hasKeyword("At the beginning of the end step, sacrifice CARDNAME.")
-                    || attacker.getSacrificeAtEOT()
+                    || attacker.getSacrificeAtEOT() || attacker.getSirenAttackOrDestroy() || (attacker.getController()
-                    || attacker.getSirenAttackOrDestroy()
+                    .getMustAttackEntity() != null)) && CombatUtil.canAttack(attacker, combat))
-                    || (attacker.getController().getMustAttackEntity() != null))
+            {
-                    && CombatUtil.canAttack(attacker, combat)) {
                 combat.addAttacker(attacker);
                 attackersLeft.remove(attacker);
             }
@@ -380,19 +432,21 @@ public class ComputerUtil_Attack2 {
         // examine the potential forces
         CardList nextTurnAttackers = new CardList();
         int candidateCounterAttackDamage = 0;
-        //int candidateTotalBlockDamage = 0;
+        // int candidateTotalBlockDamage = 0;
         for (Card pCard : playerCreatures) {
 
-            // if the creature can attack next turn add it to counter attackers list
+            // if the creature can attack next turn add it to counter attackers
+            // list
             if (CombatUtil.canAttackNextTurn(pCard)) {
                 nextTurnAttackers.add(pCard);
                 if (pCard.getNetCombatDamage() > 0) {
                     candidateCounterAttackDamage += pCard.getNetCombatDamage();
-                    //candidateTotalBlockDamage += pCard.getNetCombatDamage();
+                    // candidateTotalBlockDamage += pCard.getNetCombatDamage();
                     playerForces += 1; // player forces they might use to attack
                 }
             }
-            // increment player forces that are relevant to an attritional attack - includes walls
+            // increment player forces that are relevant to an attritional
+            // attack - includes walls
             if (CombatUtil.canBlock(pCard)) {
                 playerForcesForAttritionalAttack += 1;
             }
@@ -408,7 +462,8 @@ public class ComputerUtil_Attack2 {
         CardList candidateAttackers = new CardList();
         int candidateUnblockedDamage = 0;
         for (Card pCard : computerList) {
-            // if the creature can attack then it's a potential attacker this turn, assume summoning sickness creatures will be able to
+            // if the creature can attack then it's a potential attacker this
+            // turn, assume summoning sickness creatures will be able to
             if (CombatUtil.canAttackNextTurn(pCard)) {
 
                 candidateAttackers.add(pCard);
@@ -422,24 +477,36 @@ public class ComputerUtil_Attack2 {
 
         // find the potential damage ratio the AI can cause
         double playerLifeToDamageRatio = 1000000;
-        if (candidateUnblockedDamage > 0)
+        if (candidateUnblockedDamage > 0) {
             playerLifeToDamageRatio = (double) AllZone.getHumanPlayer().life / candidateUnblockedDamage;
+        }
 
-        /*System.out.println(String.valueOf(aiLifeToPlayerDamageRatio) + " = ai life to player damage ratio");
+        /*
-			System.out.println(String.valueOf(playerLifeToDamageRatio) + " = player life ai player damage ratio");*/
+         * System.out.println(String.valueOf(aiLifeToPlayerDamageRatio) +
+         * " = ai life to player damage ratio");
+         * System.out.println(String.valueOf(playerLifeToDamageRatio) +
+         * " = player life ai player damage ratio");
+         */
 
         // determine if the ai outnumbers the player
         int outNumber = computerForces - playerForces;
 
         // compare the ratios, higher = better for ai
         double ratioDiff = aiLifeToPlayerDamageRatio - playerLifeToDamageRatio;
-        /* System.out.println(String.valueOf(ratioDiff) + " = ratio difference, higher = better for ai");
+        /*
-			System.out.println(String.valueOf(outNumber) + " = outNumber, higher = better for ai"); */
+         * System.out.println(String.valueOf(ratioDiff) +
+         * " = ratio difference, higher = better for ai");
+         * System.out.println(String.valueOf(outNumber) +
+         * " = outNumber, higher = better for ai");
+         */
 
         // *********************
-        // if outnumber and superior ratio work out whether attritional all out attacking will work
+        // if outnumber and superior ratio work out whether attritional all out
-        // attritional attack will expect some creatures to die but to achieve victory by sheer weight
+        // attacking will work
-        // of numbers attacking turn after turn. It's not calculate very carefully, the accuracy
+        // attritional attack will expect some creatures to die but to achieve
+        // victory by sheer weight
+        // of numbers attacking turn after turn. It's not calculate very
+        // carefully, the accuracy
         // can probably be improved
         // *********************
         boolean doAttritionalAttack = false;
@@ -455,14 +522,15 @@ public class ComputerUtil_Attack2 {
         // until the attackers are used up or the player would run out of life
         int attackRounds = 1;
         while (attritionalAttackers.size() > 0 && playerLife > 0 && attackRounds < 99) {
-            //   sum attacker damage
+            // sum attacker damage
             int damageThisRound = 0;
             for (int y = 0; y < attritionalAttackers.size(); y++) {
                 damageThisRound += attritionalAttackers.getCard(y).getNetCombatDamage();
             }
-            //   remove from player life
+            // remove from player life
             playerLife -= damageThisRound;
-            //   shorten attacker list by the length of the blockers - assuming all blocked are killed for convenience
+            // shorten attacker list by the length of the blockers - assuming
+            // all blocked are killed for convenience
             for (int z = 0; z < playerForcesForAttritionalAttack; z++) {
                 if (attritionalAttackers.size() > 0) {
                     attritionalAttackers.remove(attritionalAttackers.size() - 1);
@@ -473,7 +541,7 @@ public class ComputerUtil_Attack2 {
                 doAttritionalAttack = true;
             }
         }
-        //System.out.println(doAttritionalAttack + " = do attritional attack");
+        // System.out.println(doAttritionalAttack + " = do attritional attack");
         // *********************
         // end attritional attack calculation
         // *********************
@@ -486,7 +554,8 @@ public class ComputerUtil_Attack2 {
         boolean doUnblockableAttack = false;
         for (Card attacker : attackers) {
             boolean isUnblockableCreature = true;
-            // check blockers individually, as the bulk canBeBlocked doesn't check all circumstances
+            // check blockers individually, as the bulk canBeBlocked doesn't
+            // check all circumstances
             for (Card blocker : blockers) {
                 if (CombatUtil.canBlock(attacker, blocker)) {
                     isUnblockableCreature = false;
@@ -506,22 +575,33 @@ public class ComputerUtil_Attack2 {
         // end see how long until unblockable attackers will be fatal
         // *****************
 
-        // decide on attack aggression based on a comparison of forces, life totals and other considerations
+        // decide on attack aggression based on a comparison of forces, life
-        // some bad "magic numbers" here, TODO replace with nice descriptive variable names
+        // totals and other considerations
-        if ((ratioDiff > 0 && doAttritionalAttack)) { // (playerLifeToDamageRatio <= 1 && ratioDiff >= 1 && outNumber > 0)  ||
+        // some bad "magic numbers" here, TODO replace with nice descriptive
+        // variable names
+        if ((ratioDiff > 0 && doAttritionalAttack)) { // (playerLifeToDamageRatio
+                                                      // <= 1 && ratioDiff >= 1
+                                                      // && outNumber > 0) ||
             aiAggression = 5; // attack at all costs
-        } else if ((playerLifeToDamageRatio < 2 && ratioDiff >= 0) || ratioDiff > 3 || (ratioDiff > 0 && outNumber > 0)) {
+        } else if ((playerLifeToDamageRatio < 2 && ratioDiff >= 0)
-            aiAggression = 3;  // attack expecting to kill creatures or damage player.
+                || ratioDiff > 3 || (ratioDiff > 0 && outNumber > 0)) {
+            aiAggression = 3; // attack expecting to kill creatures or damage
+                              // player.
         } else if (ratioDiff >= 0 || ratioDiff + outNumber >= -1) {
-            // at 0 ratio expect to potentially gain an advantage by attacking first
+            // at 0 ratio expect to potentially gain an advantage by attacking
+            // first
             // if the ai has a slight advantage
-            // or the ai has a significant advantage numerically but only a slight disadvantage damage/life
+            // or the ai has a significant advantage numerically but only a
-            aiAggression = 2; // attack expecting to destroy creatures/be unblockable
+            // slight disadvantage damage/life
+            aiAggression = 2; // attack expecting to destroy creatures/be
+                              // unblockable
         } else if (ratioDiff < 0 && aiLifeToPlayerDamageRatio > 1) {
             // the player is overmatched but there are a few turns before death
-            aiAggression = 2; // attack expecting to destroy creatures/be unblockable
+            aiAggression = 2; // attack expecting to destroy creatures/be
+                              // unblockable
         } else if (doUnblockableAttack || ((ratioDiff * -1) < turnsUntilDeathByUnblockable)) {
-            aiAggression = 1; // look for unblockable creatures that might be able to attack for a bit of
+            aiAggression = 1; // look for unblockable creatures that might be
+                              // able to attack for a bit of
             // fatal damage even if the player is significantly better
         } else if (ratioDiff < 0) {
             aiAggression = 0;
@@ -532,13 +612,15 @@ public class ComputerUtil_Attack2 {
         // End of edits
         // ****************
 
-        //Exalted
+        // Exalted
-        if (combat.getAttackers().length == 0 && (countExaltedBonus(AllZone.getComputerPlayer()) >= 3 ||
+        if (combat.getAttackers().length == 0
-                AllZoneUtil.isCardInPlay("Rafiq of the Many", AllZone.getComputerPlayer()) ||
+                && (countExaltedBonus(AllZone.getComputerPlayer()) >= 3
-                AllZone.getComputerPlayer().getCardsIn(Zone.Battlefield, "Battlegrace Angel").size() >= 2 ||
+                        || AllZoneUtil.isCardInPlay("Rafiq of the Many", AllZone.getComputerPlayer())
-                (AllZone.getComputerPlayer().getCardsIn(Zone.Battlefield, "Finest Hour").size() >= 1) &&
+                        || AllZone.getComputerPlayer()
-                        AllZone.getPhase().isFirstCombat())
+                        .getCardsIn(Zone.Battlefield, "Battlegrace Angel").size() >= 2 || (AllZone
-                && !bAssault) {
+                        .getComputerPlayer().getCardsIn(Zone.Battlefield, "Finest Hour").size() >= 1)
+                        && AllZone.getPhase().isFirstCombat()) && !bAssault)
+        {
             int biggest = 0;
             Card att = null;
             for (int i = 0; i < attackersLeft.size(); i++) {
@@ -547,19 +629,23 @@ public class ComputerUtil_Attack2 {
                     att = attackersLeft.get(i);
                 }
             }
-            if (att != null && CombatUtil.canAttack(att, combat))
+            if (att != null && CombatUtil.canAttack(att, combat)) {
                 combat.addAttacker(att);
+            }
 
             System.out.println("Exalted");
         }
 
-        //do assault (all creatures attack) if the computer would win the game
+        // do assault (all creatures attack) if the computer would win the game
-        //or if the computer has 4 creatures and the player has 1
+        // or if the computer has 4 creatures and the player has 1
         else if (bAssault) {
             System.out.println("Assault");
             CardListUtil.sortAttack(attackersLeft);
-            for (int i = 0; i < attackersLeft.size(); i++)
+            for (int i = 0; i < attackersLeft.size(); i++) {
-                if (CombatUtil.canAttack(attackersLeft.get(i), combat)) combat.addAttacker(attackersLeft.get(i));
+                if (CombatUtil.canAttack(attackersLeft.get(i), combat)) {
+                    combat.addAttacker(attackersLeft.get(i));
+                }
+            }
         } else {
             System.out.println("Normal attack");
 
@@ -571,28 +657,36 @@ public class ComputerUtil_Attack2 {
             for (int i = 0; i < attackersLeft.size(); i++) {
                 Card attacker = attackersLeft.get(i);
                 int totalFirstStrikeBlockPower = 0;
-                if (!attacker.hasFirstStrike() && !attacker.hasDoubleStrike())
+                if (!attacker.hasFirstStrike() && !attacker.hasDoubleStrike()) {
-                    totalFirstStrikeBlockPower = CombatUtil.getTotalFirstStrikeBlockPower(attacker, AllZone.getHumanPlayer());
+                    totalFirstStrikeBlockPower = CombatUtil.getTotalFirstStrikeBlockPower(attacker,
+                            AllZone.getHumanPlayer());
+                }
 
-                if (shouldAttack(attacker, blockers, combat) && (totalFirstStrikeBlockPower < attacker.getKillDamage() || aiAggression == 5)
+                if (shouldAttack(attacker, blockers, combat)
+                        && (totalFirstStrikeBlockPower < attacker.getKillDamage() || aiAggression == 5)
                         && CombatUtil.canAttack(attacker, combat))
+                {
                     combat.addAttacker(attacker);
+                }
             }
-        }//getAttackers()
+        } // getAttackers()
 
         return combat;
-    }//getAttackers()
+    } // getAttackers()
 
     /**
-     * <p>countExaltedBonus.</p>
+     * <p>
+     * countExaltedBonus.
+     * </p>
      * 
-     * @param player a {@link forge.Player} object.
+     * @param player
+     *            a {@link forge.Player} object.
      * @return a int.
      */
-    public int countExaltedBonus(Player player) {
+    public final int countExaltedBonus(final Player player) {
         CardList list = player.getCardsIn(Zone.Battlefield);
         list = list.filter(new CardListFilter() {
-            public boolean addCard(Card c) {
+            public boolean addCard(final Card c) {
                 return c.hasKeyword("Exalted");
             }
         });
@@ -601,92 +695,125 @@ public class ComputerUtil_Attack2 {
     }
 
     /**
-     * <p>getAttack.</p>
+     * <p>
+     * getAttack.
+     * </p>
      * 
-     * @param c a {@link forge.Card} object.
+     * @param c
+     *            a {@link forge.Card} object.
      * @return a int.
      */
-    public int getAttack(Card c) {
+    public final int getAttack(final Card c) {
         int n = c.getNetCombatDamage();
 
-        if (c.hasKeyword("Double Strike"))
+        if (c.hasKeyword("Double Strike")) {
             n *= 2;
+        }
 
         return n;
     }
 
     /**
-     * <p>shouldAttack.</p>
+     * <p>
+     * shouldAttack.
+     * </p>
      * 
-     * @param attacker a {@link forge.Card} object.
+     * @param attacker
-     * @param defenders a {@link forge.CardList} object.
+     *            a {@link forge.Card} object.
-     * @param combat a {@link forge.Combat} object.
+     * @param defenders
+     *            a {@link forge.CardList} object.
+     * @param combat
+     *            a {@link forge.Combat} object.
      * @return a boolean.
      */
-    public boolean shouldAttack(Card attacker, CardList defenders, Combat combat) {
+    public final boolean shouldAttack(final Card attacker, final CardList defenders, final Combat combat) {
-        boolean canBeKilledByOne = false; // indicates if the attacker can be killed by a single blockers
+        boolean canBeKilledByOne = false; // indicates if the attacker can be
-        boolean canKillAll = true; // indicates if the attacker can kill all single blockers
+                                          // killed by a single blockers
-        boolean canKillAllDangerous = true; // indicates if the attacker can kill all single blockers with wither or infect
+        boolean canKillAll = true; // indicates if the attacker can kill all
+                                   // single blockers
+        boolean canKillAllDangerous = true; // indicates if the attacker can
+                                            // kill all single blockers with
+                                            // wither or infect
         boolean isWorthLessThanAllKillers = true;
         boolean canBeBlocked = false;
 
-        if (!isEffectiveAttacker(attacker, combat)) return false;
+        if (!isEffectiveAttacker(attacker, combat)) {
+            return false;
+        }
 
-        // look at the attacker in relation to the blockers to establish a number of factors about the attacking
+        // look at the attacker in relation to the blockers to establish a
-        // context that will be relevant to the attackers decision according to the selected strategy
+        // number of factors about the attacking
+        // context that will be relevant to the attackers decision according to
+        // the selected strategy
         for (Card defender : defenders) {
-            if (CombatUtil.canBlock(attacker, defender)) { //, combat )) {
+            if (CombatUtil.canBlock(attacker, defender)) { // , combat )) {
                 canBeBlocked = true;
                 if (CombatUtil.canDestroyAttacker(attacker, defender, combat, false)) {
-                    canBeKilledByOne = true;  // there is a single creature on the battlefield that can kill the creature
+                    canBeKilledByOne = true; // there is a single creature on
-                    // see if the defending creature is of higher or lower value. We don't want to attack only to lose value
+                                             // the battlefield that can kill
+                                             // the creature
+                    // see if the defending creature is of higher or lower
+                    // value. We don't want to attack only to lose value
                     if (CardFactoryUtil.evaluateCreature(defender) <= CardFactoryUtil.evaluateCreature(attacker)) {
                         isWorthLessThanAllKillers = false;
                     }
                 }
-                // see if this attacking creature can destroy this defender, if not record that it can't kill everything
+                // see if this attacking creature can destroy this defender, if
+                // not record that it can't kill everything
                 if (!CombatUtil.canDestroyBlocker(defender, attacker, combat, false)) {
                     canKillAll = false;
                     if (defender.hasKeyword("Wither") || defender.hasKeyword("Infect")) {
-                        canKillAllDangerous = false; // there is a dangerous creature that can survive an attack from this creature
+                        canKillAllDangerous = false; // there is a dangerous
+                                                     // creature that can
+                                                     // survive an attack from
+                                                     // this creature
                     }
                 }
             }
         }
 
-        // if the creature cannot block and can kill all opponents they might as well attack, they do nothing staying back
+        // if the creature cannot block and can kill all opponents they might as
+        // well attack, they do nothing staying back
         if (canKillAll && !CombatUtil.canBlock(attacker) && isWorthLessThanAllKillers) {
-            System.out.println(attacker.getName() + " = attacking because they can't block, expecting to kill or damage player");
+            System.out.println(attacker.getName()
+                    + " = attacking because they can't block, expecting to kill or damage player");
             return true;
         }
 
-        // decide if the creature should attack based on the prevailing strategy choice in aiAggression
+        // decide if the creature should attack based on the prevailing strategy
+        // choice in aiAggression
         switch (aiAggression) {
-            case 5: // all out attacking
+        case 5: // all out attacking
-                System.out.println(attacker.getName() + " = all out attacking");
+            System.out.println(attacker.getName() + " = all out attacking");
+            return true;
+        case 4: // expecting to at least trade with something
+            if (canKillAll || (canKillAllDangerous && !canBeKilledByOne) || !canBeBlocked) {
+                System.out.println(attacker.getName() + " = attacking expecting to at least trade with something");
                 return true;
-            case 4: // expecting to at least trade with something
+            }
-                if (canKillAll || (canKillAllDangerous && !canBeKilledByOne) || !canBeBlocked) {
+        case 3: // expecting to at least kill a creature of equal value, not be
-                    System.out.println(attacker.getName() + " = attacking expecting to at least trade with something");
+                // blocked
-                    return true;
+            if ((canKillAll && isWorthLessThanAllKillers) || (canKillAllDangerous && !canBeKilledByOne)
-                }
+                    || !canBeBlocked) {
-            case 3: // expecting to at least kill a creature of equal value, not be blocked
+                System.out.println(attacker.getName()
-                if ((canKillAll && isWorthLessThanAllKillers) || (canKillAllDangerous && !canBeKilledByOne) || !canBeBlocked) {
+                        + " = attacking expecting to kill creature or cause damage, or is unblockable");
-                    System.out.println(attacker.getName() + " = attacking expecting to kill creature or cause damage, or is unblockable");
+                return true;
-                    return true;
+            }
-                }
+        case 2: // attack expecting to attract a group block or destroying a
-            case 2: // attack expecting to attract a group block or destroying a single blocker and surviving
+                // single blocker and surviving
-                if ((canKillAll && !canBeKilledByOne) || !canBeBlocked) {
+            if ((canKillAll && !canBeKilledByOne) || !canBeBlocked) {
-                    System.out.println(attacker.getName() + " = attacking expecting to survive or attract group block");
+                System.out.println(attacker.getName() + " = attacking expecting to survive or attract group block");
-                    return true;
+                return true;
-                }
+            }
-            case 1: // unblockable creatures only
+        case 1: // unblockable creatures only
-                if (!canBeBlocked) {
+            if (!canBeBlocked) {
-                    System.out.println(attacker.getName() + " = attacking expecting not to be blocked");
+                System.out.println(attacker.getName() + " = attacking expecting not to be blocked");
-                    return true;
+                return true;
-                }
+            }
+        default:
+            break;
         }
         return false; // don't attack
     }
 
-}//end class ComputerUtil_Attack2
+} // end class ComputerUtil_Attack2

src/main/java/forge/ComputerUtil_Block2.java

@@ -1,31 +1,43 @@
 package forge;
 
-import forge.card.cardFactory.CardFactoryUtil;
-
 import java.util.ArrayList;
 
+import forge.card.cardFactory.CardFactoryUtil;
 
 /**
- * <p>ComputerUtil_Block2 class.</p>
+ * <p>
+ * ComputerUtil_Block2 class.
+ * </p>
  * 
  * @author Forge
  * @version $Id$
  */
 public class ComputerUtil_Block2 {
-    /** Constant <code>attackers</code> */
+    /** Constant <code>attackers</code>. */
-    private static CardList attackers = new CardList(); //all attackers
+    private static CardList attackers = new CardList(); // all attackers
-    /** Constant <code>attackersLeft</code> */
+    /** Constant <code>attackersLeft</code>. */
-    private static CardList attackersLeft = new CardList(); //keeps track of all currently unblocked attackers
+    private static CardList attackersLeft = new CardList(); // keeps track of
-    /** Constant <code>blockedButUnkilled</code> */
+                                                            // all currently
-    private static CardList blockedButUnkilled = new CardList(); //blocked attackers that currently wouldn't be destroyed
+                                                            // unblocked
-    /** Constant <code>blockersLeft</code> */
+                                                            // attackers
-    private static CardList blockersLeft = new CardList(); //keeps track of all unassigned blockers
+    /** Constant <code>blockedButUnkilled</code>. */
-    /** Constant <code>diff=0</code> */
+    private static CardList blockedButUnkilled = new CardList(); // blocked
+                                                                 // attackers
+                                                                 // that
+                                                                 // currently
+                                                                 // wouldn't be
+                                                                 // destroyed
+    /** Constant <code>blockersLeft</code>. */
+    private static CardList blockersLeft = new CardList(); // keeps track of all
+                                                           // unassigned
+                                                           // blockers
+    /** Constant <code>diff=0</code>. */
     private static int diff = 0;
 
-
     /**
-     * <p>Getter for the field <code>attackers</code>.</p>
+     * <p>
+     * Getter for the field <code>attackers</code>.
+     * </p>
      * 
      * @return a {@link forge.CardList} object.
      */
@@ -34,16 +46,21 @@ public class ComputerUtil_Block2 {
     }
 
     /**
-     * <p>Setter for the field <code>attackers</code>.</p>
+     * <p>
+     * Setter for the field <code>attackers</code>.
+     * </p>
      * 
-     * @param cardList a {@link forge.CardList} object.
+     * @param cardList
+     *            a {@link forge.CardList} object.
      */
-    private static void setAttackers(CardList cardList) {
+    private static void setAttackers(final CardList cardList) {
         attackers = (cardList);
     }
 
     /**
-     * <p>Getter for the field <code>attackersLeft</code>.</p>
+     * <p>
+     * Getter for the field <code>attackersLeft</code>.
+     * </p>
      * 
      * @return a {@link forge.CardList} object.
      */
@@ -52,16 +69,21 @@ public class ComputerUtil_Block2 {
     }
 
     /**
-     * <p>Setter for the field <code>attackersLeft</code>.</p>
+     * <p>
+     * Setter for the field <code>attackersLeft</code>.
+     * </p>
      * 
-     * @param cardList a {@link forge.CardList} object.
+     * @param cardList
+     *            a {@link forge.CardList} object.
      */
-    private static void setAttackersLeft(CardList cardList) {
+    private static void setAttackersLeft(final CardList cardList) {
         attackersLeft = (cardList);
     }
 
     /**
-     * <p>Getter for the field <code>blockedButUnkilled</code>.</p>
+     * <p>
+     * Getter for the field <code>blockedButUnkilled</code>.
+     * </p>
      * 
      * @return a {@link forge.CardList} object.
      */
@@ -71,16 +93,21 @@ public class ComputerUtil_Block2 {
     }
 
     /**
-     * <p>Setter for the field <code>blockedButUnkilled</code>.</p>
+     * <p>
+     * Setter for the field <code>blockedButUnkilled</code>.
+     * </p>
      * 
-     * @param cardList a {@link forge.CardList} object.
+     * @param cardList
+     *            a {@link forge.CardList} object.
      */
-    private static void setBlockedButUnkilled(CardList cardList) {
+    private static void setBlockedButUnkilled(final CardList cardList) {
         blockedButUnkilled = (cardList);
     }
 
     /**
-     * <p>Getter for the field <code>blockersLeft</code>.</p>
+     * <p>
+     * Getter for the field <code>blockersLeft</code>.
+     * </p>
      * 
      * @return a {@link forge.CardList} object.
      */
@@ -89,16 +116,21 @@ public class ComputerUtil_Block2 {
     }
 
     /**
-     * <p>Setter for the field <code>blockersLeft</code>.</p>
+     * <p>
+     * Setter for the field <code>blockersLeft</code>.
+     * </p>
      * 
-     * @param cardList a {@link forge.CardList} object.
+     * @param cardList
+     *            a {@link forge.CardList} object.
      */
-    private static void setBlockersLeft(CardList cardList) {
+    private static void setBlockersLeft(final CardList cardList) {
         blockersLeft = (cardList);
     }
 
     /**
-     * <p>Getter for the field <code>diff</code>.</p>
+     * <p>
+     * Getter for the field <code>diff</code>.
+     * </p>
      * 
      * @return a int.
      */
@@ -107,129 +139,166 @@ public class ComputerUtil_Block2 {
     }
 
     /**
-     * <p>Setter for the field <code>diff</code>.</p>
+     * <p>
+     * Setter for the field <code>diff</code>.
+     * </p>
      * 
-     * @param diff a int.
+     * @param diff
+     *            a int.
      */
-    private static void setDiff(int diff) {
+    private static void setDiff(final int diff) {
         ComputerUtil_Block2.diff = (diff);
     }
 
-
+    // finds the creatures able to block the attacker
-    //finds the creatures able to block the attacker
     /**
-     * <p>getPossibleBlockers.</p>
+     * <p>
+     * getPossibleBlockers.
+     * </p>
      * 
-     * @param attacker a {@link forge.Card} object.
+     * @param attacker
-     * @param blockersLeft a {@link forge.CardList} object.
+     *            a {@link forge.Card} object.
-     * @param combat a {@link forge.Combat} object.
+     * @param blockersLeft
+     *            a {@link forge.CardList} object.
+     * @param combat
+     *            a {@link forge.Combat} object.
      * @return a {@link forge.CardList} object.
      */
-    private static CardList getPossibleBlockers(Card attacker, CardList blockersLeft, Combat combat) {
+    private static CardList getPossibleBlockers(final Card attacker, final CardList blockersLeft, Combat combat) {
         CardList blockers = new CardList();
 
         for (Card blocker : blockersLeft) {
-            //if the blocker can block a creature with lure it can't block a creature without
+            // if the blocker can block a creature with lure it can't block a
-            if (CombatUtil.canBlock(attacker, blocker, combat)) blockers.add(blocker);
+            // creature without
+            if (CombatUtil.canBlock(attacker, blocker, combat)) {
+                blockers.add(blocker);
+            }
         }
 
         return blockers;
     }
 
-    //finds blockers that won't be destroyed
+    // finds blockers that won't be destroyed
     /**
-     * <p>getSafeBlockers.</p>
+     * <p>
+     * getSafeBlockers.
+     * </p>
      * 
-     * @param attacker a {@link forge.Card} object.
+     * @param attacker
-     * @param blockersLeft a {@link forge.CardList} object.
+     *            a {@link forge.Card} object.
-     * @param combat a {@link forge.Combat} object.
+     * @param blockersLeft
+     *            a {@link forge.CardList} object.
+     * @param combat
+     *            a {@link forge.Combat} object.
      * @return a {@link forge.CardList} object.
      */
-    private static CardList getSafeBlockers(Card attacker, CardList blockersLeft, Combat combat) {
+    private static CardList getSafeBlockers(final Card attacker, final CardList blockersLeft, Combat combat) {
         CardList blockers = new CardList();
 
         for (Card b : blockersLeft) {
-            if (!CombatUtil.canDestroyBlocker(b, attacker, combat, false)) blockers.add(b);
+            if (!CombatUtil.canDestroyBlocker(b, attacker, combat, false)) {
+                blockers.add(b);
+            }
         }
 
         return blockers;
     }
 
-    //finds blockers that destroy the attacker
+    // finds blockers that destroy the attacker
     /**
-     * <p>getKillingBlockers.</p>
+     * <p>
+     * getKillingBlockers.
+     * </p>
      * 
-     * @param attacker a {@link forge.Card} object.
+     * @param attacker
-     * @param blockersLeft a {@link forge.CardList} object.
+     *            a {@link forge.Card} object.
-     * @param combat a {@link forge.Combat} object.
+     * @param blockersLeft
+     *            a {@link forge.CardList} object.
+     * @param combat
+     *            a {@link forge.Combat} object.
      * @return a {@link forge.CardList} object.
      */
-    private static CardList getKillingBlockers(Card attacker, CardList blockersLeft, Combat combat) {
+    private static CardList getKillingBlockers(final Card attacker, final CardList blockersLeft, Combat combat) {
         CardList blockers = new CardList();
 
         for (Card b : blockersLeft) {
-            if (CombatUtil.canDestroyAttacker(attacker, b, combat, false)) blockers.add(b);
+            if (CombatUtil.canDestroyAttacker(attacker, b, combat, false)) {
+                blockers.add(b);
+            }
         }
 
         return blockers;
     }
 
     /**
-     * <p>sortPotentialAttackers.</p>
+     * <p>
+     * sortPotentialAttackers.
+     * </p>
      * 
-     * @param combat a {@link forge.Combat} object.
+     * @param combat
+     *            a {@link forge.Combat} object.
      * @return a {@link forge.CardList} object.
      */
-    public static CardList sortPotentialAttackers(Combat combat) {
+    public static CardList sortPotentialAttackers(final Combat combat) {
         CardList[] attackerLists = combat.sortAttackerByDefender();
         CardList sortedAttackers = new CardList();
 
         ArrayList<Object> defenders = combat.getDefenders();
 
-        //Begin with the attackers that pose the biggest threat
+        // Begin with the attackers that pose the biggest threat
         CardListUtil.sortByEvaluateCreature(attackerLists[0]);
         CardListUtil.sortAttack(attackerLists[0]);
 
         // If I don't have any planeswalkers than sorting doesn't really matter
-        if (defenders.size() == 1)
+        if (defenders.size() == 1) {
             return attackerLists[0];
+        }
 
         boolean bLifeInDanger = CombatUtil.lifeInDanger(combat);
 
-        // TODO: Add creatures attacking Planeswalkers in order of which we want to protect
+        // TODO Add creatures attacking Planeswalkers in order of which we want
-        // defend planeswalkers with more loyalty before planeswalkers with less loyalty
+        // to protect
+        // defend planeswalkers with more loyalty before planeswalkers with less
+        // loyalty
         // if planeswalker will be too difficult to defend don't even bother
         for (int i = 1; i < attackerLists.length; i++) {
-            //Begin with the attackers that pose the biggest threat
+            // Begin with the attackers that pose the biggest threat
             CardListUtil.sortAttack(attackerLists[i]);
-            for (Card c : attackerLists[i])
+            for (Card c : attackerLists[i]) {
                 sortedAttackers.add(c);
+            }
         }
 
         if (bLifeInDanger) {
             // add creatures attacking the Player to the front of the list
-            for (Card c : attackerLists[0])
+            for (Card c : attackerLists[0]) {
                 sortedAttackers.add(0, c);
+            }
 
         } else {
             // add creatures attacking the Player to the back of the list
-            for (Card c : attackerLists[0])
+            for (Card c : attackerLists[0]) {
                 sortedAttackers.add(c);
+            }
         }
 
         return sortedAttackers;
     }
 
-    // ======================= block assignment functions ================================
+    // ======================= block assignment functions
+    // ================================
 
     // Good Blocks means a good trade or no trade
     /**
-     * <p>makeGoodBlocks.</p>
+     * <p>
+     * makeGoodBlocks.
+     * </p>
      * 
-     * @param combat a {@link forge.Combat} object.
+     * @param combat
+     *            a {@link forge.Combat} object.
      * @return a {@link forge.Combat} object.
      */
-    private static Combat makeGoodBlocks(Combat combat) {
+    private static Combat makeGoodBlocks(final Combat combat) {
 
         CardList currentAttackers = new CardList(getAttackersLeft().toArray());
 
@@ -243,12 +312,12 @@ public class ComputerUtil_Block2 {
             CardList killingBlockers;
 
             if (safeBlockers.size() > 0) {
-                // 1.Blockers that can destroy the attacker but won't get destroyed
+                // 1.Blockers that can destroy the attacker but won't get
+                // destroyed
                 killingBlockers = getKillingBlockers(attacker, safeBlockers, combat);
-                if (killingBlockers.size() > 0) blocker = CardFactoryUtil.AI_getWorstCreature(killingBlockers);
+                if (killingBlockers.size() > 0) {
-
+                    blocker = CardFactoryUtil.AI_getWorstCreature(killingBlockers);
-                    // 2.Blockers that won't get destroyed
+                } else {
-                else {
                     blocker = CardFactoryUtil.AI_getWorstCreature(safeBlockers);
                     getBlockedButUnkilled().add(attacker);
                 }
@@ -256,10 +325,13 @@ public class ComputerUtil_Block2 {
             else {
                 killingBlockers = getKillingBlockers(attacker, blockers, combat);
                 if (killingBlockers.size() > 0) {
-                    // 3.Blockers that can destroy the attacker and are worth less
+                    // 3.Blockers that can destroy the attacker and are worth
+                    // less
                     Card worst = CardFactoryUtil.AI_getWorstCreature(killingBlockers);
 
-                    if (CardFactoryUtil.evaluateCreature(worst) + getDiff() < CardFactoryUtil.evaluateCreature(attacker)) {
+                    if (CardFactoryUtil.evaluateCreature(worst) + getDiff() < CardFactoryUtil
+                            .evaluateCreature(attacker))
+                    {
                         blocker = worst;
                     }
                 }
@@ -276,34 +348,43 @@ public class ComputerUtil_Block2 {
 
     // Good Gang Blocks means a good trade or no trade
     /**
-     * <p>makeGangBlocks.</p>
+     * <p>
+     * makeGangBlocks.
+     * </p>
      * 
-     * @param combat a {@link forge.Combat} object.
+     * @param combat
+     *            a {@link forge.Combat} object.
      * @return a {@link forge.Combat} object.
      */
-    private static Combat makeGangBlocks(Combat combat) {
+    private static Combat makeGangBlocks(final Combat combat) {
 
         CardList currentAttackers = new CardList(getAttackersLeft().toArray());
         currentAttackers = currentAttackers.getKeywordsDontContain("Rampage");
-        currentAttackers = currentAttackers.getKeywordsDontContain("CARDNAME can't be blocked by more than one creature.");
+        currentAttackers = currentAttackers
+                .getKeywordsDontContain("CARDNAME can't be blocked by more than one creature.");
         CardList blockers;
 
-        //Try to block an attacker without first strike with a gang of first strikers
+        // Try to block an attacker without first strike with a gang of first
+        // strikers
         for (Card attacker : getAttackersLeft()) {
-            if (!attacker.hasKeyword("First Strike")
+            if (!attacker.hasKeyword("First Strike") && !attacker.hasKeyword("Double Strike")) {
-                    && !attacker.hasKeyword("Double Strike")) {
                 blockers = getPossibleBlockers(attacker, getBlockersLeft(), combat);
                 CardList firstStrikeBlockers = new CardList();
                 CardList blockGang = new CardList();
-                for (int i = 0; i < blockers.size(); i++)
+                for (int i = 0; i < blockers.size(); i++) {
-                    if (blockers.get(i).hasFirstStrike() || blockers.get(i).hasDoubleStrike())
+                    if (blockers.get(i).hasFirstStrike() || blockers.get(i).hasDoubleStrike()) {
                         firstStrikeBlockers.add(blockers.get(i));
+                    }
+                }
 
                 if (firstStrikeBlockers.size() > 1) {
                     CardListUtil.sortAttack(firstStrikeBlockers);
                     for (Card blocker : firstStrikeBlockers) {
-                        int damageNeeded = attacker.getKillDamage() + CombatUtil.predictToughnessBonusOfAttacker(attacker, blocker, combat);
+                        int damageNeeded = attacker.getKillDamage()
-                        //if the total damage of the blockgang was not enough without but is enough with this blocker finish the blockgang
+                                + CombatUtil.predictToughnessBonusOfAttacker(attacker, blocker, combat);
+                        // if the total damage of the blockgang was not enough
+                        // without but is enough with this blocker finish the
+                        // blockgang
                         if (CombatUtil.totalDamageOfBlockers(attacker, blockGang) < damageNeeded) {
                             blockGang.add(blocker);
                             if (CombatUtil.totalDamageOfBlockers(attacker, blockGang) >= damageNeeded) {
@@ -322,26 +403,32 @@ public class ComputerUtil_Block2 {
         setAttackersLeft(new CardList(currentAttackers.toArray()));
         currentAttackers = new CardList(getAttackersLeft().toArray());
 
-        //Try to block an attacker with two blockers of which only one will die
+        // Try to block an attacker with two blockers of which only one will die
         for (final Card attacker : getAttackersLeft()) {
             blockers = getPossibleBlockers(attacker, getBlockersLeft(), combat);
             CardList usableBlockers;
             CardList blockGang = new CardList();
-            int absorbedDamage = 0; //The amount of damage needed to kill the first blocker
+            int absorbedDamage = 0; // The amount of damage needed to kill the
-            int currentValue = 0; //The value of the creatures in the blockgang
+                                    // first blocker
+            int currentValue = 0; // The value of the creatures in the blockgang
 
-            //Try to add blockers that could be destroyed, but are worth less than the attacker
+            // Try to add blockers that could be destroyed, but are worth less
-            //Don't use blockers without First Strike or Double Strike if attacker has it
+            // than the attacker
+            // Don't use blockers without First Strike or Double Strike if
+            // attacker has it
             usableBlockers = blockers.filter(new CardListFilter() {
-                public boolean addCard(Card c) {
+                public boolean addCard(final Card c) {
                     if ((attacker.hasKeyword("First Strike") || attacker.hasKeyword("Double Strike"))
                             && !(c.hasKeyword("First Strike") || c.hasKeyword("Double Strike")))
+                    {
                         return false;
+                    }
                     return CardFactoryUtil.evaluateCreature(c) + getDiff() < CardFactoryUtil.evaluateCreature(attacker);
                 }
             });
-            if (usableBlockers.size() < 2)
+            if (usableBlockers.size() < 2) {
                 return combat;
+            }
 
             Card leader = CardFactoryUtil.AI_getBestCreature(usableBlockers);
             blockGang.add(leader);
@@ -350,17 +437,23 @@ public class ComputerUtil_Block2 {
             currentValue = CardFactoryUtil.evaluateCreature(leader);
 
             for (Card blocker : usableBlockers) {
-                //Add an additional blocker if the current blockers are not enough and the new one would deal the remaining damage
+                // Add an additional blocker if the current blockers are not
+                // enough and the new one would deal the remaining damage
                 int currentDamage = CombatUtil.totalDamageOfBlockers(attacker, blockGang);
                 int additionalDamage = CombatUtil.dealsDamageAsBlocker(attacker, blocker);
                 int absorbedDamage2 = blocker.getEnoughDamageToKill(attacker.getNetCombatDamage(), attacker, true);
                 int addedValue = CardFactoryUtil.evaluateCreature(blocker);
-                int damageNeeded = attacker.getKillDamage() + CombatUtil.predictToughnessBonusOfAttacker(attacker, blocker, combat);
+                int damageNeeded = attacker.getKillDamage()
-                if (damageNeeded > currentDamage
+                        + CombatUtil.predictToughnessBonusOfAttacker(attacker, blocker, combat);
-                        && !(damageNeeded > currentDamage + additionalDamage) //The attacker will be killed
+                if (damageNeeded > currentDamage && !(damageNeeded > currentDamage + additionalDamage)
-                        && (absorbedDamage2 + absorbedDamage > attacker.getNetCombatDamage() //only one blocker can be killed
+                        // The attacker will be killed
-                        || currentValue + addedValue - 50 <= CardFactoryUtil.evaluateCreature(attacker)) //attacker is worth more
+                        && (absorbedDamage2 + absorbedDamage > attacker.getNetCombatDamage()
-                        && CombatUtil.canBlock(attacker, blocker, combat)) {//this is needed for attackers that can't be blocked by more than 1
+                                // only one blocker can be killed
+                        || currentValue + addedValue - 50 <= CardFactoryUtil.evaluateCreature(attacker))
+                        // attacker is worth more
+                        && CombatUtil.canBlock(attacker, blocker, combat))
+                {
+                    // this is needed for attackers that can't be blocked by more than 1
                     currentAttackers.remove(attacker);
                     combat.addBlocker(attacker, blocker);
                     combat.addBlocker(attacker, leader);
@@ -377,19 +470,22 @@ public class ComputerUtil_Block2 {
 
     // Bad Trade Blocks (should only be made if life is in danger)
     /**
-     * <p>makeTradeBlocks.</p>
+     * <p>
+     * makeTradeBlocks.
+     * </p>
      * 
-     * @param combat a {@link forge.Combat} object.
+     * @param combat
+     *            a {@link forge.Combat} object.
      * @return a {@link forge.Combat} object.
      */
-    private static Combat makeTradeBlocks(Combat combat) {
+    private static Combat makeTradeBlocks(final Combat combat) {
 
         CardList currentAttackers = new CardList(getAttackersLeft().toArray());
         CardList killingBlockers;
 
         for (Card attacker : getAttackersLeft()) {
-            killingBlockers =
+            killingBlockers = getKillingBlockers(attacker, getPossibleBlockers(attacker, getBlockersLeft(), combat),
-                    getKillingBlockers(attacker, getPossibleBlockers(attacker, getBlockersLeft(), combat), combat);
+                    combat);
             if (killingBlockers.size() > 0 && CombatUtil.lifeInDanger(combat)) {
                 Card blocker = CardFactoryUtil.AI_getWorstCreature(killingBlockers);
                 combat.addBlocker(attacker, blocker);
@@ -403,12 +499,15 @@ public class ComputerUtil_Block2 {
 
     // Chump Blocks (should only be made if life is in danger)
     /**
-     * <p>makeChumpBlocks.</p>
+     * <p>
+     * makeChumpBlocks.
+     * </p>
      * 
-     * @param combat a {@link forge.Combat} object.
+     * @param combat
+     *            a {@link forge.Combat} object.
      * @return a {@link forge.Combat} object.
      */
-    private static Combat makeChumpBlocks(Combat combat) {
+    private static Combat makeChumpBlocks(final Combat combat) {
 
         CardList currentAttackers = new CardList(getAttackersLeft().toArray());
         CardList chumpBlockers;
@@ -427,30 +526,42 @@ public class ComputerUtil_Block2 {
         return combat;
     }
 
-    //Reinforce blockers blocking attackers with trample (should only be made if life is in danger)
+    // Reinforce blockers blocking attackers with trample (should only be made
+    // if life is in danger)
     /**
-     * <p>reinforceBlockersAgainstTrample.</p>
+     * <p>
+     * reinforceBlockersAgainstTrample.
+     * </p>
      * 
-     * @param combat a {@link forge.Combat} object.
+     * @param combat
+     *            a {@link forge.Combat} object.
      * @return a {@link forge.Combat} object.
      */
-    private static Combat reinforceBlockersAgainstTrample(Combat combat) {
+    private static Combat reinforceBlockersAgainstTrample(final Combat combat) {
 
         CardList chumpBlockers;
 
         CardList tramplingAttackers = getAttackers().getKeyword("Trample");
-        tramplingAttackers = tramplingAttackers.getKeywordsDontContain("Rampage");     //Don't make it worse
+        tramplingAttackers = tramplingAttackers.getKeywordsDontContain("Rampage"); // Don't
-        tramplingAttackers = tramplingAttackers.getKeywordsDontContain("CARDNAME can't be blocked by more than one creature.");
+                                                                                   // make
-        //TODO - should check here for a "rampage-like" trigger that replaced the keyword:
+                                                                                   // it
+                                                                                   // worse
+        tramplingAttackers = tramplingAttackers
+                .getKeywordsDontContain("CARDNAME can't be blocked by more than one creature.");
+        // TODO - should check here for a "rampage-like" trigger that replaced
+        // the keyword:
         // "Whenever CARDNAME becomes blocked, it gets +1/+1 until end of turn for each creature blocking it."
 
         for (Card attacker : tramplingAttackers) {
             chumpBlockers = getPossibleBlockers(attacker, getBlockersLeft(), combat);
             for (Card blocker : chumpBlockers) {
-                //Add an additional blocker if the current blockers are not enough and the new one would suck some of the damage
+                // Add an additional blocker if the current blockers are not
-                if (CombatUtil.getAttack(attacker) > CombatUtil.totalShieldDamage(attacker, combat.getBlockers(attacker))
+                // enough and the new one would suck some of the damage
-                        && CombatUtil.shieldDamage(attacker, blocker) > 0 && CombatUtil.canBlock(attacker, blocker, combat)
+                if (CombatUtil.getAttack(attacker) > CombatUtil.totalShieldDamage(attacker,
-                        && CombatUtil.lifeInDanger(combat)) {
+                        combat.getBlockers(attacker))
+                        && CombatUtil.shieldDamage(attacker, blocker) > 0
+                        && CombatUtil.canBlock(attacker, blocker, combat) && CombatUtil.lifeInDanger(combat))
+                {
                     combat.addBlocker(attacker, blocker);
                     getBlockersLeft().remove(blocker);
                 }
@@ -460,54 +571,74 @@ public class ComputerUtil_Block2 {
         return combat;
     }
 
-    //Support blockers not destroying the attacker with more blockers to try to kill the attacker
+    // Support blockers not destroying the attacker with more blockers to try to
+    // kill the attacker
     /**
-     * <p>reinforceBlockersToKill.</p>
+     * <p>
+     * reinforceBlockersToKill.
+     * </p>
      * 
-     * @param combat a {@link forge.Combat} object.
+     * @param combat
+     *            a {@link forge.Combat} object.
      * @return a {@link forge.Combat} object.
      */
-    private static Combat reinforceBlockersToKill(Combat combat) {
+    private static Combat reinforceBlockersToKill(final Combat combat) {
 
         CardList safeBlockers;
         CardList blockers;
-        CardList targetAttackers = getBlockedButUnkilled().getKeywordsDontContain("Rampage");     //Don't make it worse
+        CardList targetAttackers = getBlockedButUnkilled().getKeywordsDontContain("Rampage"); // Don't
-        targetAttackers = targetAttackers.getKeywordsDontContain("CARDNAME can't be blocked by more than one creature.");
+                                                                                              // make
-        //TODO - should check here for a "rampage-like" trigger that replaced the keyword:
+                                                                                              // it
+                                                                                              // worse
+        targetAttackers = targetAttackers
+                .getKeywordsDontContain("CARDNAME can't be blocked by more than one creature.");
+        // TODO - should check here for a "rampage-like" trigger that replaced
+        // the keyword:
         // "Whenever CARDNAME becomes blocked, it gets +1/+1 until end of turn for each creature blocking it."
 
         for (Card attacker : targetAttackers) {
             blockers = getPossibleBlockers(attacker, getBlockersLeft(), combat);
 
-            //Try to use safe blockers first
+            // Try to use safe blockers first
             safeBlockers = getSafeBlockers(attacker, blockers, combat);
             for (Card blocker : safeBlockers) {
-                int damageNeeded = attacker.getKillDamage() + CombatUtil.predictToughnessBonusOfAttacker(attacker, blocker, combat);
+                int damageNeeded = attacker.getKillDamage()
-                //Add an additional blocker if the current blockers are not enough and the new one would deal additional damage
+                        + CombatUtil.predictToughnessBonusOfAttacker(attacker, blocker, combat);
+                // Add an additional blocker if the current blockers are not
+                // enough and the new one would deal additional damage
                 if (damageNeeded > CombatUtil.totalDamageOfBlockers(attacker, combat.getBlockers(attacker))
-                        && CombatUtil.dealsDamageAsBlocker(attacker, blocker) > 0 && CombatUtil.canBlock(attacker, blocker, combat)) {
+                        && CombatUtil.dealsDamageAsBlocker(attacker, blocker) > 0
+                        && CombatUtil.canBlock(attacker, blocker, combat))
+                {
                     combat.addBlocker(attacker, blocker);
                     getBlockersLeft().remove(blocker);
                 }
-                blockers.remove(blocker); //Don't check them again next
+                blockers.remove(blocker); // Don't check them again next
             }
 
-            //Try to add blockers that could be destroyed, but are worth less than the attacker
+            // Try to add blockers that could be destroyed, but are worth less
-            //Don't use blockers without First Strike or Double Strike if attacker has it
+            // than the attacker
+            // Don't use blockers without First Strike or Double Strike if
+            // attacker has it
             if (attacker.hasKeyword("First Strike") || attacker.hasKeyword("Double Strike")) {
                 safeBlockers = blockers.getKeyword("First Strike");
                 safeBlockers.addAll(blockers.getKeyword("Double Strike"));
-            } else safeBlockers = new CardList(blockers.toArray());
+            } else {
+                safeBlockers = new CardList(blockers.toArray());
+            }
 
             for (Card blocker : safeBlockers) {
-                int damageNeeded = attacker.getKillDamage() + CombatUtil.predictToughnessBonusOfAttacker(attacker, blocker, combat);
+                int damageNeeded = attacker.getKillDamage()
-                //Add an additional blocker if the current blockers are not enough and the new one would deal the remaining damage
+                        + CombatUtil.predictToughnessBonusOfAttacker(attacker, blocker, combat);
+                // Add an additional blocker if the current blockers are not
+                // enough and the new one would deal the remaining damage
                 int currentDamage = CombatUtil.totalDamageOfBlockers(attacker, combat.getBlockers(attacker));
                 int additionalDamage = CombatUtil.dealsDamageAsBlocker(attacker, blocker);
                 if (damageNeeded > currentDamage
                         && !(damageNeeded > currentDamage + additionalDamage)
-                        && CardFactoryUtil.evaluateCreature(blocker) + getDiff() < CardFactoryUtil.evaluateCreature(attacker)
+                        && CardFactoryUtil.evaluateCreature(blocker) + getDiff() < CardFactoryUtil
-                        && CombatUtil.canBlock(attacker, blocker, combat)) {
+                                .evaluateCreature(attacker) && CombatUtil.canBlock(attacker, blocker, combat))
+                {
                     combat.addBlocker(attacker, blocker);
                     getBlockersLeft().removeAll(blocker);
                 }
@@ -518,50 +649,83 @@ public class ComputerUtil_Block2 {
     }
 
     /**
-     * <p>resetBlockers.</p>
+     * <p>
+     * resetBlockers.
+     * </p>
      * 
-     * @param combat a {@link forge.Combat} object.
+     * @param combat
-     * @param possibleBlockers a {@link forge.CardList} object.
+     *            a {@link forge.Combat} object.
+     * @param possibleBlockers
+     *            a {@link forge.CardList} object.
      * @return a {@link forge.Combat} object.
      */
-    private static Combat resetBlockers(Combat combat, CardList possibleBlockers) {
+    private static Combat resetBlockers(final Combat combat, final CardList possibleBlockers) {
 
         CardList oldBlockers = combat.getAllBlockers();
         for (Card blocker : oldBlockers) {
             combat.removeFromCombat(blocker);
         }
 
-        setAttackersLeft(new CardList(getAttackers().toArray())); //keeps track of all currently unblocked attackers
+        setAttackersLeft(new CardList(getAttackers().toArray())); // keeps track
-        setBlockersLeft(new CardList(possibleBlockers.toArray())); //keeps track of all unassigned blockers
+                                                                  // of all
-        setBlockedButUnkilled(new CardList()); //keeps track of all blocked attackers that currently wouldn't be destroyed
+                                                                  // currently
+                                                                  // unblocked
+                                                                  // attackers
+        setBlockersLeft(new CardList(possibleBlockers.toArray())); // keeps
+                                                                   // track of
+                                                                   // all
+                                                                   // unassigned
+                                                                   // blockers
+        setBlockedButUnkilled(new CardList()); // keeps track of all blocked
+                                               // attackers that currently
+                                               // wouldn't be destroyed
 
         return combat;
     }
 
-    //Main function
+    // Main function
     /**
-     * <p>getBlockers.</p>
+     * <p>
+     * getBlockers.
+     * </p>
      * 
-     * @param originalCombat a {@link forge.Combat} object.
+     * @param originalCombat
-     * @param possibleBlockers a {@link forge.CardList} object.
+     *            a {@link forge.Combat} object.
+     * @param possibleBlockers
+     *            a {@link forge.CardList} object.
      * @return a {@link forge.Combat} object.
      */
-    static public Combat getBlockers(Combat originalCombat, CardList possibleBlockers) {
+    public static Combat getBlockers(final Combat originalCombat, final CardList possibleBlockers) {
 
         Combat combat = originalCombat;
 
         setAttackers(sortPotentialAttackers(combat));
 
-        if (getAttackers().size() == 0)
+        if (getAttackers().size() == 0) {
             return combat;
+        }
 
-        setAttackersLeft(new CardList(getAttackers().toArray())); //keeps track of all currently unblocked attackers
+        setAttackersLeft(new CardList(getAttackers().toArray())); // keeps track
-        setBlockersLeft(new CardList(possibleBlockers.toArray())); //keeps track of all unassigned blockers
+                                                                  // of all
-        setBlockedButUnkilled(new CardList()); //keeps track of all blocked attackers that currently wouldn't be destroyed
+                                                                  // currently
+                                                                  // unblocked
+                                                                  // attackers
+        setBlockersLeft(new CardList(possibleBlockers.toArray())); // keeps
+                                                                   // track of
+                                                                   // all
+                                                                   // unassigned
+                                                                   // blockers
+        setBlockedButUnkilled(new CardList()); // keeps track of all blocked
+                                               // attackers that currently
+                                               // wouldn't be destroyed
         CardList blockers;
         CardList chumpBlockers;
 
-        setDiff(AllZone.getComputerPlayer().getLife() * 2 - 5); //This is the minimal gain for an unnecessary trade
+        setDiff(AllZone.getComputerPlayer().getLife() * 2 - 5); // This is the
+                                                                // minimal gain
+                                                                // for an
+                                                                // unnecessary
+                                                                // trade
 
         // remove all attackers that can't be blocked anyway
         for (Card a : getAttackers()) {
@@ -572,52 +736,85 @@ public class ComputerUtil_Block2 {
 
         // remove all blockers that can't block anyway
         for (Card b : possibleBlockers) {
-            if (!CombatUtil.canBlock(b, combat)) getBlockersLeft().remove(b);
+            if (!CombatUtil.canBlock(b, combat)) {
+                getBlockersLeft().remove(b);
+            }
         }
 
-        if (getAttackersLeft().size() == 0)
+        if (getAttackersLeft().size() == 0) {
             return combat;
+        }
 
-        //Begin with the weakest blockers
+        // Begin with the weakest blockers
         CardListUtil.sortAttackLowFirst(getBlockersLeft());
 
-        //== 1. choose best blocks first ==
+        // == 1. choose best blocks first ==
         combat = makeGoodBlocks(combat);
         combat = makeGangBlocks(combat);
-        if (CombatUtil.lifeInDanger(combat))
-            combat = makeTradeBlocks(combat); //choose necessary trade blocks if life is in danger
-        if (CombatUtil.lifeInDanger(combat))
-            combat = makeChumpBlocks(combat); //choose necessary chump blocks if life is still in danger
-        //Reinforce blockers blocking attackers with trample if life is still in danger
-        if (CombatUtil.lifeInDanger(combat)) combat = reinforceBlockersAgainstTrample(combat);
-        //Support blockers not destroying the attacker with more blockers to try to kill the attacker
-        if (!CombatUtil.lifeInDanger(combat)) combat = reinforceBlockersToKill(combat);
-
-
-        //== 2. If the AI life would still be in danger make a safer approach ==
         if (CombatUtil.lifeInDanger(combat)) {
-            combat = resetBlockers(combat, possibleBlockers); // reset every block assignment
+            combat = makeTradeBlocks(combat); // choose necessary trade blocks
-            combat = makeTradeBlocks(combat); //choose necessary trade blocks if life is in danger
+        }
+                                              // if life is in danger
+        if (CombatUtil.lifeInDanger(combat)) {
+            combat = makeChumpBlocks(combat); // choose necessary chump blocks
+        }
+                                              // if life is still in danger
+        // Reinforce blockers blocking attackers with trample if life is still
+        // in danger
+        if (CombatUtil.lifeInDanger(combat)) {
+            combat = reinforceBlockersAgainstTrample(combat);
+        }
+        // Support blockers not destroying the attacker with more blockers to
+        // try to kill the attacker
+        if (!CombatUtil.lifeInDanger(combat)) {
+            combat = reinforceBlockersToKill(combat);
+        }
+
+        // == 2. If the AI life would still be in danger make a safer approach
+        // ==
+        if (CombatUtil.lifeInDanger(combat)) {
+            combat = resetBlockers(combat, possibleBlockers); // reset every
+                                                              // block
+                                                              // assignment
+            combat = makeTradeBlocks(combat); // choose necessary trade blocks
+                                              // if life is in danger
             combat = makeGoodBlocks(combat);
-            if (CombatUtil.lifeInDanger(combat))
+            if (CombatUtil.lifeInDanger(combat)) {
-                combat = makeChumpBlocks(combat); //choose necessary chump blocks if life is still in danger
+                combat = makeChumpBlocks(combat); // choose necessary chump
-            //Reinforce blockers blocking attackers with trample if life is still in danger
+            }
-            if (CombatUtil.lifeInDanger(combat)) combat = reinforceBlockersAgainstTrample(combat);
+                                                  // blocks if life is still in
+                                                  // danger
+            // Reinforce blockers blocking attackers with trample if life is
+            // still in danger
+            if (CombatUtil.lifeInDanger(combat)) {
+                combat = reinforceBlockersAgainstTrample(combat);
+            }
             combat = makeGangBlocks(combat);
             combat = reinforceBlockersToKill(combat);
         }
 
-        //== 3. If the AI life would be in serious danger make an even safer approach ==
+        // == 3. If the AI life would be in serious danger make an even safer
+        // approach ==
         if (CombatUtil.lifeInSeriousDanger(combat)) {
-            combat = resetBlockers(combat, possibleBlockers); // reset every block assignment
+            combat = resetBlockers(combat, possibleBlockers); // reset every
-            combat = makeChumpBlocks(combat); //choose chump blocks
+                                                              // block
-            if (CombatUtil.lifeInDanger(combat))
+                                                              // assignment
-                combat = makeTradeBlocks(combat); //choose necessary trade blocks if life is in danger
+            combat = makeChumpBlocks(combat); // choose chump blocks
-            if (!CombatUtil.lifeInDanger(combat)) combat = makeGoodBlocks(combat);
+            if (CombatUtil.lifeInDanger(combat)) {
-            //Reinforce blockers blocking attackers with trample if life is still in danger
+                combat = makeTradeBlocks(combat); // choose necessary trade
-            if (CombatUtil.lifeInDanger(combat)) combat = reinforceBlockersAgainstTrample(combat);
+            }
+                                                  // blocks if life is in danger
+            if (!CombatUtil.lifeInDanger(combat)) {
+                combat = makeGoodBlocks(combat);
+            }
+            // Reinforce blockers blocking attackers with trample if life is
+            // still in danger
+            if (CombatUtil.lifeInDanger(combat)) {
+                combat = reinforceBlockersAgainstTrample(combat);
+            }
             combat = makeGangBlocks(combat);
-            //Support blockers not destroying the attacker with more blockers to try to kill the attacker
+            // Support blockers not destroying the attacker with more blockers
+            // to try to kill the attacker
             combat = reinforceBlockersToKill(combat);
         }
 
@@ -625,7 +822,9 @@ public class ComputerUtil_Block2 {
         chumpBlockers = getBlockersLeft().getKeyword("CARDNAME blocks each turn if able.");
         // if an attacker with lure attacks - all that can block
         for (Card blocker : getBlockersLeft()) {
-            if (CombatUtil.mustBlockAnAttacker(blocker, combat)) chumpBlockers.add(blocker);
+            if (CombatUtil.mustBlockAnAttacker(blocker, combat)) {
+                chumpBlockers.add(blocker);
+            }
         }
         if (!chumpBlockers.isEmpty()) {
             getAttackers().shuffle();

src/main/java/forge/Constant.java

@@ -1,163 +1,333 @@
 package forge;
 
-
 import java.util.ArrayList;
 import java.util.List;
 
 import forge.deck.Deck;
 import forge.game.GameType;
 
-
 /**
- * <p>Constant interface.</p>
+ * <p>
+ * Constant interface.
+ * </p>
  * 
  * @author Forge
  * @version $Id$
  */
 public interface Constant {
     /** Constant <code>ProgramName="Forge - http://cardforge.org"</code> */
-    public static final String ProgramName = "Forge - http://cardforge.org";
+    String ProgramName = "Forge - http://cardforge.org";
 
-    //used to pass information between the GUI screens
+    // used to pass information between the GUI screens
+    /**
+     * The Class Runtime.
+     */
     public abstract class Runtime {
+
+        /** The Constant HumanDeck. */
         public static final Deck[] HumanDeck = new Deck[1];
+
+        /** The Constant ComputerDeck. */
         public static final Deck[] ComputerDeck = new Deck[1];
+
+        /** The game type. */
         public static GameType gameType = GameType.Constructed;
 
+        /** The Constant Smooth. */
         public static final boolean[] Smooth = new boolean[1];
-        public static final boolean[] Mill = new boolean[1];
-        public static final boolean[] DevMode = new boolean[1];    // one for normal mode one for quest mode
 
+        /** The Constant Mill. */
+        public static final boolean[] Mill = new boolean[1];
+
+        /** The Constant DevMode. */
+        public static final boolean[] DevMode = new boolean[1]; // one for
+                                                                // normal mode
+                                                                // one for quest
+                                                                // mode
+
+        /** The Constant NetConn. */
         public static final boolean[] NetConn = new boolean[1];
+
+        /** The Constant UpldDrft. */
         public static final boolean[] UpldDrft = new boolean[1];
 
+        /** The Constant RndCFoil. */
         public static final boolean[] RndCFoil = new boolean[1];
 
-        public static final int[] width = {300};
+        /** The Constant width. */
+        public static final int[] width = { 300 };
+
+        /** The Constant height. */
         public static final int[] height = new int[1];
 
+        /** The Constant stackSize. */
         public static final int[] stackSize = new int[1];
+
+        /** The Constant stackOffset. */
         public static final int[] stackOffset = new int[1];
     }
 
-    //public interface IO {
+    // public interface IO {
-        // probably should read this from a file, or set from GUI
+    // probably should read this from a file, or set from GUI
 
-        //public static final String deckFile = "all-decks2";
+    // public static final String deckFile = "all-decks2";
-        //public static final String boosterDeckFile = "booster-decks";
+    // public static final String boosterDeckFile = "booster-decks";
 
-        //public static final String imageBaseDir = "pics";
+    // public static final String imageBaseDir = "pics";
 
-        //public static final ImageIcon upIcon = new ImageIcon("up.gif");
+    // public static final ImageIcon upIcon = new ImageIcon("up.gif");
-        //public static final ImageIcon downIcon = new ImageIcon("down.gif");
+    // public static final ImageIcon downIcon = new ImageIcon("down.gif");
-        //public static final ImageIcon leftIcon = new ImageIcon("left.gif");
+    // public static final ImageIcon leftIcon = new ImageIcon("left.gif");
-        //public static final ImageIcon rightIcon = new ImageIcon("right.gif");
+    // public static final ImageIcon rightIcon = new ImageIcon("right.gif");
-    //}
+    // }
 
+    /**
+     * The Interface Ability.
+     */
     public interface Ability {
+
+        /** The Triggered. */
         String Triggered = "Triggered";
+
+        /** The Activated. */
         String Activated = "Activated";
     }
 
+    /**
+     * The Interface Phase.
+     */
     public interface Phase {
-        public static final String Untap = "Untap";
-        public static final String Upkeep = "Upkeep";
-        public static final String Draw = "Draw";
 
-        public static final String Main1 = "Main1";
+        /** The Constant Untap. */
+        String Untap = "Untap";
 
-        public static final String Combat_Begin = "BeginCombat";
+        /** The Constant Upkeep. */
-        public static final String Combat_Declare_Attackers = "Declare Attackers";
+        String Upkeep = "Upkeep";
-        public static final String Combat_Declare_Attackers_InstantAbility = "Declare Attackers - Play Instants and Abilities";
-        public static final String Combat_Declare_Blockers = "Declare Blockers";
-        public static final String Combat_Declare_Blockers_InstantAbility = "Declare Blockers - Play Instants and Abilities";
-        public static final String Combat_Damage = "Combat Damage";
-        public static final String Combat_FirstStrikeDamage = "First Strike Damage";
-        public static final String Combat_End = "EndCombat";
 
-        public static final String Main2 = "Main2";
+        /** The Constant Draw. */
+        String Draw = "Draw";
 
-        public static final String End_Of_Turn = "End of Turn";
+        /** The Constant Main1. */
-        public static final String Cleanup = "Cleanup";
+        String Main1 = "Main1";
+
+        /** The Constant Combat_Begin. */
+        String Combat_Begin = "BeginCombat";
+
+        /** The Constant Combat_Declare_Attackers. */
+        String Combat_Declare_Attackers = "Declare Attackers";
+
+        /** The Constant Combat_Declare_Attackers_InstantAbility. */
+        String Combat_Declare_Attackers_InstantAbility = "Declare Attackers - Play Instants and Abilities";
+
+        /** The Constant Combat_Declare_Blockers. */
+        String Combat_Declare_Blockers = "Declare Blockers";
+
+        /** The Constant Combat_Declare_Blockers_InstantAbility. */
+        String Combat_Declare_Blockers_InstantAbility = "Declare Blockers - Play Instants and Abilities";
+
+        /** The Constant Combat_Damage. */
+        String Combat_Damage = "Combat Damage";
+
+        /** The Constant Combat_FirstStrikeDamage. */
+        String Combat_FirstStrikeDamage = "First Strike Damage";
+
+        /** The Constant Combat_End. */
+        String Combat_End = "EndCombat";
+
+        /** The Constant Main2. */
+        String Main2 = "Main2";
+
+        /** The Constant End_Of_Turn. */
+        String End_Of_Turn = "End of Turn";
+
+        /** The Constant Cleanup. */
+        String Cleanup = "Cleanup";
     }
 
+    /**
+     * The Enum Zone.
+     */
     public enum Zone {
+
+        /** The Hand. */
         Hand,
+
+        /** The Library. */
         Library,
+
+        /** The Graveyard. */
         Graveyard,
+
+        /** The Battlefield. */
         Battlefield,
+
+        /** The Exile. */
         Exile,
+
+        /** The Command. */
         Command,
+
+        /** The Stack. */
         Stack;
 
+        /**
+         * Smart value of.
+         * 
+         * @param value
+         *            the value
+         * @return the zone
+         */
         public static Zone smartValueOf(final String value) {
-            if (value == null)  { return null; }
+            if (value == null) {
-            if ("All".equals(value)) { return null; }
+                return null;
+            }
+            if ("All".equals(value)) {
+                return null;
+            }
             String valToCompate = value.trim();
-            for (Zone v : Zone.values()) { if (v.name().compareToIgnoreCase(valToCompate) == 0) { return v; } }
+            for (Zone v : Zone.values()) {
+                if (v.name().compareToIgnoreCase(valToCompate) == 0) {
+                    return v;
+                }
+            }
             throw new IllegalArgumentException("No element named " + value + " in enum Zone");
         }
 
+        /**
+         * List value of.
+         * 
+         * @param values
+         *            the values
+         * @return the list
+         */
         public static List<Zone> listValueOf(final String values) {
             List<Zone> result = new ArrayList<Constant.Zone>();
-            for (String s : values.split("[, ]+")) { result.add(smartValueOf(s)); }
+            for (String s : values.split("[, ]+")) {
+                result.add(smartValueOf(s));
+            }
             return result;
         }
     }
 
+    /**
+     * The Interface Color.
+     */
     public interface Color {
+
+        /** The Black. */
         String Black = "black";
+
+        /** The Blue. */
         String Blue = "blue";
+
+        /** The Green. */
         String Green = "green";
+
+        /** The Red. */
         String Red = "red";
+
+        /** The White. */
         String White = "white";
 
+        /** The Colorless. */
         String Colorless = "colorless";
-        //color order "wubrg"
+        // color order "wubrg"
-        String[] Colors = {White, Blue, Black, Red, Green, Colorless};
+        /** The Colors. */
-        String[] onlyColors = {White, Blue, Black, Red, Green};
+        String[] Colors = { White, Blue, Black, Red, Green, Colorless };
 
+        /** The only colors. */
+        String[] onlyColors = { White, Blue, Black, Red, Green };
+
+        /** The Snow. */
         String Snow = "snow";
-        String[] ManaColors = {White, Blue, Black, Red, Green, Colorless, Snow};
 
-        boolean[] loaded = {false};
+        /** The Mana colors. */
-        //public static final Constant_StringHashMap[] LandColor = new Constant_StringHashMap[1];
+        String[] ManaColors = { White, Blue, Black, Red, Green, Colorless, Snow };
 
-        String[] BasicLands = {"Plains", "Island", "Swamp", "Mountain", "Forest"};
+        /** The loaded. */
+        boolean[] loaded = { false };
+        // public static final Constant_StringHashMap[] LandColor = new
+        // Constant_StringHashMap[1];
+
+        /** The Basic lands. */
+        String[] BasicLands = { "Plains", "Island", "Swamp", "Mountain", "Forest" };
     }
 
+    /**
+     * The Interface Quest.
+     */
     public interface Quest {
+
+        /** The fantasy quest. */
         boolean[] fantasyQuest = new boolean[1];
 
-        //public static final Quest_Assignment[] qa = new Quest_Assignment[1];
+        // public static final Quest_Assignment[] qa = new Quest_Assignment[1];
 
+        /** The human list. */
         CardList[] humanList = new CardList[1];
+
+        /** The computer list. */
         CardList[] computerList = new CardList[1];
 
+        /** The human life. */
         int[] humanLife = new int[1];
+
+        /** The computer life. */
         int[] computerLife = new int[1];
 
+        /** The opp icon name. */
         String[] oppIconName = new String[1];
     }
 
+    /**
+     * The Interface CardTypes.
+     */
     public interface CardTypes {
-        boolean[] loaded = {false}; 
+
+        /** The loaded. */
+        boolean[] loaded = { false };
+
+        /** The card types. */
         Constant_StringArrayList[] cardTypes = new Constant_StringArrayList[1];
+
+        /** The super types. */
         Constant_StringArrayList[] superTypes = new Constant_StringArrayList[1];
+
+        /** The basic types. */
         Constant_StringArrayList[] basicTypes = new Constant_StringArrayList[1];
+
+        /** The land types. */
         Constant_StringArrayList[] landTypes = new Constant_StringArrayList[1];
+
+        /** The creature types. */
         Constant_StringArrayList[] creatureTypes = new Constant_StringArrayList[1];
+
+        /** The instant types. */
         Constant_StringArrayList[] instantTypes = new Constant_StringArrayList[1];
+
+        /** The sorcery types. */
         Constant_StringArrayList[] sorceryTypes = new Constant_StringArrayList[1];
+
+        /** The enchantment types. */
         Constant_StringArrayList[] enchantmentTypes = new Constant_StringArrayList[1];
+
+        /** The artifact types. */
         Constant_StringArrayList[] artifactTypes = new Constant_StringArrayList[1];
+
+        /** The walker types. */
         Constant_StringArrayList[] walkerTypes = new Constant_StringArrayList[1];
     }
 
+    /**
+     * The Interface Keywords.
+     */
     public interface Keywords {
-        boolean[] loaded = {false};
+
+        /** The loaded. */
+        boolean[] loaded = { false };
+
+        /** The Non stacking list. */
         Constant_StringArrayList[] NonStackingList = new Constant_StringArrayList[1];
     }
 
-
+} // Constant
-} //Constant

src/main/java/forge/Constant_StringArrayList.java

@@ -2,7 +2,12 @@ package forge;
 
 import java.util.ArrayList;
 
+/**
+ * The Class Constant_StringArrayList.
+ */
 public class Constant_StringArrayList {
-	public ArrayList<String> list = new ArrayList<String>();
+
+    /** The list. */
+    public ArrayList<String> list = new ArrayList<String>();
 
 }

src/main/java/forge/Constant_StringHashMap.java

@@ -3,7 +3,12 @@ package forge;
 import java.util.HashMap;
 import java.util.Map;
 
+/**
+ * The Class Constant_StringHashMap.
+ */
 public class Constant_StringHashMap {
-	public Map<String,String> map = new HashMap<String,String>();
+
+    /** The map. */
+    public Map<String, String> map = new HashMap<String, String>();
 
 }

src/main/java/forge/CopyFiles.java

@@ -1,18 +1,24 @@
 package forge;
 
-
-import forge.properties.ForgeProps;
-import forge.properties.NewConstants;
-import javax.swing.*;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.List;
 
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JLabel;
+import javax.swing.JProgressBar;
+import javax.swing.SwingWorker;
+
+import forge.properties.ForgeProps;
+import forge.properties.NewConstants;
 
 /**
- * <p>CopyFiles class.</p>
+ * <p>
+ * CopyFiles class.
+ * </p>
  * 
  * @author Forge
  * @version $Id$
@@ -20,22 +26,40 @@ import java.util.List;
 public class CopyFiles extends SwingWorker<Void, Integer> implements NewConstants {
 
     private List<File> FileList;
+
+    /** The j lb. */
     JLabel jLb;
+
+    /** The j b. */
     JProgressBar jB;
+
+    /** The j check. */
     JCheckBox jCheck;
+
+    /** The j source. */
     JButton jSource;
+
+    /** The count. */
     int count;
 
     /**
-     * <p>Constructor for CopyFiles.</p>
+     * <p>
+     * Constructor for CopyFiles.
+     * </p>
      * 
-     * @param FileList a {@link java.util.List} object.
+     * @param FileList
-     * @param jLabelTotalFiles a {@link javax.swing.JLabel} object.
+     *            a {@link java.util.List} object.
-     * @param Jbar a {@link javax.swing.JProgressBar} object.
+     * @param jLabelTotalFiles
-     * @param jCheckBox a {@link javax.swing.JCheckBox} object.
+     *            a {@link javax.swing.JLabel} object.
-     * @param jButtonSource a {@link javax.swing.JButton} object.
+     * @param Jbar
+     *            a {@link javax.swing.JProgressBar} object.
+     * @param jCheckBox
+     *            a {@link javax.swing.JCheckBox} object.
+     * @param jButtonSource
+     *            a {@link javax.swing.JButton} object.
      */
-    public CopyFiles(List<File> FileList, JLabel jLabelTotalFiles, JProgressBar Jbar, JCheckBox jCheckBox, JButton jButtonSource) {
+    public CopyFiles(final List<File> FileList, JLabel jLabelTotalFiles, JProgressBar Jbar, JCheckBox jCheckBox,
+            JButton jButtonSource) {
         this.FileList = FileList;
         jLb = jLabelTotalFiles;
         jB = Jbar;
@@ -45,7 +69,7 @@ public class CopyFiles extends SwingWorker<Void, Integer> implements NewConstant
 
     /** {@inheritDoc} */
     @Override
-    protected Void doInBackground() {
+    protected final Void doInBackground() {
         for (int i = 0; i < this.FileList.size(); i++) {
             publish();
             String cName, name, source;
@@ -66,7 +90,9 @@ public class CopyFiles extends SwingWorker<Void, Integer> implements NewConstant
                 int length;
                 while (fis.available() > 0) {
                     length = fis.read(buff);
-                    if (length > 0) fos.write(buff, 0, length);
+                    if (length > 0) {
+                        fos.write(buff, 0, length);
+                    }
                 }
                 fos.flush();
                 fis.close();
@@ -85,7 +111,7 @@ public class CopyFiles extends SwingWorker<Void, Integer> implements NewConstant
 
     /** {@inheritDoc} */
     @Override
-    protected void done() {
+    protected final void done() {
         jLb.setText("All files were copied successfully.");
         jB.setIndeterminate(false);
         jCheck.setEnabled(true);

src/main/java/forge/Counters.java

@@ -6,7 +6,6 @@
 
 package forge;
 
-
 /**
  * The class Counters.
  * 
@@ -14,120 +13,313 @@ package forge;
  * @version V0.0 17.02.2010
  */
 public enum Counters {
+
+    /** The AGE. */
     AGE(),
+
+    /** The ARROW. */
     ARROW(),
+
+    /** The ARROWHEAD. */
     ARROWHEAD(),
+
+    /** The AWAKENING. */
     AWAKENING(),
+
+    /** The BLAZE. */
     BLAZE(),
+
+    /** The BLOOD. */
     BLOOD(),
+
+    /** The BOUNTY. */
     BOUNTY(),
+
+    /** The BRIBERY. */
     BRIBERY(),
+
+    /** The CARRION. */
     CARRION(),
+
+    /** The CHARGE. */
     CHARGE(),
+
+    /** The CORPSE. */
     CORPSE(),
+
+    /** The CREDIT. */
     CREDIT(),
+
+    /** The CURRENCY. */
     CURRENCY(),
+
+    /** The DEATH. */
     DEATH(),
+
+    /** The DELAY. */
     DELAY(),
+
+    /** The DEPLETION. */
     DEPLETION(),
+
+    /** The DEVOTION. */
     DEVOTION(),
+
+    /** The DIVINITY. */
     DIVINITY(),
+
+    /** The DOOM. */
     DOOM(),
+
+    /** The ENERGY. */
     ENERGY(),
+
+    /** The EON. */
     EON(),
+
+    /** The FADE. */
     FADE(),
+
+    /** The FATE. */
     FATE(),
+
+    /** The FEATHER. */
     FEATHER(),
+
+    /** The FLOOD. */
     FLOOD(),
+
+    /** The FUNGUS. */
     FUNGUS(),
+
+    /** The FUSE. */
     FUSE(),
+
+    /** The GLYPH. */
     GLYPH(),
+
+    /** The GOLD. */
     GOLD(),
+
+    /** The GROWTH. */
     GROWTH(),
+
+    /** The HATCHLING. */
     HATCHLING(),
+
+    /** The HEALING. */
     HEALING(),
+
+    /** The HOOFPRINT. */
     HOOFPRINT(),
+
+    /** The HOURGLASS. */
     HOURGLASS(),
+
+    /** The ICE. */
     ICE(),
+
+    /** The INFECTION. */
     INFECTION(),
+
+    /** The INTERVENTION. */
     INTERVENTION(),
+
+    /** The JAVELIN. */
     JAVELIN(),
+
+    /** The KI. */
     KI(),
+
+    /** The LEVEL. */
     LEVEL("Level"),
+
+    /** The LORE. */
     LORE(),
+
+    /** The LOYALTY. */
     LOYALTY(),
+
+    /** The LUCK. */
     LUCK(),
+
+    /** The M0 m1. */
     M0M1("-0/-1"),
+
+    /** The M0 m2. */
     M0M2("-0/-2"),
+
+    /** The M1 m0. */
     M1M0("-1/-0"),
+
+    /** The M1 m1. */
     M1M1("-1/-1"),
+
+    /** The M2 m1. */
     M2M1("-2/-1"),
+
+    /** The M2 m2. */
     M2M2("-2/-2"),
+
+    /** The MANA. */
     MANA(),
+
+    /** The MINE. */
     MINE(),
+
+    /** The MINING. */
     MINING(),
+
+    /** The MIRE. */
     MIRE(),
+
+    /** The OMEN. */
     OMEN(),
+
+    /** The ORE. */
     ORE(),
+
+    /** The PAGE. */
     PAGE(),
+
+    /** The PAIN. */
     PAIN(),
+
+    /** The PARALYZATION. */
     PARALYZATION(),
+
+    /** The PETAL. */
     PETAL(),
+
+    /** The PIN. */
     PIN(),
+
+    /** The PLAGUE. */
     PLAGUE(),
+
+    /** The PRESSURE. */
     PRESSURE(),
+
+    /** The PHYLACTERY. */
     PHYLACTERY,
+
+    /** The POLYP. */
     POLYP(),
+
+    /** The PUPA. */
     PUPA(),
+
+    /** The P0 p1. */
     P0P1("+0/+1"),
+
+    /** The P1 p0. */
     P1P0("+1/+0"),
+
+    /** The P1 p1. */
     P1P1("+1/+1"),
+
+    /** The P1 p2. */
     P1P2("+1/+2"),
+
+    /** The P2 p2. */
     P2P2("+2/+2"),
+
+    /** The QUEST. */
     QUEST(),
+
+    /** The SCREAM. */
     SCREAM(),
+
+    /** The SHELL. */
     SHELL(),
+
+    /** The SHIELD. */
     SHIELD(),
+
+    /** The SHRED. */
     SHRED(),
+
+    /** The SLEEP. */
     SLEEP(),
+
+    /** The SLEIGHT. */
     SLEIGHT(),
+
+    /** The SOOT. */
     SOOT(),
+
+    /** The SPORE. */
     SPORE(),
+
+    /** The STORAGE. */
     STORAGE(),
+
+    /** The STUDY. */
     STUDY(),
+
+    /** The TIDE. */
     TIDE(),
+
+    /** The TIME. */
     TIME(),
+
+    /** The TOWER. */
     TOWER("tower"),
+
+    /** The TRAINING. */
     TRAINING(),
+
+    /** The TRAP. */
     TRAP(),
+
+    /** The TREASURE. */
     TREASURE(),
+
+    /** The VELOCITY. */
     VELOCITY(),
+
+    /** The VERSE. */
     VERSE(),
+
+    /** The VITALITY. */
     VITALITY(),
+
+    /** The WAGE. */
     WAGE(),
+
+    /** The WIND. */
     WIND(),
+
+    /** The WISH. */
     WISH();
 
     private String name;
 
     /**
-     * <p>Constructor for Counters.</p>
+     * <p>
+     * Constructor for Counters.
+     * </p>
      */
     private Counters() {
         this.name = name().substring(0, 1).toUpperCase() + name().substring(1).toLowerCase();
     }
 
     /**
-     * <p>Constructor for Counters.</p>
+     * <p>
+     * Constructor for Counters.
+     * </p>
      * 
-     * @param name a {@link java.lang.String} object.
+     * @param name
+     *            a {@link java.lang.String} object.
      */
     private Counters(final String nameIn) {
         this.name = nameIn;
     }
 
     /**
-     * <p>Getter for the field <code>name</code>.</p>
+     * <p>
+     * Getter for the field <code>name</code>.
+     * </p>
      * 
      * @return a {@link java.lang.String} object.
      */
@@ -136,9 +328,12 @@ public enum Counters {
     }
 
     /**
-     * <p>getType.</p>
+     * <p>
+     * getType.
+     * </p>
      * 
-     * @param name a {@link java.lang.String} object.
+     * @param name
+     *            a {@link java.lang.String} object.
      * @return a {@link forge.Counters} object.
      */
     public static Counters getType(final String name) {

src/main/java/forge/EndOfTurn.java

@@ -6,7 +6,9 @@ import forge.card.spellability.SpellAbility;
 
 //handles "until end of turn" and "at end of turn" commands from cards
 /**
- * <p>EndOfTurn class.</p>
+ * <p>
+ * EndOfTurn class.
+ * </p>
  * 
  * @author Forge
  * @version $Id$
@@ -20,44 +22,55 @@ public class EndOfTurn implements java.io.Serializable {
     private CommandList last = new CommandList();
 
     /**
-     * <p>addAt.</p>
+     * <p>
+     * addAt.
+     * </p>
      * 
-     * @param c a {@link forge.Command} object.
+     * @param c
+     *            a {@link forge.Command} object.
      */
     public final void addAt(final Command c) {
         at.add(c);
     }
 
     /**
-     * <p>addUntil.</p>
+     * <p>
+     * addUntil.
+     * </p>
      * 
-     * @param c a {@link forge.Command} object.
+     * @param c
+     *            a {@link forge.Command} object.
      */
     public final void addUntil(final Command c) {
         until.add(c);
     }
 
     /**
-     * <p>addLast.</p>
+     * <p>
+     * addLast.
+     * </p>
      * 
-     * @param c a {@link forge.Command} object.
+     * @param c
+     *            a {@link forge.Command} object.
      */
     public final void addLast(final Command c) {
         last.add(c);
     }
 
     /**
-     * <p>executeAt.</p>
+     * <p>
+     * executeAt.
+     * </p>
      */
     public final void executeAt() {
 
-        //Pyrohemia and Pestilence
+        // Pyrohemia and Pestilence
         CardList all = AllZoneUtil.getCardsIn(Zone.Battlefield);
 
         GameActionUtil.endOfTurn_Wall_Of_Reverence();
         GameActionUtil.endOfTurn_Lighthouse_Chronologist();
 
-        //reset mustAttackEntity for me
+        // reset mustAttackEntity for me
         AllZone.getPhase().getPlayerTurn().setMustAttackEntity(null);
 
         GameActionUtil.removeAttackedBlockedThisTurn();
@@ -65,9 +78,7 @@ public class EndOfTurn implements java.io.Serializable {
         AllZone.getStaticEffects().rePopulateStateBasedList();
 
         for (Card c : all) {
-            if (!c.isFaceDown()
+            if (!c.isFaceDown() && c.hasKeyword("At the beginning of the end step, sacrifice CARDNAME.")) {
-                    && c.hasKeyword("At the beginning of the end step, sacrifice CARDNAME."))
-            {
                 final Card card = c;
                 final SpellAbility sac = new Ability(card, "0") {
                     @Override
@@ -84,9 +95,7 @@ public class EndOfTurn implements java.io.Serializable {
                 AllZone.getStack().addSimultaneousStackEntry(sac);
 
             }
-            if (!c.isFaceDown()
+            if (!c.isFaceDown() && c.hasKeyword("At the beginning of the end step, exile CARDNAME.")) {
-                    && c.hasKeyword("At the beginning of the end step, exile CARDNAME."))
-            {
                 final Card card = c;
                 final SpellAbility exile = new Ability(card, "0") {
                     @Override
@@ -103,9 +112,7 @@ public class EndOfTurn implements java.io.Serializable {
                 AllZone.getStack().addSimultaneousStackEntry(exile);
 
             }
-            if (!c.isFaceDown()
+            if (!c.isFaceDown() && c.hasKeyword("At the beginning of the end step, destroy CARDNAME.")) {
-                    && c.hasKeyword("At the beginning of the end step, destroy CARDNAME."))
-            {
                 final Card card = c;
                 final SpellAbility destroy = new Ability(card, "0") {
                     @Override
@@ -122,7 +129,7 @@ public class EndOfTurn implements java.io.Serializable {
                 AllZone.getStack().addSimultaneousStackEntry(destroy);
 
             }
-            //Berserk is using this, so don't check isFaceDown()
+            // Berserk is using this, so don't check isFaceDown()
             if (c.hasKeyword("At the beginning of the next end step, destroy CARDNAME if it attacked this turn.")) {
                 if (c.getCreatureAttackedThisTurn()) {
                     final Card card = c;
@@ -151,8 +158,9 @@ public class EndOfTurn implements java.io.Serializable {
                     public void resolve() {
                         if (AllZoneUtil.isCardInPlay(vale)) {
                             vale.addController(vale.getController().getOpponent());
-                            //AllZone.getGameAction().changeController(
+                            // AllZone.getGameAction().changeController(
-                            //      new CardList(vale), vale.getController(), vale.getController().getOpponent());
+                            // new CardList(vale), vale.getController(),
+                            // vale.getController().getOpponent());
 
                             vale.removeExtrinsicKeyword("An opponent gains control of CARDNAME at the beginning of the next end step.");
                         }
@@ -165,9 +173,8 @@ public class EndOfTurn implements java.io.Serializable {
                 AllZone.getStack().addSimultaneousStackEntry(change);
 
             }
-            if (c.getName().equals("Erg Raiders") && !c.getCreatureAttackedThisTurn()
+            if (c.getName().equals("Erg Raiders") && !c.getCreatureAttackedThisTurn() && !c.hasSickness()
-                    && !c.hasSickness() && AllZone.getPhase().isPlayerTurn(c.getController()))
+                    && AllZone.getPhase().isPlayerTurn(c.getController())) {
-            {
                 final Card raider = c;
                 final SpellAbility change = new Ability(raider, "0") {
                     @Override
@@ -186,9 +193,8 @@ public class EndOfTurn implements java.io.Serializable {
             }
             if (c.hasKeyword("At the beginning of your end step, sacrifice this creature unless it attacked this turn.")
                     && !c.getCreatureAttackedThisTurn()
-                    /* && !(c.getTurnInZone() == AllZone.getPhase().getTurn())*/
+                    /* && !(c.getTurnInZone() == AllZone.getPhase().getTurn()) */
-                    && AllZone.getPhase().isPlayerTurn(c.getController()))
+                    && AllZone.getPhase().isPlayerTurn(c.getController())) {
-            {
                 final Card source = c;
                 final SpellAbility change = new Ability(source, "0") {
                     @Override
@@ -206,9 +212,7 @@ public class EndOfTurn implements java.io.Serializable {
 
             }
             if (c.hasKeyword("At the beginning of your end step, destroy this creature if it didn't attack this turn.")
-                    && !c.getCreatureAttackedThisTurn()
+                    && !c.getCreatureAttackedThisTurn() && AllZone.getPhase().isPlayerTurn(c.getController())) {
-                    && AllZone.getPhase().isPlayerTurn(c.getController()))
-            {
                 final Card source = c;
                 final SpellAbility change = new Ability(source, "0") {
                     @Override
@@ -226,8 +230,7 @@ public class EndOfTurn implements java.io.Serializable {
 
             }
             if (c.hasKeyword("At the beginning of your end step, return CARDNAME to its owner's hand.")
-                    && AllZone.getPhase().isPlayerTurn(c.getController()))
+                    && AllZone.getPhase().isPlayerTurn(c.getController())) {
-            {
                 final Card source = c;
                 final SpellAbility change = new Ability(source, "0") {
                     @Override
@@ -247,10 +250,8 @@ public class EndOfTurn implements java.io.Serializable {
 
         }
 
-
         execute(at);
 
-
         CardList all2 = AllZoneUtil.getCardsIn(Zone.Battlefield);
         for (Card c : all2) {
             c.clearMustBlockCards();
@@ -259,11 +260,12 @@ public class EndOfTurn implements java.io.Serializable {
             }
         }
 
-    } //executeAt()
+    } // executeAt()
-
 
     /**
-     * <p>executeUntil.</p>
+     * <p>
+     * executeUntil.
+     * </p>
      */
     public final void executeUntil() {
         execute(until);
@@ -271,7 +273,9 @@ public class EndOfTurn implements java.io.Serializable {
     }
 
     /**
-     * <p>sizeAt.</p>
+     * <p>
+     * sizeAt.
+     * </p>
      * 
      * @return a int.
      */
@@ -280,7 +284,9 @@ public class EndOfTurn implements java.io.Serializable {
     }
 
     /**
-     * <p>sizeUntil.</p>
+     * <p>
+     * sizeUntil.
+     * </p>
      * 
      * @return a int.
      */
@@ -289,7 +295,9 @@ public class EndOfTurn implements java.io.Serializable {
     }
 
     /**
-     * <p>sizeLast.</p>
+     * <p>
+     * sizeLast.
+     * </p>
      * 
      * @return a int.
      */
@@ -298,9 +306,12 @@ public class EndOfTurn implements java.io.Serializable {
     }
 
     /**
-     * <p>execute.</p>
+     * <p>
+     * execute.
+     * </p>
      * 
-     * @param c a {@link forge.CommandList} object.
+     * @param c
+     *            a {@link forge.CommandList} object.
      */
     private void execute(final CommandList c) {
         int length = c.size();
@@ -310,4 +321,4 @@ public class EndOfTurn implements java.io.Serializable {
         }
     }
 
-} //end class EndOfTurn
+} // end class EndOfTurn

src/main/java/forge/ExternalPanel.java

@@ -1,12 +1,16 @@
 package forge;
 
-import javax.swing.*;
+import java.awt.BorderLayout;
-import java.awt.*;
+import java.awt.Component;
+import java.awt.Dimension;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.WindowAdapter;
 import java.awt.event.WindowEvent;
 
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
 
 /**
  * ExternalPanel.java
@@ -14,9 +18,9 @@ import java.awt.event.WindowEvent;
  * Created on 13.08.2009
  */
 
-
 /**
- * The class ExternalPanel. A panel with which some other component can be shown in an external window.
+ * The class ExternalPanel. A panel with which some other component can be shown
+ * in an external window.
  * 
  * @author Clemens Koza
  * @version V0.0 13.08.2009
@@ -29,19 +33,26 @@ public class ExternalPanel extends JPanel {
     private JFrame frame;
 
     /**
-     * <p>Constructor for ExternalPanel.</p>
+     * <p>
+     * Constructor for ExternalPanel.
+     * </p>
      * 
-     * @param child a {@link java.awt.Component} object.
+     * @param child
+     *            a {@link java.awt.Component} object.
      */
     public ExternalPanel(final Component child) {
         this(child, BorderLayout.EAST);
     }
 
     /**
-     * <p>Constructor for ExternalPanel.</p>
+     * <p>
+     * Constructor for ExternalPanel.
+     * </p>
      * 
-     * @param child a {@link java.awt.Component} object.
+     * @param child
-     * @param side a {@link java.lang.String} object.
+     *            a {@link java.awt.Component} object.
+     * @param side
+     *            a {@link java.lang.String} object.
      */
     public ExternalPanel(final Component child, final String side) {
         super(new BorderLayout());
@@ -55,9 +66,12 @@ public class ExternalPanel extends JPanel {
     }
 
     /**
-     * <p>setHeadSide.</p>
+     * <p>
+     * setHeadSide.
+     * </p>
      * 
-     * @param side a {@link java.lang.String} object.
+     * @param side
+     *            a {@link java.lang.String} object.
      */
     public final void setHeadSide(final String side) {
         remove(head);

src/main/java/forge/FileUtil.java

@@ -1,9 +1,5 @@
 package forge;
 
-import forge.error.ErrorViewer;
-import forge.properties.ForgeProps;
-import forge.properties.NewConstants.LANG.Gui_DownloadPictures.ERRORS;
-
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.BufferedReader;
@@ -19,9 +15,15 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+import forge.error.ErrorViewer;
+import forge.properties.ForgeProps;
+import forge.properties.NewConstants.LANG.Gui_DownloadPictures.ERRORS;
 
+// TODO: Auto-generated Javadoc
 /**
- * <p>FileUtil class.</p>
+ * <p>
+ * FileUtil class.
+ * </p>
  * 
  * @author Forge
  * @version $Id$
@@ -33,9 +35,12 @@ public final class FileUtil {
     }
 
     /**
-     * <p>doesFileExist.</p>
+     * <p>
+     * doesFileExist.
+     * </p>
      * 
-     * @param filename a {@link java.lang.String} object.
+     * @param filename
+     *            a {@link java.lang.String} object.
      * @return a boolean.
      */
     public static boolean doesFileExist(final String filename) {
@@ -44,24 +49,32 @@ public final class FileUtil {
     }
 
     /**
-     * <p>writeFile.</p>
+     * <p>
+     * writeFile.
+     * </p>
      * 
-     * @param filename a {@link java.lang.String} object.
+     * @param filename
-     * @param data a {@link java.util.List} object.
+     *            a {@link java.lang.String} object.
+     * @param data
+     *            a {@link java.util.List} object.
      */
     public static void writeFile(final String filename, final List<String> data) {
         writeFile(new File(filename), data);
     }
 
-    //writes each element of ArrayList on a separate line
+    // writes each element of ArrayList on a separate line
-    //this is used to write a file of Strings
+    // this is used to write a file of Strings
-    //this will create a new file if needed
+    // this will create a new file if needed
-    //if filename already exists, it is deleted
+    // if filename already exists, it is deleted
     /**
-     * <p>writeFile.</p>
+     * <p>
+     * writeFile.
+     * </p>
      * 
-     * @param file a {@link java.io.File} object.
+     * @param file
-     * @param data a {@link java.util.List} object.
+     *            a {@link java.io.File} object.
+     * @param data
+     *            a {@link java.util.List} object.
      */
     public static void writeFile(final File file, final List<String> data) {
         try {
@@ -78,25 +91,31 @@ public final class FileUtil {
             ErrorViewer.showError(ex);
             throw new RuntimeException("FileUtil : writeFile() error, problem writing file - " + file + " : " + ex);
         }
-    } //writeAllDecks()
+    } // writeAllDecks()
 
     /**
-     * <p>readFile.</p>
+     * <p>
+     * readFile.
+     * </p>
      * 
-     * @param filename a {@link java.lang.String} object.
+     * @param filename
+     *            a {@link java.lang.String} object.
      * @return a {@link java.util.ArrayList} object.
      */
     public static ArrayList<String> readFile(final String filename) {
         return readFile(new File(filename));
     }
 
-    //reads line by line and adds each line to the ArrayList
+    // reads line by line and adds each line to the ArrayList
-    //this will return blank lines as well
+    // this will return blank lines as well
-    //if filename not found, returns an empty ArrayList
+    // if filename not found, returns an empty ArrayList
     /**
-     * <p>readFile.</p>
+     * <p>
+     * readFile.
+     * </p>
      * 
-     * @param file a {@link java.io.File} object.
+     * @param file
+     *            a {@link java.io.File} object.
      * @return a {@link java.util.ArrayList} object.
      */
     public static ArrayList<String> readFile(final File file) {
@@ -108,7 +127,6 @@ public final class FileUtil {
                 return list;
             }
 
-
             in = new BufferedReader(new FileReader(file));
 
             String line;
@@ -121,11 +139,16 @@ public final class FileUtil {
         }
 
         return list;
-    } //readFile()
+    } // readFile()
 
-    public static void downloadUrlIntoFile(final String url, final File target)
+    /**
-    {
+     * Download url into file.
-        try{
+     *
+     * @param url the url
+     * @param target the target
+     */
+    public static void downloadUrlIntoFile(final String url, final File target) {
+        try {
             byte[] buf = new byte[1024];
             int len;
 
@@ -133,17 +156,15 @@ public final class FileUtil {
             BufferedInputStream in = new BufferedInputStream(new URL(url).openConnection(p).getInputStream());
             BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(target));
 
-            //while - read and write file
+            // while - read and write file
             while ((len = in.read(buf)) != -1) {
                 out.write(buf, 0, len);
 
-            }//while - read and write file
+            } // while - read and write file
             in.close();
             out.flush();
             out.close();
-        }
+        } catch (IOException ioex) {
-        catch (IOException ioex)
-        {
             ErrorViewer.showError(ioex, ForgeProps.getLocalized(ERRORS.OTHER), "deck_temp.html", url);
         }
 

src/main/java/forge/GameEntity.java

@@ -4,9 +4,11 @@ import java.util.ArrayList;
 
 import forge.card.spellability.SpellAbility;
 
-
+// TODO: Auto-generated Javadoc
 /**
- * <p>Abstract Player class.</p>
+ * <p>
+ * Abstract Player class.
+ * </p>
  * 
  * @author Forge
  * @version $Id: Player.java 10091 2011-08-30 16:11:21Z Sloth $
@@ -14,10 +16,14 @@ import forge.card.spellability.SpellAbility;
 public abstract class GameEntity extends MyObservable {
     private String name = "";
     private int preventNextDamage = 0;
+    
+    /** The enchanted by. */
     protected ArrayList<Card> enchantedBy = new ArrayList<Card>();
 
     /**
-     * <p>Getter for the field <code>name</code>.</p>
+     * <p>
+     * Getter for the field <code>name</code>.
+     * </p>
      * 
      * @return a {@link java.lang.String} object.
      */
@@ -25,27 +31,33 @@ public abstract class GameEntity extends MyObservable {
         return name;
     }
 
-
     /**
-     * <p>Setter for the field <code>name</code>.</p>
+     * <p>
+     * Setter for the field <code>name</code>.
+     * </p>
      * 
-     * @param s a {@link java.lang.String} object.
+     * @param s
+     *            a {@link java.lang.String} object.
      */
     public void setName(String s) {
         name = s;
     }
 
-    //////////////////////////
+    // ////////////////////////
     //
     // methods for handling damage
     //
-    //////////////////////////
+    // ////////////////////////
 
     /**
-     * <p>addDamage.</p>
+     * <p>
+     * addDamage.
+     * </p>
      * 
-     * @param damage a int.
+     * @param damage
-     * @param source a {@link forge.Card} object.
+     *            a int.
+     * @param source
+     *            a {@link forge.Card} object.
      */
     public void addDamage(final int damage, final Card source) {
         int damageToDo = damage;
@@ -57,10 +69,14 @@ public abstract class GameEntity extends MyObservable {
     }
 
     /**
-     * <p>addDamageWithoutPrevention.</p>
+     * <p>
+     * addDamageWithoutPrevention.
+     * </p>
      * 
-     * @param damage a int.
+     * @param damage
-     * @param source a {@link forge.Card} object.
+     *            a int.
+     * @param source
+     *            a {@link forge.Card} object.
      */
     public void addDamageWithoutPrevention(final int damage, final Card source) {
         int damageToDo = damage;
@@ -70,27 +86,39 @@ public abstract class GameEntity extends MyObservable {
         addDamageAfterPrevention(damageToDo, source, false);
     }
 
-    //This function handles damage after replacement and prevention effects are applied
+    // This function handles damage after replacement and prevention effects are
+    // applied
     /**
-     * <p>addDamageAfterPrevention.</p>
+     * <p>
+     * addDamageAfterPrevention.
+     * </p>
      * 
-     * @param damage a int.
+     * @param damage
-     * @param source a {@link forge.Card} object.
+     *            a int.
-     * @param isCombat a boolean.
+     * @param source
+     *            a {@link forge.Card} object.
+     * @param isCombat
+     *            a boolean.
      */
     public void addDamageAfterPrevention(final int damage, final Card source, final boolean isCombat) {
 
     }
 
     /**
-     * <p>predictDamage.</p>
+     * <p>
+     * predictDamage.
+     * </p>
      * 
-     * @param damage a int.
+     * @param damage
-     * @param source a {@link forge.Card} object.
+     *            a int.
-     * @param isCombat a boolean.
+     * @param source
+     *            a {@link forge.Card} object.
+     * @param isCombat
+     *            a boolean.
      * @return a int.
      */
-    //This function helps the AI calculate the actual amount of damage an effect would deal
+    // This function helps the AI calculate the actual amount of damage an
+    // effect would deal
     public int predictDamage(final int damage, final Card source, final boolean isCombat) {
 
         int restDamage = damage;
@@ -101,26 +129,38 @@ public abstract class GameEntity extends MyObservable {
         return restDamage;
     }
 
-    //This should be also usable by the AI to forecast an effect (so it must not change the game state)
+    // This should be also usable by the AI to forecast an effect (so it must
+    // not change the game state)
     /**
-     * <p>staticDamagePrevention.</p>
+     * <p>
+     * staticDamagePrevention.
+     * </p>
      * 
-     * @param damage a int.
+     * @param damage
-     * @param source a {@link forge.Card} object.
+     *            a int.
-     * @param isCombat a boolean.
+     * @param source
+     *            a {@link forge.Card} object.
+     * @param isCombat
+     *            a boolean.
      * @return a int.
      */
     public int staticDamagePrevention(final int damage, final Card source, final boolean isCombat) {
         return 0;
     }
 
-    //This should be also usable by the AI to forecast an effect (so it must not change the game state)
+    // This should be also usable by the AI to forecast an effect (so it must
+    // not change the game state)
     /**
-     * <p>staticReplaceDamage.</p>
+     * <p>
+     * staticReplaceDamage.
+     * </p>
      * 
-     * @param damage a int.
+     * @param damage
-     * @param source a {@link forge.Card} object.
+     *            a int.
-     * @param isCombat a boolean.
+     * @param source
+     *            a {@link forge.Card} object.
+     * @param isCombat
+     *            a boolean.
      * @return a int.
      */
     public int staticReplaceDamage(final int damage, Card source, boolean isCombat) {
@@ -128,11 +168,16 @@ public abstract class GameEntity extends MyObservable {
     }
 
     /**
-     * <p>replaceDamage.</p>
+     * <p>
+     * replaceDamage.
+     * </p>
      * 
-     * @param damage a int.
+     * @param damage
-     * @param source a {@link forge.Card} object.
+     *            a int.
-     * @param isCombat a boolean.
+     * @param source
+     *            a {@link forge.Card} object.
+     * @param isCombat
+     *            a boolean.
      * @return a int.
      */
     public int replaceDamage(final int damage, Card source, boolean isCombat) {
@@ -140,35 +185,45 @@ public abstract class GameEntity extends MyObservable {
     }
 
     /**
-     * <p>preventDamage.</p>
+     * <p>
+     * preventDamage.
+     * </p>
      * 
-     * @param damage a int.
+     * @param damage
-     * @param source a {@link forge.Card} object.
+     *            a int.
-     * @param isCombat a boolean.
+     * @param source
+     *            a {@link forge.Card} object.
+     * @param isCombat
+     *            a boolean.
      * @return a int.
      */
     public int preventDamage(final int damage, Card source, boolean isCombat) {
         return 0;
     }
 
-    //////////////////////////
+    // ////////////////////////
     //
     // methods for handling Damage Prevention
     //
-    //////////////////////////
+    // ////////////////////////
 
-    //PreventNextDamage
+    // PreventNextDamage
     /**
-     * <p>Setter for the field <code>preventNextDamage</code>.</p>
+     * <p>
+     * Setter for the field <code>preventNextDamage</code>.
+     * </p>
      * 
-     * @param n a int.
+     * @param n
+     *            a int.
      */
     public void setPreventNextDamage(int n) {
         preventNextDamage = n;
     }
 
     /**
-     * <p>Getter for the field <code>preventNextDamage</code>.</p>
+     * <p>
+     * Getter for the field <code>preventNextDamage</code>.
+     * </p>
      * 
      * @return a int.
      */
@@ -177,64 +232,105 @@ public abstract class GameEntity extends MyObservable {
     }
 
     /**
-     * <p>addPreventNextDamage.</p>
+     * <p>
+     * addPreventNextDamage.
+     * </p>
      * 
-     * @param n a int.
+     * @param n
+     *            a int.
      */
     public void addPreventNextDamage(int n) {
         preventNextDamage += n;
     }
 
     /**
-     * <p>subtractPreventNextDamage.</p>
+     * <p>
+     * subtractPreventNextDamage.
+     * </p>
      * 
-     * @param n a int.
+     * @param n
+     *            a int.
      */
     public void subtractPreventNextDamage(int n) {
         preventNextDamage -= n;
     }
 
     /**
-     * <p>resetPreventNextDamage.</p>
+     * <p>
+     * resetPreventNextDamage.
+     * </p>
      */
     public void resetPreventNextDamage() {
         preventNextDamage = 0;
     }
 
-	
+    /**
-	public boolean hasKeyword(String keyword){
+     * Checks for keyword.
-		return false;
+     *
-	}
+     * @param keyword the keyword
+     * @return true, if successful
+     */
+    public boolean hasKeyword(String keyword) {
+        return false;
+    }
 
     /**
+     * Can target.
      *
-     * @param sa
+     * @param sa the sa
-     * @return  a boolean
+     * @return a boolean
      */
     public boolean canTarget(SpellAbility sa) {
         return false;
     }
 
+    /**
+     * Checks if is valid.
+     *
+     * @param Restrictions the restrictions
+     * @param sourceController the source controller
+     * @param source the source
+     * @return true, if is valid
+     */
     public boolean isValid(final String Restrictions[], final Player sourceController, final Card source) {
 
         for (int i = 0; i < Restrictions.length; i++) {
-            if (isValid(Restrictions[i], sourceController, source)) return true;
+            if (isValid(Restrictions[i], sourceController, source))
+                return true;
         }
         return false;
 
-    }//isValid
+    }// isValid
 
+    /**
+     * Checks if is valid.
+     *
+     * @param Restriction the restriction
+     * @param sourceController the source controller
+     * @param source the source
+     * @return true, if is valid
+     */
     public boolean isValid(final String Restriction, final Player sourceController, final Card source) {
         return false;
     }
 
+    /**
+     * Checks for property.
+     *
+     * @param Property the property
+     * @param sourceController the source controller
+     * @param source the source
+     * @return true, if successful
+     */
     public boolean hasProperty(String Property, final Player sourceController, final Card source) {
         return false;
     }
 
     // GameEntities can now be Enchanted
     /**
-     * <p>Getter for the field <code>enchantedBy</code>.</p>
+     * <p>
+     * Getter for the field <code>enchantedBy</code>.
+     * </p>
      * 
      * @return a {@link java.util.ArrayList} object.
      */
@@ -243,16 +339,21 @@ public abstract class GameEntity extends MyObservable {
     }
 
     /**
-     * <p>Setter for the field <code>enchantedBy</code>.</p>
+     * <p>
+     * Setter for the field <code>enchantedBy</code>.
+     * </p>
      * 
-     * @param list a {@link java.util.ArrayList} object.
+     * @param list
+     *            a {@link java.util.ArrayList} object.
      */
     public final void setEnchantedBy(final ArrayList<Card> list) {
         enchantedBy = list;
     }
 
     /**
-     * <p>isEnchanted.</p>
+     * <p>
+     * isEnchanted.
+     * </p>
      * 
      * @return a boolean.
      */
@@ -260,11 +361,13 @@ public abstract class GameEntity extends MyObservable {
         return enchantedBy.size() != 0;
     }
 
-
     /**
-     * <p>addEnchantedBy.</p>
+     * <p>
+     * addEnchantedBy.
+     * </p>
      * 
-     * @param c a {@link forge.Card} object.
+     * @param c
+     *            a {@link forge.Card} object.
      */
     public final void addEnchantedBy(final Card c) {
         enchantedBy.add(c);
@@ -272,9 +375,12 @@ public abstract class GameEntity extends MyObservable {
     }
 
     /**
-     * <p>removeEnchantedBy.</p>
+     * <p>
+     * removeEnchantedBy.
+     * </p>
      * 
-     * @param c a {@link forge.Card} object.
+     * @param c
+     *            a {@link forge.Card} object.
      */
     public final void removeEnchantedBy(final Card c) {
         enchantedBy.remove(c);
@@ -282,7 +388,9 @@ public abstract class GameEntity extends MyObservable {
     }
 
     /**
-     * <p>unEnchantAllCards.</p>
+     * <p>
+     * unEnchantAllCards.
+     * </p>
      */
     public final void unEnchantAllCards() {
         for (int i = 0; i < enchantedBy.size(); i++) {
@@ -290,12 +398,11 @@ public abstract class GameEntity extends MyObservable {
         }
     }
 
-
+    // //////////////////////////////
-    ////////////////////////////////
     //
     // generic Object overrides
     //
-    /////////////////////////////////
+    // ///////////////////////////////
 
     /** {@inheritDoc} */
     @Override

src/main/java/forge/Gui_DownloadPrices.java

@@ -1,33 +1,46 @@
 package forge;
 
-import forge.properties.ForgeProps;
+import java.awt.Point;
-import forge.properties.NewConstants.LANG.Gui_DownloadPrices.DOWNLOADPRICES;
+import java.io.BufferedInputStream;
-import forge.properties.NewConstants.QUEST;
+import java.io.BufferedOutputStream;
-
+import java.io.BufferedReader;
-import javax.swing.*;
+import java.io.BufferedWriter;
-import java.awt.*;
+import java.io.File;
-import java.io.*;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
 import java.net.Proxy;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+
+import forge.properties.ForgeProps;
+import forge.properties.NewConstants.LANG.Gui_DownloadPrices.DOWNLOADPRICES;
+import forge.properties.NewConstants.QUEST;
+
 /**
- * <p>Gui_DownloadPrices class.</p>
+ * <p>
+ * Gui_DownloadPrices class.
+ * </p>
  * 
  * @author Forge
  * @version $Id$
  */
 public class Gui_DownloadPrices extends JFrame {
 
-    /** Constant <code>serialVersionUID=1L</code> */
+    /** Constant <code>serialVersionUID=1L</code>. */
     private static final long serialVersionUID = 1L;
     private JPanel jContentPane = null;
     private JButton jButton = null;
 
     /**
-     * This is the default constructor
+     * This is the default constructor.
      */
     public Gui_DownloadPrices() {
         super();
@@ -35,7 +48,7 @@ public class Gui_DownloadPrices extends JFrame {
     }
 
     /**
-     * This method initializes this
+     * This method initializes this.
      */
     private void initialize() {
         this.setSize(386, 200);
@@ -44,7 +57,7 @@ public class Gui_DownloadPrices extends JFrame {
     }
 
     /**
-     * This method initializes jContentPane
+     * This method initializes jContentPane.
      * 
      * @return javax.swing.JPanel
      */
@@ -58,7 +71,7 @@ public class Gui_DownloadPrices extends JFrame {
     }
 
     /**
-     * This method initializes jButton
+     * This method initializes jButton.
      * 
      * @return javax.swing.JButton
      */
@@ -70,9 +83,10 @@ public class Gui_DownloadPrices extends JFrame {
             jButton.setSize(158, 89);
 
             jButton.addActionListener(new java.awt.event.ActionListener() {
-                public void actionPerformed(java.awt.event.ActionEvent e) {
+                public void actionPerformed(final java.awt.event.ActionEvent e) {
-                    if (jButton.getText().equals("Done!"))
+                    if (jButton.getText().equals("Done!")) {
                         Gui_DownloadPrices.this.dispose();
+                    }
 
                     BufferedInputStream in = null;
                     BufferedOutputStream out = null;
@@ -85,14 +99,12 @@ public class Gui_DownloadPrices extends JFrame {
                     String s = "Downloading";
 
                     try {
-                        in = new BufferedInputStream(new URL(url)
+                        in = new BufferedInputStream(new URL(url).openConnection(p).getInputStream());
-                                .openConnection(p).getInputStream());
                         out = new BufferedOutputStream(new FileOutputStream(f));
 
                         jButton.setText(ForgeProps.getLocalized(DOWNLOADPRICES.DOWNLOADING));
                         jContentPane.paintImmediately(jButton.getBounds());
 
-
                         int len = 0;
                         while ((len = in.read(buf)) != -1) {
                             out.write(buf, 0, len);
@@ -100,8 +112,7 @@ public class Gui_DownloadPrices extends JFrame {
                             if (++x % 50 == 0) {
                                 s += ".";
                                 jButton.setText(s);
-                                jContentPane.paintImmediately(jButton
+                                jContentPane.paintImmediately(jButton.getBounds());
-                                        .getBounds());
 
                                 if (x >= 300) {
                                     x = 0;
@@ -116,14 +127,16 @@ public class Gui_DownloadPrices extends JFrame {
                         return;
                     } finally {
                         try {
-                            if (in != null)
+                            if (in != null) {
                                 in.close();
-                            if (out != null)
+                            }
+                            if (out != null) {
                                 out.close();
+                            }
                         } catch (IOException ex) {
                             return;
                         }
-                    }// while - read and write file
+                    } // while - read and write file
 
                     FileReader fr = null;
                     FileWriter fw = null;
@@ -144,7 +157,7 @@ public class Gui_DownloadPrices extends JFrame {
                         x = 0;
                         s = "Compiling";
                         while (line != null && !line.equals("")) {
-                            String ll[] = line.split("\\|");
+                            String[] ll = line.split("\\|");
 
                             if (ll[0].contains("(")) {
                                 int indx = ll[0].indexOf(" (");
@@ -160,21 +173,25 @@ public class Gui_DownloadPrices extends JFrame {
 
                                 if (cp >= inp) {
                                     fScl = 1 - (float) inp / (float) cp;
-                                    if (fScl > .333)
+                                    if (fScl > .333) {
                                         cp = cp / 2;
+                                    }
                                 } else {
                                     fScl = 1 - (float) cp / (float) inp;
-                                    if (fScl > .333)
+                                    if (fScl > .333) {
                                         inp = inp / 2;
+                                    }
                                 }
 
                                 int ap = (cp + inp) / 2;
-                                if (ap < 7)
+                                if (ap < 7) {
                                     ap += 10;
+                                }
                                 prices.put(ll[0], ap);
                             } else {
-                                if (inp < 7)
+                                if (inp < 7) {
                                     inp += 10;
+                                }
 
                                 prices.put(ll[0], inp);
                             }
@@ -185,8 +202,7 @@ public class Gui_DownloadPrices extends JFrame {
                             if (++x % 100 == 0) {
                                 s += ".";
                                 jButton.setText(s);
-                                jContentPane.paintImmediately(jButton
+                                jContentPane.paintImmediately(jButton.getBounds());
-                                        .getBounds());
 
                                 if (x >= 500) {
                                     x = 0;
@@ -195,14 +211,12 @@ public class Gui_DownloadPrices extends JFrame {
                             }
                         }
 
-                        String pfn = ForgeProps.getFile(QUEST.PRICE)
+                        String pfn = ForgeProps.getFile(QUEST.PRICE).getAbsolutePath();
-                                .getAbsolutePath();
                         String pfnb = pfn.replace(".txt", ".bak");
                         File ff = new File(pfn);
                         ff.renameTo(new File(pfnb));
 
-                        fw = new FileWriter(ForgeProps
+                        fw = new FileWriter(ForgeProps.getFile(QUEST.PRICE));
-                                .getFile(QUEST.PRICE));
                         BufferedWriter outBW = new BufferedWriter(fw);
 
                         // Collection<String> keys = prices.keySet();
@@ -213,24 +227,22 @@ public class Gui_DownloadPrices extends JFrame {
                         for (int i = 0; i < keys.size(); i++) {
                             // keys.add(key);
                             String k = keys.get(i);
-                            if (k.equals("Plains") || k.equals("Island")
+                            if (k.equals("Plains") || k.equals("Island") || k.equals("Swamp") || k.equals("Mountain")
-                                    || k.equals("Swamp")
-                                    || k.equals("Mountain")
                                     || k.equals("Forest"))
+                            {
                                 outBW.write(k + "=5\r\n");
-
+                            } else if (k.equals("Snow-Covered Plains") || k.equals("Snow-Covered Island")
-                            else if (k.equals("Snow-Covered Plains")
+                                    || k.equals("Snow-Covered Swamp") || k.equals("Snow-Covered Mountain")
-                                    || k.equals("Snow-Covered Island")
-                                    || k.equals("Snow-Covered Swamp")
-                                    || k.equals("Snow-Covered Mountain")
                                     || k.equals("Snow-Covered Forest"))
+                            {
                                 outBW.write(k + "=10\r\n");
-                            else
+                            } else {
-                                outBW.write(keys.get(i) + "="
+                                outBW.write(keys.get(i) + "=" + prices.get(keys.get(i)) + "\r\n");
-                                        + prices.get(keys.get(i)) + "\r\n");
+                            }
 
-                            if (i % 100 == 0)
+                            if (i % 100 == 0) {
                                 outBW.flush();
+                            }
                         }
 
                         outBW.flush();
@@ -244,10 +256,12 @@ public class Gui_DownloadPrices extends JFrame {
                         return;
                     } finally {
                         try {
-                            if (fr != null)
+                            if (fr != null) {
                                 fr.close();
-                            if (fw != null)
+                            }
+                            if (fw != null) {
                                 fw.close();
+                            }
                         } catch (IOException ex) {
                             return;
                         }