[ci skip] spotlessApply with the new settings

1 files changed, 187 insertions, 166 deletions

diff --git a/src/main/java/gregtech/common/GT_Worldgenerator.java b/src/main/java/gregtech/common/GT_Worldgenerator.java
index fe02ed010c..8566fd769e 100644
--- a/src/main/java/gregtech/common/GT_Worldgenerator.java
+++ b/src/main/java/gregtech/common/GT_Worldgenerator.java
@@ -6,26 +6,29 @@ import static gregtech.api.enums.GT_Values.oreveinAttempts;
 import static gregtech.api.enums.GT_Values.oreveinMaxPlacementAttempts;
 import static gregtech.api.enums.GT_Values.oreveinPercentage;
 
-import cpw.mods.fml.common.IWorldGenerator;
-import cpw.mods.fml.common.registry.GameRegistry;
-import gregtech.api.GregTech_API;
-import gregtech.api.enums.Materials;
-import gregtech.api.objects.XSTR;
-import gregtech.api.util.GT_Log;
-import gregtech.api.world.GT_Worldgen;
-import gregtech.common.blocks.GT_TileEntity_Ores;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Hashtable;
 import java.util.List;
 import java.util.Random;
+
 import net.minecraft.init.Blocks;
 import net.minecraft.util.MathHelper;
 import net.minecraft.world.World;
 import net.minecraft.world.chunk.Chunk;
 import net.minecraft.world.chunk.IChunkProvider;
 
+import cpw.mods.fml.common.IWorldGenerator;
+import cpw.mods.fml.common.registry.GameRegistry;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Materials;
+import gregtech.api.objects.XSTR;
+import gregtech.api.util.GT_Log;
+import gregtech.api.world.GT_Worldgen;
+import gregtech.common.blocks.GT_TileEntity_Ores;
+
 public class GT_Worldgenerator implements IWorldGenerator {
+
     private static int mEndAsteroidProbability = 300;
     private static int mSize = 100;
     private static int endMinSize = 50;
@@ -33,7 +36,7 @@ public class GT_Worldgenerator implements IWorldGenerator {
     private static boolean endAsteroids = true;
     public static List<Runnable> mList = new ArrayList();
     public static HashSet<Long> ProcChunks = new HashSet<Long>();
-    // This is probably not going to work.  Trying to create a fake orevein to put into hashtable when there will be no
+    // This is probably not going to work. Trying to create a fake orevein to put into hashtable when there will be no
     // ores in a vein.
     public static GT_Worldgen_GT_Ore_Layer noOresInVein = new GT_Worldgen_GT_Ore_Layer(
             "NoOresInVein",
@@ -66,45 +69,50 @@ public class GT_Worldgenerator implements IWorldGenerator {
     }
 
     @Override
-    public void generate(
-            Random aRandom,
-            int aX,
-            int aZ,
-            World aWorld,
-            IChunkProvider aChunkGenerator,
+    public void generate(Random aRandom, int aX, int aZ, World aWorld, IChunkProvider aChunkGenerator,
             IChunkProvider aChunkProvider) {
         synchronized (listLock) {
-            mList.add(new WorldGenContainer(
-                    new XSTR(Math.abs(aRandom.nextInt()) + 1),
-                    aX,
-                    aZ,
-                    aWorld.provider.dimensionId,
-                    aWorld,
-                    aChunkGenerator,
-                    aChunkProvider,
-                    aWorld.getBiomeGenForCoords(aX * 16 + 8, aZ * 16 + 8).biomeName));
-            if (debugWorldGen)
-                GT_Log.out.println("ADD WorldSeed:" + aWorld.getSeed() + " DimId"
-                        + aWorld.provider.dimensionId + " chunk x:"
-                        + aX + " z:"
-                        + aZ + " SIZE: "
-                        + mList.size());
+            mList.add(
+                    new WorldGenContainer(
+                            new XSTR(Math.abs(aRandom.nextInt()) + 1),
+                            aX,
+                            aZ,
+                            aWorld.provider.dimensionId,
+                            aWorld,
+                            aChunkGenerator,
+                            aChunkProvider,
+                            aWorld.getBiomeGenForCoords(aX * 16 + 8, aZ * 16 + 8).biomeName));
+            if (debugWorldGen) GT_Log.out.println(
+                    "ADD WorldSeed:" + aWorld.getSeed()
+                            + " DimId"
+                            + aWorld.provider.dimensionId
+                            + " chunk x:"
+                            + aX
+                            + " z:"
+                            + aZ
+                            + " SIZE: "
+                            + mList.size());
         }
 
         if (!this.mIsGenerating) {
             this.mIsGenerating = true;
             int mList_sS = mList.size();
-            mList_sS = Math.min(
-                    mList_sS, 5); // Run a maximum of 5 chunks at a time through worldgen. Extra chunks get done later.
+            mList_sS = Math.min(mList_sS, 5); // Run a maximum of 5 chunks at a time through worldgen. Extra chunks get
+                                              // done later.
             for (int i = 0; i < mList_sS; i++) {
                 WorldGenContainer toRun = (WorldGenContainer) mList.get(0);
-                if (debugWorldGen)
-                    GT_Log.out.println("RUN WorldSeed:" + aWorld.getSeed() + " DimId"
-                            + aWorld.provider.dimensionId + " chunk x:"
-                            + toRun.mX + " z:"
-                            + toRun.mZ + " SIZE: "
-                            + mList.size() + " i: "
-                            + i);
+                if (debugWorldGen) GT_Log.out.println(
+                        "RUN WorldSeed:" + aWorld.getSeed()
+                                + " DimId"
+                                + aWorld.provider.dimensionId
+                                + " chunk x:"
+                                + toRun.mX
+                                + " z:"
+                                + toRun.mZ
+                                + " SIZE: "
+                                + mList.size()
+                                + " i: "
+                                + i);
                 synchronized (listLock) {
                     mList.remove(0);
                 }
@@ -115,6 +123,7 @@ public class GT_Worldgenerator implements IWorldGenerator {
     }
 
     public static class WorldGenContainer implements Runnable {
+
         public final Random mRandom;
         public final int mX;
         public final int mZ;
@@ -124,10 +133,11 @@ public class GT_Worldgenerator implements IWorldGenerator {
         public final IChunkProvider mChunkProvider;
         public final String mBiome;
         // Used for outputting orevein weights and bins
-        //        static int test=0;
+        // static int test=0;
 
         // Local class to track which orevein seeds must be checked when doing chunkified worldgen
         class NearbySeeds {
+
             public int mX;
             public int mZ;
 
@@ -140,8 +150,7 @@ public class GT_Worldgenerator implements IWorldGenerator {
             public boolean equals(Object o) {
                 if (this == o) return true;
                 if (!(o instanceof GT_Worldgenerator.WorldGenContainer.NearbySeeds)) return false;
-                GT_Worldgenerator.WorldGenContainer.NearbySeeds that =
-                        (GT_Worldgenerator.WorldGenContainer.NearbySeeds) o;
+                GT_Worldgenerator.WorldGenContainer.NearbySeeds that = (GT_Worldgenerator.WorldGenContainer.NearbySeeds) o;
                 if (this.mX != that.mX) return false;
                 return this.mZ == that.mZ;
             }
@@ -152,21 +161,13 @@ public class GT_Worldgenerator implements IWorldGenerator {
                 result = 31 * result + this.mZ;
                 return result;
             }
-        }
-        ;
+        };
 
         public static ArrayList<GT_Worldgenerator.WorldGenContainer.NearbySeeds> seedList = new ArrayList();
 
         // aX and aZ are now the by-chunk X and Z for the chunk of interest
-        public WorldGenContainer(
-                Random aRandom,
-                int aX,
-                int aZ,
-                int aDimensionType,
-                World aWorld,
-                IChunkProvider aChunkGenerator,
-                IChunkProvider aChunkProvider,
-                String aBiome) {
+        public WorldGenContainer(Random aRandom, int aX, int aZ, int aDimensionType, World aWorld,
+                IChunkProvider aChunkGenerator, IChunkProvider aChunkProvider, String aBiome) {
             this.mRandom = aRandom;
             this.mX = aX;
             this.mZ = aZ;
@@ -180,20 +181,20 @@ public class GT_Worldgenerator implements IWorldGenerator {
         // How to evaluate oregen distribution
         // - Enable debugOreveins
         // - Fly around for a while, or teleport jumping ~320 blocks at a time, with
-        //   a 15-30s pause for worldgen to catch up
+        // a 15-30s pause for worldgen to catch up
         // - Do this across a large area, at least 2000x2000 blocks for good numbers
         // - Open logs\gregtech.log
-        // - Using notepad++, do a Search | Find  - enter "Added" for the search term
+        // - Using notepad++, do a Search | Find - enter "Added" for the search term
         // - Select Find All In Current Document
         // - In the Search window, right-click and Select All
         // - Copy and paste to a new file
-        // - Delete extraneous stuff at top, and blank line at bottom.  Line count is
-        //   # of total oreveins
+        // - Delete extraneous stuff at top, and blank line at bottom. Line count is
+        // # of total oreveins
         // - For simple spot checks, use Find All in Current Document for specific
-        //   oremixes, ie ore.mix.diamond, to check how many appear in the list.
+        // oremixes, ie ore.mix.diamond, to check how many appear in the list.
         // - For more complex work, import file into Excel, and sort based on oremix
-        //   column.  Drag select the oremix names, in the bottom right will be how many
-        //   entries to add in a seperate tab to calculate %ages.
+        // column. Drag select the oremix names, in the bottom right will be how many
+        // entries to add in a seperate tab to calculate %ages.
         //
         // When using the ore weights, discount or remove the high altitude veins since
         // their high weight are offset by their rareness. I usually just use zero for them.
@@ -203,20 +204,20 @@ public class GT_Worldgenerator implements IWorldGenerator {
 
         public void worldGenFindVein(int oreseedX, int oreseedZ) {
             // Explanation of oreveinseed implementation.
-            // (long)this.mWorld.getSeed()<<16)    Deep Dark does two oregen passes, one with getSeed set to +1 the
-            // original world seed.  This pushes that +1 off the low bits of oreseedZ, so that the hashes are far apart
+            // (long)this.mWorld.getSeed()<<16) Deep Dark does two oregen passes, one with getSeed set to +1 the
+            // original world seed. This pushes that +1 off the low bits of oreseedZ, so that the hashes are far apart
             // for the two passes.
-            // ((this.mWorld.provider.dimensionId & 0xffL)<<56)    Puts the dimension in the top bits of the hash, to
+            // ((this.mWorld.provider.dimensionId & 0xffL)<<56) Puts the dimension in the top bits of the hash, to
             // make sure to get unique hashes per dimension
-            // ((long)oreseedX & 0x000000000fffffffL) << 28)    Puts the chunk X in the bits 29-55. Cuts off the top few
+            // ((long)oreseedX & 0x000000000fffffffL) << 28) Puts the chunk X in the bits 29-55. Cuts off the top few
             // bits of the chunk so we have bits for dimension.
-            // ( (long)oreseedZ & 0x000000000fffffffL ))    Puts the chunk Z in the bits 0-27. Cuts off the top few bits
+            // ( (long)oreseedZ & 0x000000000fffffffL )) Puts the chunk Z in the bits 0-27. Cuts off the top few bits
             // of the chunk so we have bits for dimension.
             long oreveinSeed = ((long) this.mWorld.getSeed() << 16)
                     ^ ((long) ((this.mWorld.provider.dimensionId & 0xffL) << 56)
                             | (((long) oreseedX & 0x000000000fffffffL) << 28)
-                            | ((long) oreseedZ
-                                    & 0x000000000fffffffL)); // Use an RNG that is identical every time it is called for
+                            | ((long) oreseedZ & 0x000000000fffffffL)); // Use an RNG that is identical every time it is
+                                                                        // called for
             // this oreseed.
             XSTR oreveinRNG = new XSTR(oreveinSeed);
             int oreveinPercentageRoll = oreveinRNG.nextInt(100); // Roll the dice, see if we get an orevein here at all
@@ -226,18 +227,22 @@ public class GT_Worldgenerator implements IWorldGenerator {
                 tDimensionName = this.mWorld.provider.getDimensionName();
             }
 
-            if (debugOrevein)
-                GT_Log.out.println(" Finding oreveins for oreveinSeed=" + oreveinSeed + " mX="
-                        + this.mX + " mZ="
-                        + this.mZ + " oreseedX="
-                        + oreseedX + " oreseedZ="
-                        + oreseedZ + " worldSeed="
-                        + this.mWorld.getSeed());
+            if (debugOrevein) GT_Log.out.println(
+                    " Finding oreveins for oreveinSeed=" + oreveinSeed
+                            + " mX="
+                            + this.mX
+                            + " mZ="
+                            + this.mZ
+                            + " oreseedX="
+                            + oreseedX
+                            + " oreseedZ="
+                            + oreseedZ
+                            + " worldSeed="
+                            + this.mWorld.getSeed());
 
             // Search for a valid orevein for this dimension
             if (!validOreveins.containsKey(oreveinSeed)) {
-                if ((oreveinPercentageRoll < oreveinPercentage)
-                        && (GT_Worldgen_GT_Ore_Layer.sWeight > 0)
+                if ((oreveinPercentageRoll < oreveinPercentage) && (GT_Worldgen_GT_Ore_Layer.sWeight > 0)
                         && (GT_Worldgen_GT_Ore_Layer.sList.size() > 0)) {
                     int placementAttempts = 0;
                     boolean oreveinFound = false;
@@ -245,24 +250,13 @@ public class GT_Worldgenerator implements IWorldGenerator {
 
                     // Used for outputting orevein weights and bins
                     /*
-                    if( test==0 )
-                        {
-                        test = 1;
-                        GT_Log.out.println(
-                            "sWeight = " + GT_Worldgen_GT_Ore_Layer.sWeight
-                            );
-                        for (GT_Worldgen_GT_Ore_Layer tWorldGen : GT_Worldgen_GT_Ore_Layer.sList) {
-                            GT_Log.out.println(
-                                ( tWorldGen).mWorldGenName + " mWeight = " + ( tWorldGen).mWeight + " mSize = " + (tWorldGen).mSize
-                                );
-                            }
-                        }
-                    */
-                    for (i = 0;
-                            (i < oreveinAttempts)
-                                    && (!oreveinFound)
-                                    && (placementAttempts < oreveinMaxPlacementAttempts);
-                            i++) {
+                     * if( test==0 ) { test = 1; GT_Log.out.println( "sWeight = " + GT_Worldgen_GT_Ore_Layer.sWeight );
+                     * for (GT_Worldgen_GT_Ore_Layer tWorldGen : GT_Worldgen_GT_Ore_Layer.sList) { GT_Log.out.println( (
+                     * tWorldGen).mWorldGenName + " mWeight = " + ( tWorldGen).mWeight + " mSize = " + (tWorldGen).mSize
+                     * ); } }
+                     */
+                    for (i = 0; (i < oreveinAttempts) && (!oreveinFound)
+                            && (placementAttempts < oreveinMaxPlacementAttempts); i++) {
                         int tRandomWeight = oreveinRNG.nextInt(GT_Worldgen_GT_Ore_Layer.sWeight);
                         for (GT_Worldgen_GT_Ore_Layer tWorldGen : GT_Worldgen_GT_Ore_Layer.sList) {
                             tRandomWeight -= (tWorldGen).mWeight;
@@ -271,7 +265,7 @@ public class GT_Worldgenerator implements IWorldGenerator {
                                     // Adjust the seed so that this layer has a series of unique random numbers.
                                     // Otherwise multiple attempts at this same oreseed will get the same offset and X/Z
                                     // values. If an orevein failed, any orevein with the
-                                    // same minimum heights would fail as well.  This prevents that, giving each orevein
+                                    // same minimum heights would fail as well. This prevents that, giving each orevein
                                     // a unique height each pass through here.
                                     int placementResult = tWorldGen.executeWorldgenChunkified(
                                             this.mWorld,
@@ -286,13 +280,16 @@ public class GT_Worldgenerator implements IWorldGenerator {
                                             this.mChunkProvider);
                                     switch (placementResult) {
                                         case GT_Worldgen_GT_Ore_Layer.ORE_PLACED:
-                                            if (debugOrevein)
-                                                GT_Log.out.println(" Added near oreveinSeed=" + oreveinSeed + " "
-                                                        + (tWorldGen).mWorldGenName
-                                                        + " tries at oremix="
-                                                        + i + " placementAttempts="
-                                                        + placementAttempts + " dimensionName="
-                                                        + tDimensionName);
+                                            if (debugOrevein) GT_Log.out.println(
+                                                    " Added near oreveinSeed=" + oreveinSeed
+                                                            + " "
+                                                            + (tWorldGen).mWorldGenName
+                                                            + " tries at oremix="
+                                                            + i
+                                                            + " placementAttempts="
+                                                            + placementAttempts
+                                                            + " dimensionName="
+                                                            + tDimensionName);
                                             validOreveins.put(oreveinSeed, tWorldGen);
                                             oreveinFound = true;
                                             break;
@@ -301,37 +298,48 @@ public class GT_Worldgenerator implements IWorldGenerator {
                                             // SHould do retry in this case until out of chances
                                             break;
                                         case GT_Worldgen_GT_Ore_Layer.NO_OVERLAP:
-                                            if (debugOrevein)
-                                                GT_Log.out.println(" Added far oreveinSeed=" + oreveinSeed + " "
-                                                        + (tWorldGen).mWorldGenName
-                                                        + " tries at oremix="
-                                                        + i + " placementAttempts="
-                                                        + placementAttempts + " dimensionName="
-                                                        + tDimensionName);
+                                            if (debugOrevein) GT_Log.out.println(
+                                                    " Added far oreveinSeed=" + oreveinSeed
+                                                            + " "
+                                                            + (tWorldGen).mWorldGenName
+                                                            + " tries at oremix="
+                                                            + i
+                                                            + " placementAttempts="
+                                                            + placementAttempts
+                                                            + " dimensionName="
+                                                            + tDimensionName);
                                             validOreveins.put(oreveinSeed, tWorldGen);
                                             oreveinFound = true;
                                             break;
                                         case GT_Worldgen_GT_Ore_Layer.NO_OVERLAP_AIR_BLOCK:
-                                            if (debugOrevein)
-                                                GT_Log.out.println(" No overlap and air block in test spot="
-                                                        + oreveinSeed + " " + (tWorldGen).mWorldGenName
-                                                        + " tries at oremix="
-                                                        + i + " placementAttempts="
-                                                        + placementAttempts + " dimensionName="
-                                                        + tDimensionName);
+                                            if (debugOrevein) GT_Log.out.println(
+                                                    " No overlap and air block in test spot=" + oreveinSeed
+                                                            + " "
+                                                            + (tWorldGen).mWorldGenName
+                                                            + " tries at oremix="
+                                                            + i
+                                                            + " placementAttempts="
+                                                            + placementAttempts
+                                                            + " dimensionName="
+                                                            + tDimensionName);
                                             // SHould do retry in this case until out of chances
                                             placementAttempts++;
                                             break;
                                     }
                                     break; // Try the next orevein
                                 } catch (Throwable e) {
-                                    if (debugOrevein)
-                                        GT_Log.out.println("Exception occurred on oreVein" + tWorldGen + " oreveinSeed="
-                                                + oreveinSeed + " mX="
-                                                + this.mX + " mZ="
-                                                + this.mZ + " oreseedX="
-                                                + oreseedX + " oreseedZ="
-                                                + oreseedZ);
+                                    if (debugOrevein) GT_Log.out.println(
+                                            "Exception occurred on oreVein" + tWorldGen
+                                                    + " oreveinSeed="
+                                                    + oreveinSeed
+                                                    + " mX="
+                                                    + this.mX
+                                                    + " mZ="
+                                                    + this.mZ
+                                                    + " oreseedX="
+                                                    + oreseedX
+                                                    + " oreseedZ="
+                                                    + oreseedZ);
                                     e.printStackTrace(GT_Log.err);
                                 }
                             }
@@ -339,37 +347,50 @@ public class GT_Worldgenerator implements IWorldGenerator {
                     }
                     // Only add an empty orevein if unable to place a vein at the oreseed chunk.
                     if ((!oreveinFound) && (this.mX == oreseedX) && (this.mZ == oreseedZ)) {
-                        if (debugOrevein)
-                            GT_Log.out.println(" Empty oreveinSeed=" + oreveinSeed + " mX="
-                                    + this.mX + " mZ="
-                                    + this.mZ + " oreseedX="
-                                    + oreseedX + " oreseedZ="
-                                    + oreseedZ + " tries at oremix="
-                                    + i + " placementAttempts="
-                                    + placementAttempts + " dimensionName="
-                                    + tDimensionName);
+                        if (debugOrevein) GT_Log.out.println(
+                                " Empty oreveinSeed=" + oreveinSeed
+                                        + " mX="
+                                        + this.mX
+                                        + " mZ="
+                                        + this.mZ
+                                        + " oreseedX="
+                                        + oreseedX
+                                        + " oreseedZ="
+                                        + oreseedZ
+                                        + " tries at oremix="
+                                        + i
+                                        + " placementAttempts="
+                                        + placementAttempts
+                                        + " dimensionName="
+                                        + tDimensionName);
                         validOreveins.put(oreveinSeed, noOresInVein);
                     }
                 } else if (oreveinPercentageRoll >= oreveinPercentage) {
-                    if (debugOrevein)
-                        GT_Log.out.println(" Skipped oreveinSeed=" + oreveinSeed + " mX="
-                                + this.mX + " mZ="
-                                + this.mZ + " oreseedX="
-                                + oreseedX + " oreseedZ="
-                                + oreseedZ + " RNG="
-                                + oreveinPercentageRoll + " %="
-                                + oreveinPercentage + " dimensionName="
-                                + tDimensionName);
+                    if (debugOrevein) GT_Log.out.println(
+                            " Skipped oreveinSeed=" + oreveinSeed
+                                    + " mX="
+                                    + this.mX
+                                    + " mZ="
+                                    + this.mZ
+                                    + " oreseedX="
+                                    + oreseedX
+                                    + " oreseedZ="
+                                    + oreseedZ
+                                    + " RNG="
+                                    + oreveinPercentageRoll
+                                    + " %="
+                                    + oreveinPercentage
+                                    + " dimensionName="
+                                    + tDimensionName);
                     validOreveins.put(oreveinSeed, noOresInVein);
                 }
             } else {
                 // oreseed is located in the previously processed table
-                if (debugOrevein)
-                    GT_Log.out.print(" Valid oreveinSeed=" + oreveinSeed + " validOreveins.size()="
-                            + validOreveins.size() + " ");
+                if (debugOrevein) GT_Log.out.print(
+                        " Valid oreveinSeed=" + oreveinSeed + " validOreveins.size()=" + validOreveins.size() + " ");
                 GT_Worldgen_GT_Ore_Layer tWorldGen = validOreveins.get(oreveinSeed);
-                oreveinRNG.setSeed(oreveinSeed
-                        ^ (tWorldGen.mPrimaryMeta)); // Reset RNG to only be based on oreseed X/Z and type of vein
+                oreveinRNG.setSeed(oreveinSeed ^ (tWorldGen.mPrimaryMeta)); // Reset RNG to only be based on oreseed X/Z
+                                                                            // and type of vein
                 int placementResult = tWorldGen.executeWorldgenChunkified(
                         this.mWorld,
                         oreveinRNG,
@@ -400,10 +421,8 @@ public class GT_Worldgenerator implements IWorldGenerator {
             try {
                 for (GT_Worldgen tWorldGen : GregTech_API.sWorldgenList) {
                     /*
-                    if (debugWorldGen) GT_Log.out.println(
-                        "tWorldGen.mWorldGenName="+tWorldGen.mWorldGenName
-                    );
-                    */
+                     * if (debugWorldGen) GT_Log.out.println( "tWorldGen.mWorldGenName="+tWorldGen.mWorldGenName );
+                     */
                     tWorldGen.executeWorldgen(
                             this.mWorld,
                             this.mRandom,
@@ -459,8 +478,7 @@ public class GT_Worldgenerator implements IWorldGenerator {
             // if (((tDimensionType == 1) && endAsteroids && ((mEndAsteroidProbability <= 1) ||
             // (aRandom.nextInt(mEndAsteroidProbability) == 0))) || ((tDimensionName.equals("Asteroids")) && gcAsteroids
             // && ((mGCAsteroidProbability <= 1) || (aRandom.nextInt(mGCAsteroidProbability) == 0)))) {
-            if (((tDimensionType == 1)
-                    && endAsteroids
+            if (((tDimensionType == 1) && endAsteroids
                     && ((mEndAsteroidProbability <= 1) || (aRandom.nextInt(mEndAsteroidProbability) == 0)))) {
                 short primaryMeta = 0;
                 short secondaryMeta = 0;
@@ -499,7 +517,7 @@ public class GT_Worldgenerator implements IWorldGenerator {
                 if (tDimensionType == 1) {
                     mSize = aRandom.nextInt((int) (endMaxSize - endMinSize));
                     // } else if (tDimensionName.equals("Asteroids")) {
-                    //    mSize = aRandom.nextInt((int) (gcMaxSize - gcMinSize));
+                    // mSize = aRandom.nextInt((int) (gcMaxSize - gcMinSize));
                 }
                 if ((mWorld.getBlock(tX, tY, tZ).isAir(mWorld, tX, tY, tZ))) {
                     float randomRadian = aRandom.nextFloat() * 3.141593F;
@@ -531,21 +549,20 @@ public class GT_Worldgenerator implements IWorldGenerator {
                                         for (int eZ = tMinZ; eZ <= tMaxZ; eZ++) {
                                             double zChance = (eZ + 0.5D - zCenter) / (halfLength / 2.0D);
                                             if ((xChance * xChance + yChance * yChance + zChance * zChance < 1.0D)
-                                                    && (mWorld.getBlock(tX, tY, tZ)
-                                                            .isAir(mWorld, tX, tY, tZ))) {
+                                                    && (mWorld.getBlock(tX, tY, tZ).isAir(mWorld, tX, tY, tZ))) {
                                                 int ranOre = aRandom.nextInt(50);
                                                 if (ranOre < 3) {
-                                                    GT_TileEntity_Ores.setOreBlock(
-                                                            mWorld, eX, eY, eZ, primaryMeta, false);
+                                                    GT_TileEntity_Ores
+                                                            .setOreBlock(mWorld, eX, eY, eZ, primaryMeta, false);
                                                 } else if (ranOre < 6) {
-                                                    GT_TileEntity_Ores.setOreBlock(
-                                                            mWorld, eX, eY, eZ, secondaryMeta, false);
+                                                    GT_TileEntity_Ores
+                                                            .setOreBlock(mWorld, eX, eY, eZ, secondaryMeta, false);
                                                 } else if (ranOre < 8) {
-                                                    GT_TileEntity_Ores.setOreBlock(
-                                                            mWorld, eX, eY, eZ, betweenMeta, false);
+                                                    GT_TileEntity_Ores
+                                                            .setOreBlock(mWorld, eX, eY, eZ, betweenMeta, false);
                                                 } else if (ranOre < 10) {
-                                                    GT_TileEntity_Ores.setOreBlock(
-                                                            mWorld, eX, eY, eZ, sporadicMeta, false);
+                                                    GT_TileEntity_Ores
+                                                            .setOreBlock(mWorld, eX, eY, eZ, sporadicMeta, false);
                                                 } else {
                                                     mWorld.setBlock(eX, eY, eZ, Blocks.end_stone, 0, 0);
                                                 }
@@ -566,9 +583,13 @@ public class GT_Worldgenerator implements IWorldGenerator {
             long endTime = System.nanoTime();
             long duration = (endTime - startTime);
             if (debugWorldGen) {
-                GT_Log.out.println(" Oregen took " + (oregenTime - leftOverTime) + " Leftover gen took "
-                        + (leftOverTime - startTime) + " Worldgen took "
-                        + duration + " nanoseconds");
+                GT_Log.out.println(
+                        " Oregen took " + (oregenTime - leftOverTime)
+                                + " Leftover gen took "
+                                + (leftOverTime - startTime)
+                                + " Worldgen took "
+                                + duration
+                                + " nanoseconds");
             }
         }
     }