[ci skip] spotlessApply with the new settings

dependencies.gradle

@@ -7,7 +7,7 @@ dependencies {
     compileOnly("org.projectlombok:lombok:1.18.24")
     annotationProcessor("org.projectlombok:lombok:1.18.24")
 
-    shadeCompile("com.github.GTNewHorizons:CTMLib:1.4.4:dev")
+    shadowImplementation("com.github.GTNewHorizons:CTMLib:1.4.4:dev")
 
     compileOnly("com.github.GTNewHorizons:waila:1.5.19:dev") {
         transitive = false

gradle.properties

@@ -57,7 +57,7 @@ containsMixinsAndOrCoreModOnly = false
 
 # If enabled, you may use 'shadowImplementation' for dependencies. They will be integrated in your jar. It is your
 # responsibility check the licence and request permission for distribution, if required.
-usesShadowedDependencies = false
+usesShadowedDependencies = true
 
 # Optional parameter to customize the produced artifacts. Use this to preserver artifact naming when migrating older
 # projects. New projects should not use this parameter.

src/main/java/com/cricketcraft/chisel/api/ChiselAPIProps.java

@@ -2,6 +2,6 @@ package com.cricketcraft.chisel.api;
 
 public class ChiselAPIProps {
 
-	public static final String VERSION = "0.1.1";
-	public static String MOD_ID = null; // Set by Chisel
+    public static final String VERSION = "0.1.1";
+    public static String MOD_ID = null; // Set by Chisel
 }

src/main/java/com/cricketcraft/chisel/api/ChiselTabs.java

@@ -3,64 +3,63 @@ package com.cricketcraft.chisel.api;
 import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
+
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class ChiselTabs {
 
-	public static class CustomCreativeTab extends CreativeTabs {
+    public static class CustomCreativeTab extends CreativeTabs {
 
-		private boolean search;
+        private boolean search;
 
-		private ItemStack stack;
+        private ItemStack stack;
 
-		public CustomCreativeTab(String label, boolean searchbar) {
-			super(label);
-			this.search = searchbar;
-		}
+        public CustomCreativeTab(String label, boolean searchbar) {
+            super(label);
+            this.search = searchbar;
+        }
 
-		@Override
-		public Item getTabIconItem() {
-			return stack.getItem();
-		}
+        @Override
+        public Item getTabIconItem() {
+            return stack.getItem();
+        }
 
-		public void setTabIconItemStack(ItemStack stack) {
-			this.stack = stack;
-		}
+        public void setTabIconItemStack(ItemStack stack) {
+            this.stack = stack;
+        }
 
-		@Override
-		public ItemStack getIconItemStack() {
-			return stack;
-		}
+        @Override
+        public ItemStack getIconItemStack() {
+            return stack;
+        }
 
-		@Override
-		@SideOnly(Side.CLIENT)
-		public String getBackgroundImageName() {
+        @Override
+        @SideOnly(Side.CLIENT)
+        public String getBackgroundImageName() {
 
-			return search ? "item_search.png" : super.getBackgroundImageName();
-		}
+            return search ? "item_search.png" : super.getBackgroundImageName();
+        }
 
-		@Override
-		public int getSearchbarWidth() {
+        @Override
+        public int getSearchbarWidth() {
 
-			return 89;
-		}
+            return 89;
+        }
 
-		@Override
-		public boolean hasSearchBar() {
+        @Override
+        public boolean hasSearchBar() {
 
-			return search;
-		}
-	}
-
-
-	public static final CustomCreativeTab tabChisel = new CustomCreativeTab("tabChisel", false);
-	public static final CustomCreativeTab tabStoneChiselBlocks = new CustomCreativeTab("tabStoneChiselBlocks", true);
-	public static final CustomCreativeTab tabWoodChiselBlocks = new CustomCreativeTab("tabWoodChiselBlocks", true);
-	public static final CustomCreativeTab tabMetalChiselBlocks = new CustomCreativeTab("tabMetalChiselBlocks", true);
-	public static final CustomCreativeTab tabOtherChiselBlocks = new CustomCreativeTab("tabOtherChiselBlocks", true);
-	public static final CustomCreativeTab tabModdedChiselBlocks = new CustomCreativeTab("tabModdedChiselBlocks", true);
-	public static final CustomCreativeTab tabStairChiselBlocks = new CustomCreativeTab("tabStairChiselBlocks", true);
+            return search;
+        }
+    }
 
+    public static final CustomCreativeTab tabChisel = new CustomCreativeTab("tabChisel", false);
+    public static final CustomCreativeTab tabStoneChiselBlocks = new CustomCreativeTab("tabStoneChiselBlocks", true);
+    public static final CustomCreativeTab tabWoodChiselBlocks = new CustomCreativeTab("tabWoodChiselBlocks", true);
+    public static final CustomCreativeTab tabMetalChiselBlocks = new CustomCreativeTab("tabMetalChiselBlocks", true);
+    public static final CustomCreativeTab tabOtherChiselBlocks = new CustomCreativeTab("tabOtherChiselBlocks", true);
+    public static final CustomCreativeTab tabModdedChiselBlocks = new CustomCreativeTab("tabModdedChiselBlocks", true);
+    public static final CustomCreativeTab tabStairChiselBlocks = new CustomCreativeTab("tabStairChiselBlocks", true);
 
 }

src/main/java/com/cricketcraft/chisel/api/FMPIMC.java

@@ -2,21 +2,22 @@ package com.cricketcraft.chisel.api;
 
 import net.minecraft.block.Block;
 import net.minecraft.item.ItemStack;
+
 import cpw.mods.fml.common.event.FMLInterModComms;
 
 public class FMPIMC {
 
-	public static void registerFMP(Block block) {
-		registerFMP(block, 0, 15);
-	}
+    public static void registerFMP(Block block) {
+        registerFMP(block, 0, 15);
+    }
 
-	public static void registerFMP(Block block, int minMeta, int maxMeta) {
-		for (int c = minMeta; c <= maxMeta; c++) {
-			registerFMP(block, c);
-		}
-	}
+    public static void registerFMP(Block block, int minMeta, int maxMeta) {
+        for (int c = minMeta; c <= maxMeta; c++) {
+            registerFMP(block, c);
+        }
+    }
 
-	public static void registerFMP(Block block, int meta) {
-		FMLInterModComms.sendMessage("ForgeMicroblock", "microMaterial", new ItemStack(block, 1, meta));
-	}
+    public static void registerFMP(Block block, int meta) {
+        FMLInterModComms.sendMessage("ForgeMicroblock", "microMaterial", new ItemStack(block, 1, meta));
+    }
 }

src/main/java/com/cricketcraft/chisel/api/IAdvancedChisel.java

@@ -9,25 +9,21 @@ import com.cricketcraft.chisel.api.carving.IChiselMode;
  */
 public interface IAdvancedChisel {
 
-	/**
-	 * Gets the next mode the button in the GUI should switch to given the current mode.
-	 * 
-	 * @param stack
-	 *            The {@link ItemStack} representing the chisel
-	 * @param current
-	 *            The {@link IChiselMode} that is currently active
-	 * @return The next {@link IChiselMode} in the loop
-	 */
-	public IChiselMode getNextMode(ItemStack stack, IChiselMode current);
+    /**
+     * Gets the next mode the button in the GUI should switch to given the current mode.
+     * 
+     * @param stack   The {@link ItemStack} representing the chisel
+     * @param current The {@link IChiselMode} that is currently active
+     * @return The next {@link IChiselMode} in the loop
+     */
+    public IChiselMode getNextMode(ItemStack stack, IChiselMode current);
 
-	/**
-	 * Gets an {@link IChiselMode} instance from a String name
-	 * 
-	 * @param chisel
-	 *            The {@link ItemStack} representing the chisel
-	 * @param name
-	 *            The name of the {@link IChiselMode mode}
-	 * @return An {@link IChiselMode} that has the name {@code name}
-	 */
-	public IChiselMode getMode(ItemStack chisel, String name);
+    /**
+     * Gets an {@link IChiselMode} instance from a String name
+     * 
+     * @param chisel The {@link ItemStack} representing the chisel
+     * @param name   The name of the {@link IChiselMode mode}
+     * @return An {@link IChiselMode} that has the name {@code name}
+     */
+    public IChiselMode getMode(ItemStack chisel, String name);
 }

src/main/java/com/cricketcraft/chisel/api/ICarvable.java

@@ -1,44 +1,42 @@
 package com.cricketcraft.chisel.api;
 
+import net.minecraft.world.IBlockAccess;
+
 import team.chisel.ctmlib.ICTMBlock;
 import team.chisel.ctmlib.ISubmapManager;
-import net.minecraft.world.IBlockAccess;
 
 import com.cricketcraft.chisel.api.carving.CarvableHelper;
 import com.cricketcraft.chisel.api.carving.IVariationInfo;
 
 /**
- * To be implemented on blocks that can be chiseled and need advanced metadata to variation mapping. Currently not very usable without internal classes.
+ * To be implemented on blocks that can be chiseled and need advanced metadata to variation mapping. Currently not very
+ * usable without internal classes.
  */
 public interface ICarvable extends ICTMBlock<IVariationInfo> {
 
-	/**
-	 * Gets a {@link ISubmapManager} from this block, based on metadata.
-	 * <p>
-	 * Typically you can refer this method to {@link CarvableHelper#getVariation(int)} but this method is provided for more complex metadata handling.
-	 * 
-	 * @param metadata
-	 *            The metadata of the block
-	 * @param world
-	 *            {@link IBlockAccess} object, usually a world. Use of {@link IBlockAccess} Is necessary due to this method's use in rendering.
-	 * @param x
-	 *            X coord of the block
-	 * @param y
-	 *            Y coord of the block
-	 * @param z
-	 *            Z coord of the block
-	 * @param metadata
-	 *            The metadata of the block
-	 * @return The {@link ISubmapManager} that represents this block in the world.
-	 */
-	@Override
-	public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata);
+    /**
+     * Gets a {@link ISubmapManager} from this block, based on metadata.
+     * <p>
+     * Typically you can refer this method to {@link CarvableHelper#getVariation(int)} but this method is provided for
+     * more complex metadata handling.
+     * 
+     * @param metadata The metadata of the block
+     * @param world    {@link IBlockAccess} object, usually a world. Use of {@link IBlockAccess} Is necessary due to
+     *                 this method's use in rendering.
+     * @param x        X coord of the block
+     * @param y        Y coord of the block
+     * @param z        Z coord of the block
+     * @param metadata The metadata of the block
+     * @return The {@link ISubmapManager} that represents this block in the world.
+     */
+    @Override
+    public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata);
 
-	/**
-	 * Gets the {@link ISubmapManager} for this block when it is in item form.
-	 * 
-	 * @return A {@link ISubmapManager}
-	 */
-	@Override
-	public IVariationInfo getManager(int meta);
+    /**
+     * Gets the {@link ISubmapManager} for this block when it is in item form.
+     * 
+     * @return A {@link ISubmapManager}
+     */
+    @Override
+    public IVariationInfo getManager(int meta);
 }

src/main/java/com/cricketcraft/chisel/api/IChiselItem.java

@@ -12,74 +12,60 @@ import com.cricketcraft.chisel.api.carving.ICarvingVariation;
  */
 public interface IChiselItem {
 
-	/**
-	 * Checks whether the chisel can have its GUI opened
-	 * 
-	 * @param world
-	 *            {@link World} object
-	 * @param player
-	 *            The player holding the chisel. It can always be assumed that the player's current item will be this.
-	 * @param chisel
-	 *            The {@link ItemStack} representing your chisel
-	 * @return True if the GUI should open. False otherwise.
-	 */
-	boolean canOpenGui(World world, EntityPlayer player, ItemStack chisel);
+    /**
+     * Checks whether the chisel can have its GUI opened
+     * 
+     * @param world  {@link World} object
+     * @param player The player holding the chisel. It can always be assumed that the player's current item will be
+     *               this.
+     * @param chisel The {@link ItemStack} representing your chisel
+     * @return True if the GUI should open. False otherwise.
+     */
+    boolean canOpenGui(World world, EntityPlayer player, ItemStack chisel);
 
-	/**
-	 * Called when an item is chiseled using this chisel
-	 * 
-	 * @param world
-	 *            {@link World} object
-	 * @param chisel
-	 *            The {@link ItemStack} representing the chisel
-	 * @param target
-	 *            The {@link ICarvingVariation} representing the target item
-	 * @return True if the chisel should be damaged. False otherwise.
-	 */
-	boolean onChisel(World world, ItemStack chisel, ICarvingVariation target);
+    /**
+     * Called when an item is chiseled using this chisel
+     * 
+     * @param world  {@link World} object
+     * @param chisel The {@link ItemStack} representing the chisel
+     * @param target The {@link ICarvingVariation} representing the target item
+     * @return True if the chisel should be damaged. False otherwise.
+     */
+    boolean onChisel(World world, ItemStack chisel, ICarvingVariation target);
 
-	/**
-	 * Called to check if this {@link ItemStack} can be chiseled in this chisel. If not, there will be no possible variants displayed in the GUI.
-	 * <p>
-	 * It is not necessary to take into account whether this item <i>has</i> any variants, this method will only be called after that check.
-	 * 
-	 * @param world
-	 *            {@link World} object
-	 * @param chisel
-	 *            The {@link ItemStack} representing the chisel
-	 * @param target
-	 *            The {@link ICarvingVariation} representing the target item
-	 * @return True if the current target can be chiseled into anything. False otherwise.
-	 */
-	boolean canChisel(World world, ItemStack chisel, ICarvingVariation target);
+    /**
+     * Called to check if this {@link ItemStack} can be chiseled in this chisel. If not, there will be no possible
+     * variants displayed in the GUI.
+     * <p>
+     * It is not necessary to take into account whether this item <i>has</i> any variants, this method will only be
+     * called after that check.
+     * 
+     * @param world  {@link World} object
+     * @param chisel The {@link ItemStack} representing the chisel
+     * @param target The {@link ICarvingVariation} representing the target item
+     * @return True if the current target can be chiseled into anything. False otherwise.
+     */
+    boolean canChisel(World world, ItemStack chisel, ICarvingVariation target);
 
-	/**
-	 * Allows you to control if your item can chisel this block in the world.
-	 * 
-	 * @param world
-	 *            World object
-	 * @param player
-	 *            {@link EntityPlayer The player} holding the chisel.
-	 * @param x
-	 *            X coord of the block being chiseled
-	 * @param y
-	 *            Y coord of the block being chiseled
-	 * @param z
-	 *            Z coord of the block being chiseled
-	 * @param block
-	 *            The {@link Block} being chiseled
-	 * @param metadata
-	 *            The blocks' metadata
-	 * @return True if the chiseling should take place. False otherwise.
-	 */
-	boolean canChiselBlock(World world, EntityPlayer player, int x, int y, int z, Block block, int metadata);
+    /**
+     * Allows you to control if your item can chisel this block in the world.
+     * 
+     * @param world    World object
+     * @param player   {@link EntityPlayer The player} holding the chisel.
+     * @param x        X coord of the block being chiseled
+     * @param y        Y coord of the block being chiseled
+     * @param z        Z coord of the block being chiseled
+     * @param block    The {@link Block} being chiseled
+     * @param metadata The blocks' metadata
+     * @return True if the chiseling should take place. False otherwise.
+     */
+    boolean canChiselBlock(World world, EntityPlayer player, int x, int y, int z, Block block, int metadata);
 
-	/**
-	 * Allows you to control if your item has chiseling modes.
-	 * 
-	 * @param chisel
-	 *            The {@link ItemStack} representing the chisel.
-	 * @return True if the chisel supports modes. False otherwise.
-	 */
-	boolean hasModes(ItemStack chisel);
+    /**
+     * Allows you to control if your item has chiseling modes.
+     * 
+     * @param chisel The {@link ItemStack} representing the chisel.
+     * @return True if the chisel supports modes. False otherwise.
+     */
+    boolean hasModes(ItemStack chisel);
 }

src/main/java/com/cricketcraft/chisel/api/IConnectable.java

@@ -7,20 +7,16 @@ import net.minecraft.world.IBlockAccess;
  */
 public interface IConnectable {
 
-	/**
-	 * Determines whether other CTM blocks can connect to this one.
-	 * 
-	 * @param world
-	 * @param x
-	 *            The X position of the block that is connecting to this one. NOT the position of your block.
-	 * @param y
-	 *            The Y position of the block that is connecting to this one. NOT the position of your block.
-	 * @param z
-	 *            The Z position of the block that is connecting to this one. NOT the position of your block.
-	 * @param side
-	 *            The side being drawn.
-	 * @return True if a block can connect to this one from the given direction. False otherwise.
-	 */
-	boolean canConnectCTM(IBlockAccess world, int x, int y, int z, int side);
+    /**
+     * Determines whether other CTM blocks can connect to this one.
+     * 
+     * @param world
+     * @param x     The X position of the block that is connecting to this one. NOT the position of your block.
+     * @param y     The Y position of the block that is connecting to this one. NOT the position of your block.
+     * @param z     The Z position of the block that is connecting to this one. NOT the position of your block.
+     * @param side  The side being drawn.
+     * @return True if a block can connect to this one from the given direction. False otherwise.
+     */
+    boolean canConnectCTM(IBlockAccess world, int x, int y, int z, int side);
 
 }

src/main/java/com/cricketcraft/chisel/api/IFacade.java

@@ -9,41 +9,31 @@ import net.minecraft.world.World;
  */
 public interface IFacade {
 
-	/**
-	 * Gets the block this facade is acting as.
-	 * 
-	 * @param world
-	 *            {@link World}
-	 * @param x
-	 *            X coord of your block
-	 * @param y
-	 *            Y coord of your block
-	 * @param z
-	 *            Z coord of your block
-	 * @param side
-	 *            The side being rendered, NOT the side being connected from.
-	 *            <p>
-	 *            This value can be -1 if no side is specified. Please handle this appropriately.
-	 * @return The block inside of your facade block.
-	 */
-	Block getFacade(IBlockAccess world, int x, int y, int z, int side);
+    /**
+     * Gets the block this facade is acting as.
+     * 
+     * @param world {@link World}
+     * @param x     X coord of your block
+     * @param y     Y coord of your block
+     * @param z     Z coord of your block
+     * @param side  The side being rendered, NOT the side being connected from.
+     *              <p>
+     *              This value can be -1 if no side is specified. Please handle this appropriately.
+     * @return The block inside of your facade block.
+     */
+    Block getFacade(IBlockAccess world, int x, int y, int z, int side);
 
-	/**
-	 * Gets the metadata of the block that this facade is acting as.
-	 * 
-	 * @param world
-	 *            {@link World}
-	 * @param x
-	 *            X coord of your block
-	 * @param y
-	 *            Y coord of your block
-	 * @param z
-	 *            Z coord of your block
-	 * @param side
-	 *            The side being rendered, NOT the side being connected from.
-	 *            <p>
-	 *            This value can be -1 if no side is specified. Please handle this appropriately.
-	 * @return The metadata of your facade block.
-	 */
-	int getFacadeMetadata(IBlockAccess world, int x, int y, int z, int side);
-}
+    /**
+     * Gets the metadata of the block that this facade is acting as.
+     * 
+     * @param world {@link World}
+     * @param x     X coord of your block
+     * @param y     Y coord of your block
+     * @param z     Z coord of your block
+     * @param side  The side being rendered, NOT the side being connected from.
+     *              <p>
+     *              This value can be -1 if no side is specified. Please handle this appropriately.
+     * @return The metadata of your facade block.
+     */
+    int getFacadeMetadata(IBlockAccess world, int x, int y, int z, int side);
+}

src/main/java/com/cricketcraft/chisel/api/IMC.java

@@ -1,64 +1,69 @@
 package com.cricketcraft.chisel.api;
 
 /**
- * Use the enum constants (using {@link #key} or calling {@link #toString()}) in this class as keys for IMC messages sent to chisel
+ * Use the enum constants (using {@link #key} or calling {@link #toString()}) in this class as keys for IMC messages
+ * sent to chisel
  * <p>
  * It is also acceptable to copy the Strings in this class to avoid referencing this API.
  */
 public enum IMC {
 
-	/**
-	 * Adds a variation to a group.
-	 * 
-	 * Use this to add a variation to a group. String syntax:
-	 * <p>
-	 * groupname|blockname|meta
-	 * <p>
-	 * An example would be {@code "mygroup|minecraft:dirt|1"} and this will add the vanilla dirt block with metadata 1 to the "mygroup" group, creating that group if need be.
-	 */
-	ADD_VARIATION("variation:add"),
+    /**
+     * Adds a variation to a group.
+     * 
+     * Use this to add a variation to a group. String syntax:
+     * <p>
+     * groupname|blockname|meta
+     * <p>
+     * An example would be {@code "mygroup|minecraft:dirt|1"} and this will add the vanilla dirt block with metadata 1
+     * to the "mygroup" group, creating that group if need be.
+     */
+    ADD_VARIATION("variation:add"),
 
-	/**
-	 * Removes a variation from a group.
-	 * 
-	 * Use this to remove a variation from a group. String syntax:
-	 * <p>
-	 * groupname|blockname|meta
-	 * <p>
-	 * An example would be {@code "mygroup|minecraft:dirt|1"} and this will add the vanilla dirt block with metadata 1 to the "mygroup" group, creating that group if need be.
-	 */
-	REMOVE_VARIATION("variation:remove"),
+    /**
+     * Removes a variation from a group.
+     * 
+     * Use this to remove a variation from a group. String syntax:
+     * <p>
+     * groupname|blockname|meta
+     * <p>
+     * An example would be {@code "mygroup|minecraft:dirt|1"} and this will add the vanilla dirt block with metadata 1
+     * to the "mygroup" group, creating that group if need be.
+     */
+    REMOVE_VARIATION("variation:remove"),
 
-	/**
-	 * Registers an oredict name to a group. This can be used to automatically add all blocks with this oredict name to a group. String syntax:
-	 * <p>
-	 * groupname|oredictname
-	 * <p>
-	 * An example would be {@code "mygroup|plankWood"} which will add all blocks registered in the oredict as "plankWood" to your group called "mygroup".
-	 */
-	REGISTER_GROUP_ORE("group:ore");
+    /**
+     * Registers an oredict name to a group. This can be used to automatically add all blocks with this oredict name to
+     * a group. String syntax:
+     * <p>
+     * groupname|oredictname
+     * <p>
+     * An example would be {@code "mygroup|plankWood"} which will add all blocks registered in the oredict as
+     * "plankWood" to your group called "mygroup".
+     */
+    REGISTER_GROUP_ORE("group:ore");
 
-	/**
-	 * The IMC message key for this message type.
-	 */
-	public final String key;
+    /**
+     * The IMC message key for this message type.
+     */
+    public final String key;
 
-	IMC(String key) {
-		this.key = key;
-	}
+    IMC(String key) {
+        this.key = key;
+    }
 
-	@Override
-	public String toString() {
-		return key;
-	}
+    @Override
+    public String toString() {
+        return key;
+    }
 
-	/**
-	 * The modid of Chisel so you can easily send IMC to this mod.
-	 */
-	@Deprecated
-	public static final String CHISEL_MODID = "chisel";
+    /**
+     * The modid of Chisel so you can easily send IMC to this mod.
+     */
+    @Deprecated
+    public static final String CHISEL_MODID = "chisel";
 
-	public static final String getModid() {
-		return ChiselAPIProps.MOD_ID;
-	}
+    public static final String getModid() {
+        return ChiselAPIProps.MOD_ID;
+    }
 }

src/main/java/com/cricketcraft/chisel/api/Statistics.java

@@ -6,10 +6,12 @@ import net.minecraft.util.ChatComponentTranslation;
 
 public class Statistics {
 
-	public static StatBase blocksChiseled = (new StatBasic("stat.blockChiseled", new ChatComponentTranslation("stat.blockChiseled", new Object[0])));
+    public static StatBase blocksChiseled = (new StatBasic(
+            "stat.blockChiseled",
+            new ChatComponentTranslation("stat.blockChiseled", new Object[0])));
 
-	public static void init() {
-		blocksChiseled.initIndependentStat();
-		blocksChiseled.registerStat();
-	}
+    public static void init() {
+        blocksChiseled.initIndependentStat();
+        blocksChiseled.registerStat();
+    }
 }

src/main/java/com/cricketcraft/chisel/api/carving/CarvableHelper.java

@@ -14,6 +14,7 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
 import net.minecraftforge.oredict.OreDictionary;
+
 import team.chisel.ctmlib.ISubmapManager;
 
 import com.cricketcraft.chisel.api.ChiselAPIProps;
@@ -27,197 +28,197 @@ import cpw.mods.fml.relauncher.SideOnly;
 
 public class CarvableHelper {
 
-	public static Class<? extends ItemBlock> itemCarvableClass = null;
+    public static Class<? extends ItemBlock> itemCarvableClass = null;
 
-	private Block theBlock;
+    private Block theBlock;
 
-	public ArrayList<IVariationInfo> infoList = new ArrayList<IVariationInfo>();
-	IVariationInfo[] infoMap = new IVariationInfo[16];
-	public boolean forbidChiseling = false;
+    public ArrayList<IVariationInfo> infoList = new ArrayList<IVariationInfo>();
+    IVariationInfo[] infoMap = new IVariationInfo[16];
+    public boolean forbidChiseling = false;
 
-	public CarvableHelper(Block block) {
-		this.theBlock = block;
-	}
+    public CarvableHelper(Block block) {
+        this.theBlock = block;
+    }
 
-	public void addVariation(String description, int metadata, ISubmapManager manager) {
-		addVariation(description, metadata, null, manager);
-	}
+    public void addVariation(String description, int metadata, ISubmapManager manager) {
+        addVariation(description, metadata, null, manager);
+    }
 
-	public void addVariation(String description, int metadata, Block bb) {
-		addVariation(description, metadata, null, bb, 0, ChiselAPIProps.MOD_ID);
-	}
+    public void addVariation(String description, int metadata, Block bb) {
+        addVariation(description, metadata, null, bb, 0, ChiselAPIProps.MOD_ID);
+    }
 
-	public void addVariation(String description, int metadata, Block bb, int blockMeta) {
-		addVariation(description, metadata, null, bb, blockMeta, ChiselAPIProps.MOD_ID);
-	}
+    public void addVariation(String description, int metadata, Block bb, int blockMeta) {
+        addVariation(description, metadata, null, bb, blockMeta, ChiselAPIProps.MOD_ID);
+    }
 
-	public void addVariation(String description, int metadata, Block bb, int blockMeta, Material material) {
-		addVariation(description, metadata, null, bb, blockMeta, ChiselAPIProps.MOD_ID);
-	}
+    public void addVariation(String description, int metadata, Block bb, int blockMeta, Material material) {
+        addVariation(description, metadata, null, bb, blockMeta, ChiselAPIProps.MOD_ID);
+    }
 
-	public void addVariation(String description, int metadata, String texture) {
-		addVariation(description, metadata, texture, (ISubmapManager) null);
-	}
+    public void addVariation(String description, int metadata, String texture) {
+        addVariation(description, metadata, texture, (ISubmapManager) null);
+    }
 
-	public void addVariation(String description, int metadata, String texture, ISubmapManager manager) {
-		addVariation(description, metadata, texture, null, 0, ChiselAPIProps.MOD_ID, manager, metadata);
-	}
+    public void addVariation(String description, int metadata, String texture, ISubmapManager manager) {
+        addVariation(description, metadata, texture, null, 0, ChiselAPIProps.MOD_ID, manager, metadata);
+    }
 
-	public void addVariation(String description, int metadata, Block bb, String modid) {
-		addVariation(description, metadata, null, bb, 0, modid);
-	}
+    public void addVariation(String description, int metadata, Block bb, String modid) {
+        addVariation(description, metadata, null, bb, 0, modid);
+    }
 
-	public void addVariation(String description, int metadata, Block bb, int blockMeta, String modid) {
-		addVariation(description, metadata, null, bb, blockMeta, modid);
-	}
+    public void addVariation(String description, int metadata, Block bb, int blockMeta, String modid) {
+        addVariation(description, metadata, null, bb, blockMeta, modid);
+    }
 
-	public void addVariation(String description, int metadata, Block bb, int blockMeta, Material material, String modid) {
-		addVariation(description, metadata, null, bb, blockMeta, modid);
-	}
+    public void addVariation(String description, int metadata, Block bb, int blockMeta, Material material,
+            String modid) {
+        addVariation(description, metadata, null, bb, blockMeta, modid);
+    }
 
-	public void addVariation(String description, int metadata, String texture, String modid) {
-		addVariation(description, metadata, texture, null, 0, modid);
-	}
+    public void addVariation(String description, int metadata, String texture, String modid) {
+        addVariation(description, metadata, texture, null, 0, modid);
+    }
 
-	public void addVariation(String description, int metadata, String texture, Block block, int blockMeta, String modid) {
-		addVariation(description, metadata, texture, block, blockMeta, modid, null, metadata);
-	}
+    public void addVariation(String description, int metadata, String texture, Block block, int blockMeta,
+            String modid) {
+        addVariation(description, metadata, texture, block, blockMeta, modid, null, metadata);
+    }
 
-	public void addVariation(String description, int metadata, String texture, int order) {
-		addVariation(description, metadata, texture, null, 0, ChiselAPIProps.MOD_ID, (ISubmapManager) null, order);
-	}
+    public void addVariation(String description, int metadata, String texture, int order) {
+        addVariation(description, metadata, texture, null, 0, ChiselAPIProps.MOD_ID, (ISubmapManager) null, order);
+    }
 
-	public void addVariation(String description, int metadata, String texture, Block block, int blockMeta, String modid, ISubmapManager customManager, int order) {
+    public void addVariation(String description, int metadata, String texture, Block block, int blockMeta, String modid,
+            ISubmapManager customManager, int order) {
 
-		if (infoList.size() >= 16)
-			return;
+        if (infoList.size() >= 16) return;
 
-		IVariationInfo info = FMLCommonHandler.instance().getSide().isClient() ? getClientInfo(modid, texture, description, metadata, block, blockMeta, customManager, order) : getServerInfo(modid,
-				texture, description, metadata, block, blockMeta, customManager, order);
+        IVariationInfo info = FMLCommonHandler.instance().getSide().isClient()
+                ? getClientInfo(modid, texture, description, metadata, block, blockMeta, customManager, order)
+                : getServerInfo(modid, texture, description, metadata, block, blockMeta, customManager, order);
 
-		infoList.add(info);
-		infoMap[metadata] = info;
-	}
+        infoList.add(info);
+        infoMap[metadata] = info;
+    }
 
-	private IVariationInfo getClientInfo(String modid, String texture, String description, int metadata, Block block, int blockMeta, ISubmapManager customManager, int order) {
-		ICarvingVariation var = CarvingUtils.getDefaultVariationFor(getBlock(), metadata, order);
-		TextureType type = TextureType.getTypeFor(this, modid, texture);
-		if (type == TextureType.CUSTOM && customManager == null && block == null) {
-			throw new IllegalArgumentException(String.format("Could not find texture %s, and no custom texture manager was provided.", texture));
-		}
+    private IVariationInfo getClientInfo(String modid, String texture, String description, int metadata, Block block,
+            int blockMeta, ISubmapManager customManager, int order) {
+        ICarvingVariation var = CarvingUtils.getDefaultVariationFor(getBlock(), metadata, order);
+        TextureType type = TextureType.getTypeFor(this, modid, texture);
+        if (type == TextureType.CUSTOM && customManager == null && block == null) {
+            throw new IllegalArgumentException(
+                    String.format("Could not find texture %s, and no custom texture manager was provided.", texture));
+        }
 
-		ISubmapManager manager;
-		if (customManager != null) {
-			manager = customManager;
-		} else if (block != null) {
-			manager = type.createManagerFor(var, block, blockMeta);
-		} else {
-			manager = type.createManagerFor(var, texture);
-		}
-		return new VariationInfoBase(var, description, manager, type);
-	}
+        ISubmapManager manager;
+        if (customManager != null) {
+            manager = customManager;
+        } else if (block != null) {
+            manager = type.createManagerFor(var, block, blockMeta);
+        } else {
+            manager = type.createManagerFor(var, texture);
+        }
+        return new VariationInfoBase(var, description, manager, type);
+    }
 
-	private IVariationInfo getServerInfo(String modid, String texture, String description, int metadata, Block block, int blockMeta, ISubmapManager customManager, int order) {
-		ICarvingVariation var = CarvingUtils.getDefaultVariationFor(getBlock(), metadata, order);
-		return new VariationInfoBase(var, description, null);
-	}
+    private IVariationInfo getServerInfo(String modid, String texture, String description, int metadata, Block block,
+            int blockMeta, ISubmapManager customManager, int order) {
+        ICarvingVariation var = CarvingUtils.getDefaultVariationFor(getBlock(), metadata, order);
+        return new VariationInfoBase(var, description, null);
+    }
 
-	public IVariationInfo getVariation(int metadata) {
-		if (metadata < 0 || metadata > 15)
-			metadata = 0;
+    public IVariationInfo getVariation(int metadata) {
+        if (metadata < 0 || metadata > 15) metadata = 0;
 
-		IVariationInfo info = infoMap[metadata];
-		if (info == null)
-			return null;
+        IVariationInfo info = infoMap[metadata];
+        if (info == null) return null;
 
-		return info;
-	}
+        return info;
+    }
 
-	public IIcon getIcon(int side, int metadata) {
-		if (metadata < 0 || metadata > 15)
-			metadata = 0;
+    public IIcon getIcon(int side, int metadata) {
+        if (metadata < 0 || metadata > 15) metadata = 0;
 
-		IVariationInfo info = infoMap[metadata];
-		if (info == null)
-			return getMissingIcon();
+        IVariationInfo info = infoMap[metadata];
+        if (info == null) return getMissingIcon();
 
-		return info.getIcon(side, metadata);
-	}
+        return info.getIcon(side, metadata);
+    }
 
-	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
-		int metadata = world.getBlockMetadata(x, y, z);
+    public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+        int metadata = world.getBlockMetadata(x, y, z);
 
-		if (metadata < 0 || metadata > 15)
-			metadata = 0;
+        if (metadata < 0 || metadata > 15) metadata = 0;
 
-		IVariationInfo info = infoMap[metadata];
-		if (info == null)
-			return getMissingIcon();
+        IVariationInfo info = infoMap[metadata];
+        if (info == null) return getMissingIcon();
 
-		return info.getIcon(world, x, y, z, side);
-	}
+        return info.getIcon(world, x, y, z, side);
+    }
 
-	public void registerAll(Block block, String name) {
-		registerAll(block, name, itemCarvableClass);
-	}
+    public void registerAll(Block block, String name) {
+        registerAll(block, name, itemCarvableClass);
+    }
 
-	public void registerBlock(Block block, String name) {
-		registerBlock(block, name, itemCarvableClass);
-	}
+    public void registerBlock(Block block, String name) {
+        registerBlock(block, name, itemCarvableClass);
+    }
 
-	void registerBlock(Block block, String name, Class<? extends ItemBlock> cl) {
-		block.setBlockName("chisel." + name);
-		GameRegistry.registerBlock(block, cl, name);
-	}
+    void registerBlock(Block block, String name, Class<? extends ItemBlock> cl) {
+        block.setBlockName("chisel." + name);
+        GameRegistry.registerBlock(block, cl, name);
+    }
 
-	public void registerAll(Block block, String name, Class<? extends ItemBlock> cl) {
-		registerBlock(block, name, cl);
-		registerVariations(name);
-	}
+    public void registerAll(Block block, String name, Class<? extends ItemBlock> cl) {
+        registerBlock(block, name, cl);
+        registerVariations(name);
+    }
 
-	public void registerVariations(String name) {
-		for (IVariationInfo info : infoList) {
-			registerVariation(name, info);
-		}
-	}
+    public void registerVariations(String name) {
+        for (IVariationInfo info : infoList) {
+            registerVariation(name, info);
+        }
+    }
 
-	public void registerVariation(String name, IVariationInfo info) {
+    public void registerVariation(String name, IVariationInfo info) {
 
-		Block block = info.getVariation().getBlock();
+        Block block = info.getVariation().getBlock();
 
-		if (block.renderAsNormalBlock() || block.isOpaqueCube() || block.isNormalCube()) {
-			FMPIMC.registerFMP(block, info.getVariation().getBlockMeta());
-		}
+        if (block.renderAsNormalBlock() || block.isOpaqueCube() || block.isNormalCube()) {
+            FMPIMC.registerFMP(block, info.getVariation().getBlockMeta());
+        }
 
-		if (forbidChiseling)
-			return;
+        if (forbidChiseling) return;
 
-		CarvingUtils.getChiselRegistry().addVariation(name, info.getVariation());
-	}
+        CarvingUtils.getChiselRegistry().addVariation(name, info.getVariation());
+    }
 
-	@SideOnly(Side.CLIENT)
-	public void registerBlockIcons(String modName, Block block, IIconRegister register) {
-		for (IVariationInfo info : infoList) {
-			info.registerIcons(modName, block, register);
-		}
-	}
+    @SideOnly(Side.CLIENT)
+    public void registerBlockIcons(String modName, Block block, IIconRegister register) {
+        for (IVariationInfo info : infoList) {
+            info.registerIcons(modName, block, register);
+        }
+    }
 
-	public void registerSubBlocks(Block block, CreativeTabs tabs, List<ItemStack> list) {
-		for (IVariationInfo info : infoList) {
-			list.add(new ItemStack(block, 1, info.getVariation().getItemMeta()));
-		}
-	}
+    public void registerSubBlocks(Block block, CreativeTabs tabs, List<ItemStack> list) {
+        for (IVariationInfo info : infoList) {
+            list.add(new ItemStack(block, 1, info.getVariation().getItemMeta()));
+        }
+    }
 
-	public void registerOre(String ore) {
-		OreDictionary.registerOre(ore, getBlock());
-	}
+    public void registerOre(String ore) {
+        OreDictionary.registerOre(ore, getBlock());
+    }
 
-	@SideOnly(Side.CLIENT)
-	public IIcon getMissingIcon() {
-		return ((TextureMap) Minecraft.getMinecraft().getTextureManager().getTexture(TextureMap.locationBlocksTexture)).getAtlasSprite("missingno");
-	}
-	
-	public Block getBlock() {
-		return theBlock;
-	}
+    @SideOnly(Side.CLIENT)
+    public IIcon getMissingIcon() {
+        return ((TextureMap) Minecraft.getMinecraft().getTextureManager().getTexture(TextureMap.locationBlocksTexture))
+                .getAtlasSprite("missingno");
+    }
+
+    public Block getBlock() {
+        return theBlock;
+    }
 }

src/main/java/com/cricketcraft/chisel/api/carving/CarvingUtils.java

@@ -11,166 +11,163 @@ import com.google.common.collect.Lists;
 
 public class CarvingUtils {
 
-	/**
-	 * A simple way to compare two {@link ICarvingVariation} objects based on the {@link ICarvingVariation#getOrder() getOrder()} method.
-	 * 
-	 * @param v1
-	 *            The first {@link ICarvingVariation variation}.
-	 * @param v2
-	 *            The second {@link ICarvingVariation variation}.
-	 * @return A positive integer if the first's order is greater, a negative integer if the second's is greater, and 0 if they are equal.
-	 */
-	public static int compare(ICarvingVariation v1, ICarvingVariation v2) {
-		return v1.getOrder() - v2.getOrder();
-	}
+    /**
+     * A simple way to compare two {@link ICarvingVariation} objects based on the {@link ICarvingVariation#getOrder()
+     * getOrder()} method.
+     * 
+     * @param v1 The first {@link ICarvingVariation variation}.
+     * @param v2 The second {@link ICarvingVariation variation}.
+     * @return A positive integer if the first's order is greater, a negative integer if the second's is greater, and 0
+     *         if they are equal.
+     */
+    public static int compare(ICarvingVariation v1, ICarvingVariation v2) {
+        return v1.getOrder() - v2.getOrder();
+    }
 
-	/**
-	 * Gets an {@link ItemStack} representing the passed {@link ICarvingVariation}.
-	 * 
-	 * @param variation
-	 *            An {@link ICarvingVariation}
-	 * @return An {@link ItemStack}
-	 */
-	public static ItemStack getStack(ICarvingVariation variation) {
-		return new ItemStack(variation.getBlock(), 1, variation.getItemMeta());
-	}
+    /**
+     * Gets an {@link ItemStack} representing the passed {@link ICarvingVariation}.
+     * 
+     * @param variation An {@link ICarvingVariation}
+     * @return An {@link ItemStack}
+     */
+    public static ItemStack getStack(ICarvingVariation variation) {
+        return new ItemStack(variation.getBlock(), 1, variation.getItemMeta());
+    }
 
-	public static ICarvingRegistry chisel;
+    public static ICarvingRegistry chisel;
 
-	/**
-	 * @return The instance of the chisel carving registry from the chisel mod.
-	 *         <p>
-	 *         If chisel is not installed this will return null.
-	 */
-	public static ICarvingRegistry getChiselRegistry() {
-		return chisel;
-	}
+    /**
+     * @return The instance of the chisel carving registry from the chisel mod.
+     *         <p>
+     *         If chisel is not installed this will return null.
+     */
+    public static ICarvingRegistry getChiselRegistry() {
+        return chisel;
+    }
 
-	/**
-	 * Creates a standard {@link ICarvingVariation} for the given data. Use this if you do not need any custom behavior in your own variation.
-	 * 
-	 * @param block
-	 *            The block of the variation
-	 * @param metadata
-	 *            The metadata of both the block and item
-	 * @param order
-	 *            The sorting order.
-	 * @return A standard {@link ICarvingVariation} instance.
-	 */
-	public static ICarvingVariation getDefaultVariationFor(Block block, int metadata, int order) {
-		return new SimpleCarvingVariation(block, metadata, order);
-	}
+    /**
+     * Creates a standard {@link ICarvingVariation} for the given data. Use this if you do not need any custom behavior
+     * in your own variation.
+     * 
+     * @param block    The block of the variation
+     * @param metadata The metadata of both the block and item
+     * @param order    The sorting order.
+     * @return A standard {@link ICarvingVariation} instance.
+     */
+    public static ICarvingVariation getDefaultVariationFor(Block block, int metadata, int order) {
+        return new SimpleCarvingVariation(block, metadata, order);
+    }
 
-	/**
-	 * Creates a standard {@link ICarvingGroup} for the given name. Use this if you do not need any custom behavior in your own group.
-	 * 
-	 * @param name
-	 *            The name of the group.
-	 * @return A standard {@link ICarvingGroup} instance.
-	 */
-	public static ICarvingGroup getDefaultGroupFor(String name) {
-		return new SimpleCarvingGroup(name);
-	}
+    /**
+     * Creates a standard {@link ICarvingGroup} for the given name. Use this if you do not need any custom behavior in
+     * your own group.
+     * 
+     * @param name The name of the group.
+     * @return A standard {@link ICarvingGroup} instance.
+     */
+    public static ICarvingGroup getDefaultGroupFor(String name) {
+        return new SimpleCarvingGroup(name);
+    }
 
-	public static class SimpleCarvingVariation implements ICarvingVariation {
+    public static class SimpleCarvingVariation implements ICarvingVariation {
 
-		private int order;
-		private Block block;
-		private int meta;
-		private int damage;
+        private int order;
+        private Block block;
+        private int meta;
+        private int damage;
 
-		public SimpleCarvingVariation(Block block, int metadata, int order) {
-			this.order = order;
-			this.block = block;
-			this.meta = metadata;
-			this.damage = metadata;
-		}
+        public SimpleCarvingVariation(Block block, int metadata, int order) {
+            this.order = order;
+            this.block = block;
+            this.meta = metadata;
+            this.damage = metadata;
+        }
 
-		@Override
-		public Block getBlock() {
-			return block;
-		}
+        @Override
+        public Block getBlock() {
+            return block;
+        }
 
-		@Override
-		public int getBlockMeta() {
-			return meta;
-		}
+        @Override
+        public int getBlockMeta() {
+            return meta;
+        }
 
-		@Override
-		public int getItemMeta() {
-			return damage;
-		}
+        @Override
+        public int getItemMeta() {
+            return damage;
+        }
 
-		@Override
-		public int getOrder() {
-			return order;
-		}
-	}
+        @Override
+        public int getOrder() {
+            return order;
+        }
+    }
 
-	public static class SimpleCarvingGroup implements ICarvingGroup {
+    public static class SimpleCarvingGroup implements ICarvingGroup {
 
-		private String name;
-		private String sound;
-		private String oreName;
+        private String name;
+        private String sound;
+        private String oreName;
 
-		private List<ICarvingVariation> variations = Lists.newArrayList();
+        private List<ICarvingVariation> variations = Lists.newArrayList();
 
-		public SimpleCarvingGroup(String name) {
-			this.name = name;
-		}
+        public SimpleCarvingGroup(String name) {
+            this.name = name;
+        }
 
-		@Override
-		public List<ICarvingVariation> getVariations() {
-			return Lists.newArrayList(variations);
-		}
+        @Override
+        public List<ICarvingVariation> getVariations() {
+            return Lists.newArrayList(variations);
+        }
 
-		@Override
-		public void addVariation(ICarvingVariation variation) {
-			variations.add(variation);
-			Collections.sort(variations, new Comparator<ICarvingVariation>() {
+        @Override
+        public void addVariation(ICarvingVariation variation) {
+            variations.add(variation);
+            Collections.sort(variations, new Comparator<ICarvingVariation>() {
 
-				@Override
-				public int compare(ICarvingVariation o1, ICarvingVariation o2) {
-					return CarvingUtils.compare(o1, o2);
-				}
-			});
-		}
+                @Override
+                public int compare(ICarvingVariation o1, ICarvingVariation o2) {
+                    return CarvingUtils.compare(o1, o2);
+                }
+            });
+        }
 
-		@Override
-		public boolean removeVariation(ICarvingVariation variation) {
-			ICarvingVariation toRemove = null;
-			for (ICarvingVariation v : variations) {
-				if (v.getBlock() == variation.getBlock() && v.getBlockMeta() == variation.getBlockMeta()) {
-					toRemove = v;
-				}
-			}
-			return toRemove == null ? false : variations.remove(toRemove);
-		}
+        @Override
+        public boolean removeVariation(ICarvingVariation variation) {
+            ICarvingVariation toRemove = null;
+            for (ICarvingVariation v : variations) {
+                if (v.getBlock() == variation.getBlock() && v.getBlockMeta() == variation.getBlockMeta()) {
+                    toRemove = v;
+                }
+            }
+            return toRemove == null ? false : variations.remove(toRemove);
+        }
 
-		@Override
-		public String getName() {
-			return name;
-		}
+        @Override
+        public String getName() {
+            return name;
+        }
 
-		@Override
-		public String getSound() {
-			return sound;
-		}
+        @Override
+        public String getSound() {
+            return sound;
+        }
 
-		@Override
-		public void setSound(String sound) {
-			this.sound = sound;
-		}
+        @Override
+        public void setSound(String sound) {
+            this.sound = sound;
+        }
 
-		@Override
-		public String getOreName() {
-			return oreName;
-		}
+        @Override
+        public String getOreName() {
+            return oreName;
+        }
 
-		@Override
-		public void setOreName(String oreName) {
-			this.oreName = oreName;
-		}
-	}
+        @Override
+        public void setOreName(String oreName) {
+            this.oreName = oreName;
+        }
+    }
 
 }

src/main/java/com/cricketcraft/chisel/api/carving/ICarvingGroup.java

@@ -5,70 +5,69 @@ import java.util.List;
 /**
  * Represents a group of chiselable blocks.
  * <p>
- * This is an object that contains a collection of {@link ICarvingVariation} objects, and keeps them sorted. You may sort them in any way (or not at all), and {@link ICarvingVariation#getOrder()} will
- * likely be of use to do so.
+ * This is an object that contains a collection of {@link ICarvingVariation} objects, and keeps them sorted. You may
+ * sort them in any way (or not at all), and {@link ICarvingVariation#getOrder()} will likely be of use to do so.
  * <p>
  * It also defines what sound and oredict name the group as a whole has.
  */
 public interface ICarvingGroup {
 
-	/**
-	 * The name of this group. Used for internal identification.
-	 * 
-	 * @return A string name for the group
-	 */
-	String getName();
+    /**
+     * The name of this group. Used for internal identification.
+     * 
+     * @return A string name for the group
+     */
+    String getName();
 
-	/**
-	 * Can return null. If null, fallback sound will be used (the standard chisel sound).
-	 * 
-	 * @return The string resource path of the sound to use for chiseling items in this group
-	 */
-	String getSound();
+    /**
+     * Can return null. If null, fallback sound will be used (the standard chisel sound).
+     * 
+     * @return The string resource path of the sound to use for chiseling items in this group
+     */
+    String getSound();
 
-	/**
-	 * Sets the sound of this group
-	 * 
-	 * @param sound
-	 *            A string resource path for the sound this group makes when chiseled
-	 */
-	void setSound(String sound);
+    /**
+     * Sets the sound of this group
+     * 
+     * @param sound A string resource path for the sound this group makes when chiseled
+     */
+    void setSound(String sound);
 
-	/**
-	 * The oredict name to match to this group. All items with this oredict name will be assumed to be part of this group.
-	 * 
-	 * @return An ore dictionary name
-	 */
-	String getOreName();
+    /**
+     * The oredict name to match to this group. All items with this oredict name will be assumed to be part of this
+     * group.
+     * 
+     * @return An ore dictionary name
+     */
+    String getOreName();
 
-	/**
-	 * Sets the oredict name for this group.
-	 * 
-	 * @param oreName
-	 *            The String oredict name to be associated with this group.
-	 */
-	void setOreName(String oreName);
+    /**
+     * Sets the oredict name for this group.
+     * 
+     * @param oreName The String oredict name to be associated with this group.
+     */
+    void setOreName(String oreName);
 
-	/**
-	 * Gets all carving variations associated with this group.
-	 * 
-	 * @return A {@link List} of {@link ICarvingVariation}s
-	 */
-	List<ICarvingVariation> getVariations();
+    /**
+     * Gets all carving variations associated with this group.
+     * 
+     * @return A {@link List} of {@link ICarvingVariation}s
+     */
+    List<ICarvingVariation> getVariations();
 
-	/**
-	 * Adds a variation to this group. Do not call this from external code, as it will fail to remove the inverse lookup from the registry.
-	 * 
-	 * @param variation
-	 *            An {@link ICarvingVariation} to add to this group
-	 */
-	void addVariation(ICarvingVariation variation);
+    /**
+     * Adds a variation to this group. Do not call this from external code, as it will fail to remove the inverse lookup
+     * from the registry.
+     * 
+     * @param variation An {@link ICarvingVariation} to add to this group
+     */
+    void addVariation(ICarvingVariation variation);
 
-	/**
-	 * Removes a variation to this group. Do not call this from external code, as it will fail to remove the inverse lookup from the registry.
-	 * 
-	 * @param variation
-	 *            An {@link ICarvingVariation} to add to this group
-	 */
-	boolean removeVariation(ICarvingVariation variation);
+    /**
+     * Removes a variation to this group. Do not call this from external code, as it will fail to remove the inverse
+     * lookup from the registry.
+     * 
+     * @param variation An {@link ICarvingVariation} to add to this group
+     */
+    boolean removeVariation(ICarvingVariation variation);
 }

src/main/java/com/cricketcraft/chisel/api/carving/ICarvingRegistry.java

@@ -14,191 +14,168 @@ import net.minecraft.world.World;
  */
 public interface ICarvingRegistry {
 
-	/* Getters */
+    /* Getters */
 
-	/**
-	 * Finds the group the block/meta pair belongs to in the registry.
-	 * 
-	 * @param block
-	 *            The block of the variation
-	 * @param meta
-	 *            The metadata of the variation
-	 * @return The {@link ICarvingGroup} that the block/meta pair belongs to
-	 */
-	ICarvingGroup getGroup(Block block, int meta);
+    /**
+     * Finds the group the block/meta pair belongs to in the registry.
+     * 
+     * @param block The block of the variation
+     * @param meta  The metadata of the variation
+     * @return The {@link ICarvingGroup} that the block/meta pair belongs to
+     */
+    ICarvingGroup getGroup(Block block, int meta);
 
-	/**
-	 * Gets an {@link ICarvingGroup} by its name.
-	 * 
-	 * @param name
-	 *            The name of the group
-	 * @return An {@link ICarvingGroup}
-	 */
-	ICarvingGroup getGroup(String name);
+    /**
+     * Gets an {@link ICarvingGroup} by its name.
+     * 
+     * @param name The name of the group
+     * @return An {@link ICarvingGroup}
+     */
+    ICarvingGroup getGroup(String name);
 
-	/**
-	 * Gets the {@link ICarvingVariation} instance represented by this block/meta pair.
-	 * 
-	 * @param block
-	 *            The block of the variatoin
-	 * @param meta
-	 *            The metadata of the variation
-	 * @return The {@link ICarvingVariation} containing this block/meta pair
-	 */
-	ICarvingVariation getVariation(Block block, int meta);
+    /**
+     * Gets the {@link ICarvingVariation} instance represented by this block/meta pair.
+     * 
+     * @param block The block of the variatoin
+     * @param meta  The metadata of the variation
+     * @return The {@link ICarvingVariation} containing this block/meta pair
+     */
+    ICarvingVariation getVariation(Block block, int meta);
 
-	/**
-	 * Gets the list of {@link ICarvingVariation}s from the group that contains this block/meta pair.
-	 * 
-	 * @param block
-	 *            The block of the variation
-	 * @param meta
-	 *            The metadata of the variation
-	 * @return All of the {@link ICarvingVariation}s in the group that contains this block/meta pair
-	 */
-	List<ICarvingVariation> getGroupVariations(Block block, int meta);
+    /**
+     * Gets the list of {@link ICarvingVariation}s from the group that contains this block/meta pair.
+     * 
+     * @param block The block of the variation
+     * @param meta  The metadata of the variation
+     * @return All of the {@link ICarvingVariation}s in the group that contains this block/meta pair
+     */
+    List<ICarvingVariation> getGroupVariations(Block block, int meta);
 
-	/**
-	 * Gets the oredict name for the group that contains this block/meta pair.
-	 * 
-	 * @param block
-	 *            The block of the variation
-	 * @param meta
-	 *            The metadata of the variation
-	 * @return A string oredict name for the group
-	 */
-	String getOreName(Block block, int meta);
+    /**
+     * Gets the oredict name for the group that contains this block/meta pair.
+     * 
+     * @param block The block of the variation
+     * @param meta  The metadata of the variation
+     * @return A string oredict name for the group
+     */
+    String getOreName(Block block, int meta);
 
-	/**
-	 * Gets the possible output items for this {@link ItemStack}. To be used for machines/GUIs that chisel items.
-	 * 
-	 * @param chiseled
-	 *            The {@link ItemStack} being chiseled
-	 * @return A list of stacks that can be chiseled from the passed {@link ItemStack stack}
-	 */
-	List<ItemStack> getItemsForChiseling(ItemStack chiseled);
+    /**
+     * Gets the possible output items for this {@link ItemStack}. To be used for machines/GUIs that chisel items.
+     * 
+     * @param chiseled The {@link ItemStack} being chiseled
+     * @return A list of stacks that can be chiseled from the passed {@link ItemStack stack}
+     */
+    List<ItemStack> getItemsForChiseling(ItemStack chiseled);
 
-	/**
-	 * Gets the sound resource string for the group represented by this block/meta pair.
-	 * 
-	 * @param block
-	 *            The block of the variation
-	 * @param metadata
-	 *            The metadata of the variation
-	 * @return The string resource for the sound that can be used in {@link World#playSound(double, double, double, String, float, float, boolean)} and other methods.
-	 */
-	public String getVariationSound(Block block, int metadata);
+    /**
+     * Gets the sound resource string for the group represented by this block/meta pair.
+     * 
+     * @param block    The block of the variation
+     * @param metadata The metadata of the variation
+     * @return The string resource for the sound that can be used in
+     *         {@link World#playSound(double, double, double, String, float, float, boolean)} and other methods.
+     */
+    public String getVariationSound(Block block, int metadata);
 
-	/**
-	 * Gets the sound resource string for the group represented by this item/meta pair.
-	 * <p>
-	 * Mostly a convenience for calling {@link #getVariationSound(Block, int)} with {@link Block#getBlockFromItem(Item)}.
-	 * 
-	 * @param item
-	 *            The item of the variation
-	 * @param metadata
-	 *            The metadata of the variation
-	 * @return The string resource for the sound that can be used in {@link World#playSound(double, double, double, String, float, float, boolean)} and other methods.
-	 */
-	public String getVariationSound(Item item, int metadata);
+    /**
+     * Gets the sound resource string for the group represented by this item/meta pair.
+     * <p>
+     * Mostly a convenience for calling {@link #getVariationSound(Block, int)} with
+     * {@link Block#getBlockFromItem(Item)}.
+     * 
+     * @param item     The item of the variation
+     * @param metadata The metadata of the variation
+     * @return The string resource for the sound that can be used in
+     *         {@link World#playSound(double, double, double, String, float, float, boolean)} and other methods.
+     */
+    public String getVariationSound(Item item, int metadata);
 
-	/**
-	 * @return A list of all registered group names, sorted alphabetically.
-	 */
-	List<String> getSortedGroupNames();
+    /**
+     * @return A list of all registered group names, sorted alphabetically.
+     */
+    List<String> getSortedGroupNames();
 
-	/* Setters */
+    /* Setters */
 
-	/**
-	 * Adds a variation to the registry.
-	 * 
-	 * @param groupName
-	 *            The name of the group to add to.
-	 * @param block
-	 *            The block of the variation
-	 * @param metadata
-	 *            The metadata of the variation
-	 * @param order
-	 *            The order of the variation in the list of all variations in the group. Higher numbers are sorted at the end.
-	 */
-	void addVariation(String groupName, Block block, int metadata, int order);
+    /**
+     * Adds a variation to the registry.
+     * 
+     * @param groupName The name of the group to add to.
+     * @param block     The block of the variation
+     * @param metadata  The metadata of the variation
+     * @param order     The order of the variation in the list of all variations in the group. Higher numbers are sorted
+     *                  at the end.
+     */
+    void addVariation(String groupName, Block block, int metadata, int order);
 
-	/**
-	 * Adds a variation to the registry.
-	 * 
-	 * @param groupName
-	 *            The name of the group to add to
-	 * @param variation
-	 *            The {@link ICarvingVariation} to add
-	 */
-	void addVariation(String groupName, ICarvingVariation variation);
+    /**
+     * Adds a variation to the registry.
+     * 
+     * @param groupName The name of the group to add to
+     * @param variation The {@link ICarvingVariation} to add
+     */
+    void addVariation(String groupName, ICarvingVariation variation);
 
-	/**
-	 * Adds a group to the registry.
-	 * 
-	 * @param group
-	 *            The {@link ICarvingGroup} to add.
-	 */
-	void addGroup(ICarvingGroup group);
+    /**
+     * Adds a group to the registry.
+     * 
+     * @param group The {@link ICarvingGroup} to add.
+     */
+    void addGroup(ICarvingGroup group);
 
-	/**
-	 * Removes a group from the registry.
-	 * <p>
-	 * This in effect removes all variations associated with the group, though they are not explicitly removed from the object. If you maintain a reference to the {@link ICarvingGroup} that is
-	 * removed, it will still contain its variations.
-	 * 
-	 * @param groupName
-	 *            The name of the group to remove.
-	 * @return The {@link ICarvingGroup} that was removed.
-	 */
-	ICarvingGroup removeGroup(String groupName);
+    /**
+     * Removes a group from the registry.
+     * <p>
+     * This in effect removes all variations associated with the group, though they are not explicitly removed from the
+     * object. If you maintain a reference to the {@link ICarvingGroup} that is removed, it will still contain its
+     * variations.
+     * 
+     * @param groupName The name of the group to remove.
+     * @return The {@link ICarvingGroup} that was removed.
+     */
+    ICarvingGroup removeGroup(String groupName);
 
-	/**
-	 * Removes a varaition with the passed {@link Block} and metadata from the registry. If this variation is registered with mutiple groups, it will remove it from all of them.
-	 * 
-	 * @param block
-	 *            The {@link Block} of the {@link ICarvingVariation variation}
-	 * @param metadata
-	 *            The metadata of the {@link ICarvingVariation variation}
-	 * @return The ICarvingVariation that was removed. Null if nothing was removed.
-	 */
-	ICarvingVariation removeVariation(Block block, int metadata);
+    /**
+     * Removes a varaition with the passed {@link Block} and metadata from the registry. If this variation is registered
+     * with mutiple groups, it will remove it from all of them.
+     * 
+     * @param block    The {@link Block} of the {@link ICarvingVariation variation}
+     * @param metadata The metadata of the {@link ICarvingVariation variation}
+     * @return The ICarvingVariation that was removed. Null if nothing was removed.
+     */
+    ICarvingVariation removeVariation(Block block, int metadata);
 
-	/**
-	 * Removes a varaition with the passed {@link Block} and metadata from the registry, but only from the specified {@link ICarvingGroup} name.
-	 * 
-	 * @param block
-	 *            The {@link Block} of the {@link ICarvingVariation variation}
-	 * @param metadata
-	 *            The metadata of the {@link ICarvingVariation variation}
-	 * @param group
-	 *            The name of the group that the variation should be removed from
-	 * @return The ICarvingVariation that was removed. Null if nothing was removed.
-	 */
-	ICarvingVariation removeVariation(Block block, int metadata, String group);
+    /**
+     * Removes a varaition with the passed {@link Block} and metadata from the registry, but only from the specified
+     * {@link ICarvingGroup} name.
+     * 
+     * @param block    The {@link Block} of the {@link ICarvingVariation variation}
+     * @param metadata The metadata of the {@link ICarvingVariation variation}
+     * @param group    The name of the group that the variation should be removed from
+     * @return The ICarvingVariation that was removed. Null if nothing was removed.
+     */
+    ICarvingVariation removeVariation(Block block, int metadata, String group);
 
-	/**
-	 * Registers a group to an oredict name.
-	 * <p>
-	 * Doing this means that all blocks that are registered to this oredict name will act as if they are a part of this group.
-	 * 
-	 * @param groupName
-	 *            The name of the group
-	 * @param oreName
-	 *            The oredict name
-	 */
-	void registerOre(String groupName, String oreName);
+    /**
+     * Registers a group to an oredict name.
+     * <p>
+     * Doing this means that all blocks that are registered to this oredict name will act as if they are a part of this
+     * group.
+     * 
+     * @param groupName The name of the group
+     * @param oreName   The oredict name
+     */
+    void registerOre(String groupName, String oreName);
 
-	/**
-	 * Sets the sound resource for a group.
-	 * <p>
-	 * This is the sound that is used when a block from this group is chiseled. <br/>
-	 * Does <i>not</i> need to be explicitly set.
-	 * 
-	 * @param name
-	 *            The name of the group
-	 * @param sound
-	 *            The resource string for the sound
-	 */
-	void setVariationSound(String name, String sound);
+    /**
+     * Sets the sound resource for a group.
+     * <p>
+     * This is the sound that is used when a block from this group is chiseled. <br/>
+     * Does <i>not</i> need to be explicitly set.
+     * 
+     * @param name  The name of the group
+     * @param sound The resource string for the sound
+     */
+    void setVariationSound(String name, String sound);
 }

src/main/java/com/cricketcraft/chisel/api/carving/ICarvingVariation.java

@@ -8,31 +8,31 @@ import net.minecraft.item.Item;
  */
 public interface ICarvingVariation {
 
-	/**
-	 * The base block of this variation.
-	 * 
-	 * @return A {@link Block} that is the base of this variation
-	 */
-	Block getBlock();
+    /**
+     * The base block of this variation.
+     * 
+     * @return A {@link Block} that is the base of this variation
+     */
+    Block getBlock();
 
-	/**
-	 * The metadata of this variation
-	 * 
-	 * @return An int representing the metadata of this variation's {@link Block} in the world.
-	 */
-	int getBlockMeta();
+    /**
+     * The metadata of this variation
+     * 
+     * @return An int representing the metadata of this variation's {@link Block} in the world.
+     */
+    int getBlockMeta();
 
-	/**
-	 * The item metadata of this variation
-	 * 
-	 * @return An int representing the metadata of this variations's {@link Item}.
-	 */
-	int getItemMeta();
+    /**
+     * The item metadata of this variation
+     * 
+     * @return An int representing the metadata of this variations's {@link Item}.
+     */
+    int getItemMeta();
 
-	/**
-	 * The "order" of this variation. Represents its position in the list of variations held by a group.
-	 * 
-	 * @return An integer to represent the position of this variation in the list of all variations in the group
-	 */
-	int getOrder();
+    /**
+     * The "order" of this variation. Represents its position in the list of variations held by a group.
+     * 
+     * @return An integer to represent the position of this variation in the list of all variations in the group
+     */
+    int getOrder();
 }

src/main/java/com/cricketcraft/chisel/api/carving/IChiselMode.java

@@ -6,15 +6,17 @@ import net.minecraftforge.common.util.ForgeDirection;
 
 public interface IChiselMode {
 
-	/**
-	 * NOTE: This method is responsible for increasing the "Blocks Chiseled" statistic found in the Statistics class.
-	 */
-	void chiselAll(EntityPlayer player, World world, int x, int y, int z, ForgeDirection side, ICarvingVariation variation);
+    /**
+     * NOTE: This method is responsible for increasing the "Blocks Chiseled" statistic found in the Statistics class.
+     */
+    void chiselAll(EntityPlayer player, World world, int x, int y, int z, ForgeDirection side,
+            ICarvingVariation variation);
 
-	/**
-	 * Implemented implicitly by enums. If your IChiselMode is not an enum constant, this needs to be implemented explicitly.
-	 * 
-	 * @return The name of the mode.
-	 */
-	String name();
+    /**
+     * Implemented implicitly by enums. If your IChiselMode is not an enum constant, this needs to be implemented
+     * explicitly.
+     * 
+     * @return The name of the mode.
+     */
+    String name();
 }

src/main/java/com/cricketcraft/chisel/api/carving/IVariationInfo.java

@@ -6,9 +6,9 @@ import com.cricketcraft.chisel.api.rendering.TextureType;
 
 public interface IVariationInfo extends ISubmapManager {
 
-	ICarvingVariation getVariation();
+    ICarvingVariation getVariation();
 
-	String getDescription();
+    String getDescription();
 
-	TextureType getType();
+    TextureType getType();
 }

src/main/java/com/cricketcraft/chisel/api/carving/VariationInfoBase.java

@@ -1,6 +1,5 @@
 package com.cricketcraft.chisel.api.carving;
 
-import team.chisel.ctmlib.ISubmapManager;
 import net.minecraft.block.Block;
 import net.minecraft.client.renderer.RenderBlocks;
 import net.minecraft.client.renderer.texture.IIconRegister;
@@ -9,70 +8,72 @@ import net.minecraft.util.StatCollector;
 import net.minecraft.world.IBlockAccess;
 import net.minecraftforge.common.util.ForgeDirection;
 
+import team.chisel.ctmlib.ISubmapManager;
+
 import com.cricketcraft.chisel.api.rendering.TextureType;
 
 public class VariationInfoBase implements IVariationInfo {
 
-	private ICarvingVariation variation;
-	private String unlocDesc;
-	private ISubmapManager manager;
-	private TextureType type;
+    private ICarvingVariation variation;
+    private String unlocDesc;
+    private ISubmapManager manager;
+    private TextureType type;
 
-	public VariationInfoBase(ICarvingVariation variation, String unlocDesc, ISubmapManager manager) {
-		this(variation, unlocDesc, manager, TextureType.CUSTOM);
-	}
+    public VariationInfoBase(ICarvingVariation variation, String unlocDesc, ISubmapManager manager) {
+        this(variation, unlocDesc, manager, TextureType.CUSTOM);
+    }
 
-	public VariationInfoBase(ICarvingVariation variation, String unlocDesc, ISubmapManager manager, TextureType type) {
-		this.variation = variation;
-		this.unlocDesc = unlocDesc;
-		this.manager = manager;
-		this.type = type;
-	}
+    public VariationInfoBase(ICarvingVariation variation, String unlocDesc, ISubmapManager manager, TextureType type) {
+        this.variation = variation;
+        this.unlocDesc = unlocDesc;
+        this.manager = manager;
+        this.type = type;
+    }
 
-	@Override
-	public ICarvingVariation getVariation() {
-		return variation;
-	}
+    @Override
+    public ICarvingVariation getVariation() {
+        return variation;
+    }
 
-	@Override
-	public String getDescription() {
-		return StatCollector.translateToLocal(unlocDesc);
-	}
+    @Override
+    public String getDescription() {
+        return StatCollector.translateToLocal(unlocDesc);
+    }
 
-	@Override
-	public TextureType getType() {
-		return type;
-	}
+    @Override
+    public TextureType getType() {
+        return type;
+    }
 
-	// ISubmapManager delegation
+    // ISubmapManager delegation
 
-	@Override
-	public IIcon getIcon(int side, int meta) {
-		return manager.getIcon(side, meta);
-	}
+    @Override
+    public IIcon getIcon(int side, int meta) {
+        return manager.getIcon(side, meta);
+    }
 
-	@Override
-	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
-		return manager.getIcon(world, x, y, z, side);
-	}
+    @Override
+    public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+        return manager.getIcon(world, x, y, z, side);
+    }
 
-	@Override
-	public void registerIcons(String modName, Block block, IIconRegister register) {
-		manager.registerIcons(modName, block, register);
-	}
+    @Override
+    public void registerIcons(String modName, Block block, IIconRegister register) {
+        manager.registerIcons(modName, block, register);
+    }
 
-	@Override
-	public RenderBlocks createRenderContext(RenderBlocks rendererOld, Block block, IBlockAccess world) {
-		return manager.createRenderContext(rendererOld, block, world);
-	}
+    @Override
+    public RenderBlocks createRenderContext(RenderBlocks rendererOld, Block block, IBlockAccess world) {
+        return manager.createRenderContext(rendererOld, block, world);
+    }
 
-	@Override
-	public void preRenderSide(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, ForgeDirection side) {
-		manager.preRenderSide(renderer, world, x, y, z, side);
-	}
+    @Override
+    public void preRenderSide(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, ForgeDirection side) {
+        manager.preRenderSide(renderer, world, x, y, z, side);
+    }
 
-	@Override
-	public void postRenderSide(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, ForgeDirection side) {
-		manager.postRenderSide(renderer, world, x, y, z, side);
-	}
+    @Override
+    public void postRenderSide(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, ForgeDirection side) {
+        manager.postRenderSide(renderer, world, x, y, z, side);
+    }
 }

src/main/java/com/cricketcraft/chisel/api/carving/package-info.java

@@ -2,6 +2,4 @@
 package com.cricketcraft.chisel.api.carving;
 
 import com.cricketcraft.chisel.api.ChiselAPIProps;
-
 import cpw.mods.fml.common.API;
-

src/main/java/com/cricketcraft/chisel/api/package-info.java

@@ -2,4 +2,3 @@
 package com.cricketcraft.chisel.api;
 
 import cpw.mods.fml.common.API;
-

src/main/java/com/cricketcraft/chisel/api/rendering/ClientUtils.java

@@ -2,6 +2,6 @@ package com.cricketcraft.chisel.api.rendering;
 
 public class ClientUtils {
 
-	public static int renderCTMId;
+    public static int renderCTMId;
 
 }

src/main/java/com/cricketcraft/chisel/api/rendering/TextureType.java

@@ -33,7 +33,7 @@ import cpw.mods.fml.relauncher.SideOnly;
 @SuppressWarnings("unchecked")
 public enum TextureType {
 
-	// @formatter:off
+    // @formatter:off
 	TOPBOTSIDE("top", "bottom", "side"){
 		@Override
 		protected Object registerIcons(ICarvingVariation variation, String modName, String texturePath, IIconRegister register) {

src/main/java/com/cricketcraft/chisel/api/rendering/package-info.java

@@ -2,6 +2,4 @@
 package com.cricketcraft.chisel.api.rendering;
 
 import com.cricketcraft.chisel.api.ChiselAPIProps;
-
 import cpw.mods.fml.common.API;
-

src/main/java/team/chisel/BlockNameConversion.java

@@ -2,107 +2,110 @@ package team.chisel;
 
 import java.util.HashMap;
 
-import team.chisel.utils.General;
 import net.minecraft.block.Block;
 import net.minecraft.item.Item;
+
+import team.chisel.utils.General;
 import cpw.mods.fml.common.FMLLog;
 import cpw.mods.fml.common.registry.GameRegistry;
 
 public class BlockNameConversion {
 
-	static final private HashMap<String, String> namingConversion = new HashMap<String, String>();
+    static final private HashMap<String, String> namingConversion = new HashMap<String, String>();
 
-	public static class NameConversions {
+    public static class NameConversions {
 
-		public final static int MAX = 5;
+        public final static int MAX = 5;
 
-		protected static String conversion(String oldname, int step) {
-			oldname = General.cleanTags(oldname);
-			String newname = null;
-			switch (step) {
-			case 0: // lookup list
-				return namingConversion.get(oldname);
-			case 1: // remove Chisel:
-				if (oldname.startsWith("Chisel:")) {
-					newname = oldname.replaceAll("(?i)" + "Chisel:", "");
-				}
-				return newname;
-			case 2: // rename "marbleSlab" -> "marble_slab", "redstone" ->
-					// "redstone_block"
-				newname = oldname.replaceAll("([a-z]+)([A-Z])", "$1_$2").toLowerCase();
+        protected static String conversion(String oldname, int step) {
+            oldname = General.cleanTags(oldname);
+            String newname = null;
+            switch (step) {
+                case 0: // lookup list
+                    return namingConversion.get(oldname);
+                case 1: // remove Chisel:
+                    if (oldname.startsWith("Chisel:")) {
+                        newname = oldname.replaceAll("(?i)" + "Chisel:", "");
+                    }
+                    return newname;
+                case 2: // rename "marbleSlab" -> "marble_slab", "redstone" ->
+                        // "redstone_block"
+                    newname = oldname.replaceAll("([a-z]+)([A-Z])", "$1_$2").toLowerCase();
 
-				if (newname.startsWith("block_")) {
-					newname = newname.replaceFirst("block_([a-z_]+)", "$1_block");
-				} else if (newname.startsWith("snakestone_")) {
-					newname = newname.replaceFirst("snakestone_([a-z_]+)", "$1_snakestone");
-				}
-				return newname;
-			case 3: // rename "wood-dark-oak" -> "dark_oak_planks"
-				newname = oldname.replaceAll("([a-z]+)([A-Z])", "$1_$2").toLowerCase().replace('-', '_');
-				if (newname.contains("wood_")) {
-					newname = newname.replaceFirst("wood_([a-z_]+)", "$1_planks");
-				}
-				return newname;
-			case (MAX - 1): // ALWAYS last: rename "blockYxx" -> "yxx" (e.g.
-							// "dirt" -> "dirt").
-				// This can be dangerous in cases like "carpet" (a block) ->
-				// "carpet" (NO block)
-				return oldname.replaceAll("([a-z]+)([A-Z])", "$1_$2").toLowerCase().replaceFirst("block_", "");
-			default:
-				throw new IndexOutOfBoundsException("conversion got invalid parameter step=" + step);
-			}
-		}
-	}
+                    if (newname.startsWith("block_")) {
+                        newname = newname.replaceFirst("block_([a-z_]+)", "$1_block");
+                    } else if (newname.startsWith("snakestone_")) {
+                        newname = newname.replaceFirst("snakestone_([a-z_]+)", "$1_snakestone");
+                    }
+                    return newname;
+                case 3: // rename "wood-dark-oak" -> "dark_oak_planks"
+                    newname = oldname.replaceAll("([a-z]+)([A-Z])", "$1_$2").toLowerCase().replace('-', '_');
+                    if (newname.contains("wood_")) {
+                        newname = newname.replaceFirst("wood_([a-z_]+)", "$1_planks");
+                    }
+                    return newname;
+                case (MAX - 1): // ALWAYS last: rename "blockYxx" -> "yxx" (e.g.
+                                // "dirt" -> "dirt").
+                    // This can be dangerous in cases like "carpet" (a block) ->
+                    // "carpet" (NO block)
+                    return oldname.replaceAll("([a-z]+)([A-Z])", "$1_$2").toLowerCase().replaceFirst("block_", "");
+                default:
+                    throw new IndexOutOfBoundsException("conversion got invalid parameter step=" + step);
+            }
+        }
+    }
 
-	static public void init() {
-		namingConversion.put("blockCobble", "cobblestone");
-		namingConversion.put("iron", "iron_block");
-		namingConversion.put("gold", "gold_block");
-		namingConversion.put("diamond", "diamond_block");
-		namingConversion.put("lightstone", "glowstone");
-		namingConversion.put("lapis", "lapis_block");
-		namingConversion.put("emerald", "emerald_block");
-		namingConversion.put("hellrock", "netherrack");
-		namingConversion.put("stoneMoss", "mossy_cobblestone");
-		namingConversion.put("stoneBrick", "stonebrick");
-		namingConversion.put("fenceIron", "iron_bars");
-		namingConversion.put("fantasy", "fantasyblock");
-		namingConversion.put("carpetFloor", "carpet");
-		namingConversion.put("temple", "templeblock");
-		namingConversion.put("templeMossy", "mossy_templeblock");
-		namingConversion.put("factory", "factoryblock");
-		namingConversion.put("laboratory", "laboratoryblock");
-		// "LightGray" is unfortunately converted to "light_gray"
-		namingConversion.put("stainedGlassLightGray", "stained_glass_lightgray");
-		namingConversion.put("stainedGlassPaneLightGray", "stained_glass_pane_lightgray");
-		namingConversion.put("blockTemple", "templeblock");
-		namingConversion.put("stoneBrick", "stonebricksmooth");
-		namingConversion.put("blockTempleMossy", "mossy_templeblock");
-		namingConversion.put("blockFactory", "factoryblock");
-		namingConversion.put("blockFft", "fantasyblock");
-		namingConversion.put("blockCarpetFloor", "carpet");
-		namingConversion.put("blockLaboratory", "laboratoryblock");
-	}
+    static public void init() {
+        namingConversion.put("blockCobble", "cobblestone");
+        namingConversion.put("iron", "iron_block");
+        namingConversion.put("gold", "gold_block");
+        namingConversion.put("diamond", "diamond_block");
+        namingConversion.put("lightstone", "glowstone");
+        namingConversion.put("lapis", "lapis_block");
+        namingConversion.put("emerald", "emerald_block");
+        namingConversion.put("hellrock", "netherrack");
+        namingConversion.put("stoneMoss", "mossy_cobblestone");
+        namingConversion.put("stoneBrick", "stonebrick");
+        namingConversion.put("fenceIron", "iron_bars");
+        namingConversion.put("fantasy", "fantasyblock");
+        namingConversion.put("carpetFloor", "carpet");
+        namingConversion.put("temple", "templeblock");
+        namingConversion.put("templeMossy", "mossy_templeblock");
+        namingConversion.put("factory", "factoryblock");
+        namingConversion.put("laboratory", "laboratoryblock");
+        // "LightGray" is unfortunately converted to "light_gray"
+        namingConversion.put("stainedGlassLightGray", "stained_glass_lightgray");
+        namingConversion.put("stainedGlassPaneLightGray", "stained_glass_pane_lightgray");
+        namingConversion.put("blockTemple", "templeblock");
+        namingConversion.put("stoneBrick", "stonebricksmooth");
+        namingConversion.put("blockTempleMossy", "mossy_templeblock");
+        namingConversion.put("blockFactory", "factoryblock");
+        namingConversion.put("blockFft", "fantasyblock");
+        namingConversion.put("blockCarpetFloor", "carpet");
+        namingConversion.put("blockLaboratory", "laboratoryblock");
+    }
 
-	public static Item findItem(String oldname) {
-		FMLLog.getLogger().trace("[Chisel 2] findItem() START " + oldname);
-		Item item = null;
-		for (int i = 0; i < NameConversions.MAX && item == null; i++) {
-			FMLLog.getLogger().trace("[Chisel 2] findItem()       Checking for " + NameConversions.conversion(oldname, i));
-			item = GameRegistry.findItem(Chisel.MOD_ID, NameConversions.conversion(oldname, i));
-		}
+    public static Item findItem(String oldname) {
+        FMLLog.getLogger().trace("[Chisel 2] findItem() START " + oldname);
+        Item item = null;
+        for (int i = 0; i < NameConversions.MAX && item == null; i++) {
+            FMLLog.getLogger()
+                    .trace("[Chisel 2] findItem()       Checking for " + NameConversions.conversion(oldname, i));
+            item = GameRegistry.findItem(Chisel.MOD_ID, NameConversions.conversion(oldname, i));
+        }
 
-		return item;
-	}
+        return item;
+    }
 
-	public static Block findBlock(String oldname) {
-		FMLLog.getLogger().trace("[Chisel 2] findBlock() START: " + oldname);
-		Block block = null;
-		for (int i = 0; i < NameConversions.MAX && block == null; i++) {
-			FMLLog.getLogger().trace("[Chisel 2] findBlock()       Checking for " + NameConversions.conversion(oldname, i));
-			block = GameRegistry.findBlock(Chisel.MOD_ID, NameConversions.conversion(oldname, i));
-		}
+    public static Block findBlock(String oldname) {
+        FMLLog.getLogger().trace("[Chisel 2] findBlock() START: " + oldname);
+        Block block = null;
+        for (int i = 0; i < NameConversions.MAX && block == null; i++) {
+            FMLLog.getLogger()
+                    .trace("[Chisel 2] findBlock()       Checking for " + NameConversions.conversion(oldname, i));
+            block = GameRegistry.findBlock(Chisel.MOD_ID, NameConversions.conversion(oldname, i));
+        }
 
-		return block;
-	}
-}
+        return block;
+    }
+}

src/main/java/team/chisel/Chisel.java

@@ -53,149 +53,159 @@ import cpw.mods.fml.common.registry.EntityRegistry;
 import cpw.mods.fml.common.registry.GameRegistry;
 import cpw.mods.fml.common.registry.GameRegistry.Type;
 
-@Mod(modid = Chisel.MOD_ID, name = Chisel.MOD_NAME, version = Chisel.VERSION, guiFactory = "team.chisel.client.gui.GuiFactory", dependencies = "after:EE3;after:ForgeMultipart;after:Thaumcraft;after:appliedenergistics2;after:Railcraft;after:AWWayofTime;after:TwilightForest")
+@Mod(
+        modid = Chisel.MOD_ID,
+        name = Chisel.MOD_NAME,
+        version = Chisel.VERSION,
+        guiFactory = "team.chisel.client.gui.GuiFactory",
+        dependencies = "after:EE3;after:ForgeMultipart;after:Thaumcraft;after:appliedenergistics2;after:Railcraft;after:AWWayofTime;after:TwilightForest")
 public class Chisel {
 
-	public static final String MOD_ID = "chisel";
-	public static final BlockCarvable.SoundType soundTempleFootstep = new BlockCarvable.SoundType("dig.stone", MOD_ID + ":step.templeblock", 1.0f, 1.0f);
-	public static final String MOD_NAME = "Chisel";
-	public static final String VERSION = "GRADLETOKEN_VERSION";
-	public static final BlockCarvable.SoundType soundHolystoneFootstep = new BlockCarvable.SoundType("holystone", 1.0f, 1.0f);
-	public static final BlockCarvable.SoundType soundMetalFootstep = new BlockCarvable.SoundType("metal", 1.0f, 1.0f);
-	public static boolean multipartLoaded = false;
-	public static boolean gtnhLoaded = false;
-	public static int renderEldritchId;
-	public static int renderAutoChiselId;
-	public static int renderGlowId;
-	public static int renderLayeredId;
-	public static int roadLineId;
+    public static final String MOD_ID = "chisel";
+    public static final BlockCarvable.SoundType soundTempleFootstep = new BlockCarvable.SoundType(
+            "dig.stone",
+            MOD_ID + ":step.templeblock",
+            1.0f,
+            1.0f);
+    public static final String MOD_NAME = "Chisel";
+    public static final String VERSION = "GRADLETOKEN_VERSION";
+    public static final BlockCarvable.SoundType soundHolystoneFootstep = new BlockCarvable.SoundType(
+            "holystone",
+            1.0f,
+            1.0f);
+    public static final BlockCarvable.SoundType soundMetalFootstep = new BlockCarvable.SoundType("metal", 1.0f, 1.0f);
+    public static boolean multipartLoaded = false;
+    public static boolean gtnhLoaded = false;
+    public static int renderEldritchId;
+    public static int renderAutoChiselId;
+    public static int renderGlowId;
+    public static int renderLayeredId;
+    public static int roadLineId;
 
-	public static final Logger logger = LogManager.getLogger(MOD_NAME);
+    public static final Logger logger = LogManager.getLogger(MOD_NAME);
 
-	@Instance(MOD_ID)
-	public static Chisel instance;
+    @Instance(MOD_ID)
+    public static Chisel instance;
 
-	public Chisel() {
-		ChiselAPIProps.MOD_ID = MOD_ID;
-		CarvableHelper.itemCarvableClass = ItemCarvable.class;
-		Carving.construct();
-	}
+    public Chisel() {
+        ChiselAPIProps.MOD_ID = MOD_ID;
+        CarvableHelper.itemCarvableClass = ItemCarvable.class;
+        Carving.construct();
+    }
 
-	@SidedProxy(clientSide = "team.chisel.proxy.ClientProxy", serverSide = "team.chisel.proxy.CommonProxy")
-	public static CommonProxy proxy;
+    @SidedProxy(clientSide = "team.chisel.proxy.ClientProxy", serverSide = "team.chisel.proxy.CommonProxy")
+    public static CommonProxy proxy;
 
-	@EventHandler
-	public void missingMapping(FMLMissingMappingsEvent event) {
-		BlockNameConversion.init();
+    @EventHandler
+    public void missingMapping(FMLMissingMappingsEvent event) {
+        BlockNameConversion.init();
 
-		for (MissingMapping m : event.get()) {
-			// This bug was introduced along with Chisel 1.5.2, and was fixed in
-			// 1.5.3.
-			// Ice Stairs were called null.0-7 instead of other names, and
-			// Marble/Limestone stairs did not exist.
-			// This fixes the bug.
-			if (m.name.startsWith("null.") && m.name.length() == 6 && m.type == Type.BLOCK) {
-				m.warn();// (Action.WARN);
-			}
+        for (MissingMapping m : event.get()) {
+            // This bug was introduced along with Chisel 1.5.2, and was fixed in
+            // 1.5.3.
+            // Ice Stairs were called null.0-7 instead of other names, and
+            // Marble/Limestone stairs did not exist.
+            // This fixes the bug.
+            if (m.name.startsWith("null.") && m.name.length() == 6 && m.type == Type.BLOCK) {
+                m.warn();// (Action.WARN);
+            }
 
-			// Fix mapping of snakestoneSand, snakestoneStone, limestoneStairs,
-			// marbleStairs when loading an old (1.5.4) save
-			else if (m.type == Type.BLOCK) {
-				final Block block = BlockNameConversion.findBlock(m.name);
+            // Fix mapping of snakestoneSand, snakestoneStone, limestoneStairs,
+            // marbleStairs when loading an old (1.5.4) save
+            else if (m.type == Type.BLOCK) {
+                final Block block = BlockNameConversion.findBlock(m.name);
 
-				if (block != null) {
-					m.remap(block);
-					FMLLog.getLogger().info("Remapping block " + m.name + " to " + General.getName(block));
-				} else
-					FMLLog.getLogger().warn("Block " + m.name + " could not get remapped.");
-			} else if (m.type == Type.ITEM) {
-				final Item item = BlockNameConversion.findItem(m.name);
+                if (block != null) {
+                    m.remap(block);
+                    FMLLog.getLogger().info("Remapping block " + m.name + " to " + General.getName(block));
+                } else FMLLog.getLogger().warn("Block " + m.name + " could not get remapped.");
+            } else if (m.type == Type.ITEM) {
+                final Item item = BlockNameConversion.findItem(m.name);
 
-				if (item != null) {
-					m.remap(item);
-					FMLLog.getLogger().info("Remapping item " + m.name + " to " + General.getName(item));
+                if (item != null) {
+                    m.remap(item);
+                    FMLLog.getLogger().info("Remapping item " + m.name + " to " + General.getName(item));
 
-				} else
-					FMLLog.getLogger().warn("Item " + m.name + " could not get remapped.");
-			}
-		}
-	}
+                } else FMLLog.getLogger().warn("Item " + m.name + " could not get remapped.");
+            }
+        }
+    }
 
-	@EventHandler
-	public void preInit(FMLPreInitializationEvent event) {
-		FMLCommonHandler.instance().registerCrashCallable(new ChiselCrashCallable());
-		
-		File configFile = event.getSuggestedConfigurationFile();
-		Configurations.configExists = configFile.exists();
-		Configurations.config = new Configuration(configFile);
-		Configurations.config.load();
-		Configurations.refreshConfig();
+    @EventHandler
+    public void preInit(FMLPreInitializationEvent event) {
+        FMLCommonHandler.instance().registerCrashCallable(new ChiselCrashCallable());
+
+        File configFile = event.getSuggestedConfigurationFile();
+        Configurations.configExists = configFile.exists();
+        Configurations.config = new Configuration(configFile);
+        Configurations.config.load();
+        Configurations.refreshConfig();
 
         if (Loader.isModLoaded("dreamcraft")) {
             gtnhLoaded = true;
         }
-		TabsInit.preInit();
-		Features.preInit();
-		Statistics.init();
-		PacketHandler.init();
-		ChiselController.INSTANCE.preInit();
-		if (Loader.isModLoaded("ForgeMultipart")) {
-			new FMPCompat().init();
-		}
-		proxy.preInit();
-	}
+        TabsInit.preInit();
+        Features.preInit();
+        Statistics.init();
+        PacketHandler.init();
+        ChiselController.INSTANCE.preInit();
+        if (Loader.isModLoaded("ForgeMultipart")) {
+            new FMPCompat().init();
+        }
+        proxy.preInit();
+    }
 
-	@EventHandler
-	public void init(FMLInitializationEvent event) {
-		Features.init();
+    @EventHandler
+    public void init(FMLInitializationEvent event) {
+        Features.init();
 
-		NetworkRegistry.INSTANCE.registerGuiHandler(this, new ChiselGuiHandler());
+        NetworkRegistry.INSTANCE.registerGuiHandler(this, new ChiselGuiHandler());
 
-		addWorldgen(Features.MARBLE, ChiselBlocks.marble, Configurations.marbleAmount);
-		addWorldgen(Features.LIMESTONE, ChiselBlocks.limestone, Configurations.limestoneAmount);
-		addWorldgen(Features.ANDESITE, ChiselBlocks.andesite, Configurations.andesiteAmount, 40, 100, 0.5);
-		addWorldgen(Features.GRANITE, ChiselBlocks.granite, Configurations.graniteAmount, 40, 100, 0.5);
-		addWorldgen(Features.DIORITE, ChiselBlocks.diorite, Configurations.dioriteAmount, 40, 100, 0.5);
-		GameRegistry.registerWorldGenerator(GeneratorChisel.INSTANCE, 1000);
+        addWorldgen(Features.MARBLE, ChiselBlocks.marble, Configurations.marbleAmount);
+        addWorldgen(Features.LIMESTONE, ChiselBlocks.limestone, Configurations.limestoneAmount);
+        addWorldgen(Features.ANDESITE, ChiselBlocks.andesite, Configurations.andesiteAmount, 40, 100, 0.5);
+        addWorldgen(Features.GRANITE, ChiselBlocks.granite, Configurations.graniteAmount, 40, 100, 0.5);
+        addWorldgen(Features.DIORITE, ChiselBlocks.diorite, Configurations.dioriteAmount, 40, 100, 0.5);
+        GameRegistry.registerWorldGenerator(GeneratorChisel.INSTANCE, 1000);
 
-		EntityRegistry.registerModEntity(EntityChiselSnowman.class, "snowman", 0, this, 80, 1, true);
+        EntityRegistry.registerModEntity(EntityChiselSnowman.class, "snowman", 0, this, 80, 1, true);
 
-		proxy.init();
-		MinecraftForge.EVENT_BUS.register(this);
-		FMLCommonHandler.instance().bus().register(instance);
+        proxy.init();
+        MinecraftForge.EVENT_BUS.register(this);
+        FMLCommonHandler.instance().bus().register(instance);
 
-		FMLInterModComms.sendMessage("Waila", "register", "team.chisel.compat.WailaCompat.register");
-	}
+        FMLInterModComms.sendMessage("Waila", "register", "team.chisel.compat.WailaCompat.register");
+    }
 
-	private void addWorldgen(Features feature, Block block, double... data) {
-		if (feature.enabled()) {
-			if (data.length == 1) {
-				GeneratorChisel.INSTANCE.addFeature(block, 32, (int) data[0]);
-			} else if (data.length > 1 && data.length < 4) {
-				GeneratorChisel.INSTANCE.addFeature(block, 32, (int) data[0], (int) data[1], (int) data[2]);
-			} else if (data.length == 4) {
-				GeneratorChisel.INSTANCE.addFeature(block, 32, (int) data[0], (int) data[1], (int) data[2], data[3]);
-			}
-		}
-	}
+    private void addWorldgen(Features feature, Block block, double... data) {
+        if (feature.enabled()) {
+            if (data.length == 1) {
+                GeneratorChisel.INSTANCE.addFeature(block, 32, (int) data[0]);
+            } else if (data.length > 1 && data.length < 4) {
+                GeneratorChisel.INSTANCE.addFeature(block, 32, (int) data[0], (int) data[1], (int) data[2]);
+            } else if (data.length == 4) {
+                GeneratorChisel.INSTANCE.addFeature(block, 32, (int) data[0], (int) data[1], (int) data[2], data[3]);
+            }
+        }
+    }
 
-	@EventHandler
-	public void postInit(FMLPostInitializationEvent event) {
-		TabsInit.postInit();
-		Compatibility.init(event);
-	}
+    @EventHandler
+    public void postInit(FMLPostInitializationEvent event) {
+        TabsInit.postInit();
+        Compatibility.init(event);
+    }
 
-	@EventHandler
-	public void onIMC(IMCEvent event) {
-		for (IMCMessage msg : event.getMessages()) {
-			IMCHandler.INSTANCE.handleMessage(msg);
-		}
-	}
+    @EventHandler
+    public void onIMC(IMCEvent event) {
+        for (IMCMessage msg : event.getMessages()) {
+            IMCHandler.INSTANCE.handleMessage(msg);
+        }
+    }
 
-	@SubscribeEvent
-	public void onConfigChanged(ConfigChangedEvent.OnConfigChangedEvent event) {
-		if (event.modID.equals("chisel")) {
-			Configurations.refreshConfig();
-		}
-	}
+    @SubscribeEvent
+    public void onConfigChanged(ConfigChangedEvent.OnConfigChangedEvent event) {
+        if (event.modID.equals("chisel")) {
+            Configurations.refreshConfig();
+        }
+    }
 }

src/main/java/team/chisel/ChiselCrashCallable.java

@@ -4,14 +4,14 @@ import cpw.mods.fml.common.ICrashCallable;
 
 public class ChiselCrashCallable implements ICrashCallable {
 
-	@Override
-	public String call() throws Exception {
-		return "Errors like \"[FML]: Unable to lookup ...\" are NOT the cause of this crash. "
-				+ "You can safely ignore these errors. And update forge while you're at it.";
-	}
+    @Override
+    public String call() throws Exception {
+        return "Errors like \"[FML]: Unable to lookup ...\" are NOT the cause of this crash. "
+                + "You can safely ignore these errors. And update forge while you're at it.";
+    }
 
-	@Override
-	public String getLabel() {
-		return Chisel.MOD_NAME;
-	}
+    @Override
+    public String getLabel() {
+        return Chisel.MOD_NAME;
+    }
 }

src/main/java/team/chisel/block/BlockAutoChisel.java

@@ -1,7 +1,5 @@
 package team.chisel.block;
 
-import team.chisel.Chisel;
-import team.chisel.block.tileentity.TileEntityAutoChisel;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockContainer;
 import net.minecraft.block.material.Material;
@@ -10,67 +8,70 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.world.World;
 
+import team.chisel.Chisel;
+import team.chisel.block.tileentity.TileEntityAutoChisel;
+
 public class BlockAutoChisel extends BlockContainer {
 
-	public BlockAutoChisel() {
-		super(Material.rock);
-		setHardness(1F);
-		setBlockBounds(0.125f, 0, 0.125f, 0.875f, 0.8125f, 0.875f);
-	}
+    public BlockAutoChisel() {
+        super(Material.rock);
+        setHardness(1F);
+        setBlockBounds(0.125f, 0, 0.125f, 0.875f, 0.8125f, 0.875f);
+    }
 
-	@Override
-	public int getRenderType() {
-		return Chisel.renderAutoChiselId;
-	}
+    @Override
+    public int getRenderType() {
+        return Chisel.renderAutoChiselId;
+    }
 
-	@Override
-	public boolean isOpaqueCube() {
-		return false;
-	}
+    @Override
+    public boolean isOpaqueCube() {
+        return false;
+    }
 
-	@Override
-	public boolean renderAsNormalBlock() {
-		return false;
-	}
+    @Override
+    public boolean renderAsNormalBlock() {
+        return false;
+    }
 
-	@Override
-	public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int metadata, float x1, float y1, float z1) {
-		TileEntity tile = world.getTileEntity(x, y, z);
-		if (world.isRemote)
-			return true;
+    @Override
+    public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int metadata, float x1,
+            float y1, float z1) {
+        TileEntity tile = world.getTileEntity(x, y, z);
+        if (world.isRemote) return true;
 
-		if (tile != null && tile instanceof TileEntityAutoChisel && !player.isSneaking()) {
-			player.openGui(Chisel.instance, 1, world, x, y, z);
-		}
+        if (tile != null && tile instanceof TileEntityAutoChisel && !player.isSneaking()) {
+            player.openGui(Chisel.instance, 1, world, x, y, z);
+        }
 
-		return true;
-	}
+        return true;
+    }
 
-	@Override
-	public void breakBlock(World world, int x, int y, int z, Block block, int par6) {
-		dropItems(world, x, y, z);
-		super.breakBlock(world, x, y, z, block, par6);
-	}
+    @Override
+    public void breakBlock(World world, int x, int y, int z, Block block, int par6) {
+        dropItems(world, x, y, z);
+        super.breakBlock(world, x, y, z, block, par6);
+    }
 
-	private void dropItems(World world, int x, int y, int z) {
-		TileEntity tileEntity = world.getTileEntity(x, y, z);
+    private void dropItems(World world, int x, int y, int z) {
+        TileEntity tileEntity = world.getTileEntity(x, y, z);
 
-		if (!(tileEntity instanceof TileEntityAutoChisel)) {
-			return;
-		}
+        if (!(tileEntity instanceof TileEntityAutoChisel)) {
+            return;
+        }
 
-		TileEntityAutoChisel inventory = (TileEntityAutoChisel) world.getTileEntity(x, y, z);
+        TileEntityAutoChisel inventory = (TileEntityAutoChisel) world.getTileEntity(x, y, z);
 
-		for (int c = 0; c < inventory.getSizeInventory(); c++) {
-			ItemStack stack = inventory.getStackInSlot(c);
-			if (stack != null) {
-				dropBlockAsItem(world, x, y, z, stack);
-			}
-		}
-	}
+        for (int c = 0; c < inventory.getSizeInventory(); c++) {
+            ItemStack stack = inventory.getStackInSlot(c);
+            if (stack != null) {
+                dropBlockAsItem(world, x, y, z, stack);
+            }
+        }
+    }
 
-	@Override
-	public TileEntity createNewTileEntity(World var1, int var2) {
-		return new TileEntityAutoChisel();
-	}
+    @Override
+    public TileEntity createNewTileEntity(World var1, int var2) {
+        return new TileEntityAutoChisel();
+    }
 }

src/main/java/team/chisel/block/BlockBeaconBase.java

@@ -8,16 +8,16 @@ import net.minecraft.world.IBlockAccess;
  */
 public class BlockBeaconBase extends BlockCarvable {
 
-	public BlockBeaconBase() {
-		super();
-	}
+    public BlockBeaconBase() {
+        super();
+    }
 
-	public BlockBeaconBase(Material mat) {
-		super(mat);
-	}
+    public BlockBeaconBase(Material mat) {
+        super(mat);
+    }
 
-	@Override
-	public boolean isBeaconBase(IBlockAccess worldObj, int x, int y, int z, int beaconX, int beaconY, int beaconZ) {
-		return true;
-	}
+    @Override
+    public boolean isBeaconBase(IBlockAccess worldObj, int x, int y, int z, int beaconX, int beaconY, int beaconZ) {
+        return true;
+    }
 }

src/main/java/team/chisel/block/BlockCarvable.java

@@ -2,13 +2,6 @@ package team.chisel.block;
 
 import java.util.List;
 
-import com.cricketcraft.chisel.api.ICarvable;
-import com.cricketcraft.chisel.api.carving.CarvableHelper;
-import com.cricketcraft.chisel.api.carving.IVariationInfo;
-import com.cricketcraft.chisel.api.rendering.ClientUtils;
-
-import team.chisel.Chisel;
-import com.cricketcraft.chisel.api.ChiselTabs;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.texture.IIconRegister;
@@ -16,167 +9,163 @@ import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.item.Item;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
+
+import team.chisel.Chisel;
+
+import com.cricketcraft.chisel.api.ChiselTabs;
+import com.cricketcraft.chisel.api.ICarvable;
+import com.cricketcraft.chisel.api.carving.CarvableHelper;
+import com.cricketcraft.chisel.api.carving.IVariationInfo;
+import com.cricketcraft.chisel.api.rendering.ClientUtils;
+
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class BlockCarvable extends Block implements ICarvable {
 
-	public CarvableHelper carverHelper;
-	private boolean isAlpha;
+    public CarvableHelper carverHelper;
+    private boolean isAlpha;
 
-	public BlockCarvable() {
-		this(Material.rock);
-	}
+    public BlockCarvable() {
+        this(Material.rock);
+    }
 
-	public BlockCarvable(Material m) {
-		super(m);
-		if (m == Material.rock || m == Material.iron) {
-			setHarvestLevel("pickaxe", 0);
-		}
-		carverHelper = new CarvableHelper(this);
-		setResistance(10.0F);
-		setHardness(2.0F);
-		setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
-	}
+    public BlockCarvable(Material m) {
+        super(m);
+        if (m == Material.rock || m == Material.iron) {
+            setHarvestLevel("pickaxe", 0);
+        }
+        carverHelper = new CarvableHelper(this);
+        setResistance(10.0F);
+        setHardness(2.0F);
+        setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
+    }
 
-	public BlockCarvable setStained(boolean a) {
-		this.isAlpha = a;
-		return this;
-	}
+    public BlockCarvable setStained(boolean a) {
+        this.isAlpha = a;
+        return this;
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public int getRenderBlockPass() {
-		return isAlpha ? 1 : 0;
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public int getRenderBlockPass() {
+        return isAlpha ? 1 : 0;
+    }
 
-	@Override
-	public IIcon getIcon(int side, int metadata) {
-		return carverHelper.getIcon(side, metadata);
-	}
+    @Override
+    public IIcon getIcon(int side, int metadata) {
+        return carverHelper.getIcon(side, metadata);
+    }
 
-	@Override
-	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
-		return carverHelper.getIcon(world, x, y, z, side);
-	}
+    @Override
+    public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+        return carverHelper.getIcon(world, x, y, z, side);
+    }
 
-	@Override
-	public int damageDropped(int i) {
-		return i;
-	}
+    @Override
+    public int damageDropped(int i) {
+        return i;
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public void registerBlockIcons(IIconRegister register) {
-		carverHelper.registerBlockIcons(Chisel.MOD_ID, this, register);
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerBlockIcons(IIconRegister register) {
+        carverHelper.registerBlockIcons(Chisel.MOD_ID, this, register);
+    }
 
-	@SuppressWarnings({ "unchecked", "rawtypes" })
-	@Override
-	public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
-		carverHelper.registerSubBlocks(this, tabs, list);
-	}
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Override
+    public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
+        carverHelper.registerSubBlocks(this, tabs, list);
+    }
 
-	@Override
-	public int getRenderType() {
-		return ClientUtils.renderCTMId;
-	}
+    @Override
+    public int getRenderType() {
+        return ClientUtils.renderCTMId;
+    }
 
-	@Override
-	public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
-		return carverHelper.getVariation(metadata);
-	}
+    @Override
+    public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
+        return carverHelper.getVariation(metadata);
+    }
 
-	@Override
-	public IVariationInfo getManager(int meta) {
-		return carverHelper.getVariation(meta);
-	}
+    @Override
+    public IVariationInfo getManager(int meta) {
+        return carverHelper.getVariation(meta);
+    }
 
-	public static class SoundType extends Block.SoundType {
+    public static class SoundType extends Block.SoundType {
 
-		public final String soundNameStep;
-		public final String soundNameBreak;
-		public final String soundNamePlace;
+        public final String soundNameStep;
+        public final String soundNameBreak;
+        public final String soundNamePlace;
 
-		/**
-		 * Creates a SoundType with automatic names for step and break sounds. Sound names dig.soundName and step.soundName must be specified in the sounds.json
-		 * 
-		 * @param soundName
-		 *            block of the sound. Will automatically be expanded to "mod:dig.soundName" and "mod:step.soundName" respectively)
-		 * @param volume
-		 *            default 1.0f
-		 * @param frequency
-		 *            default 1.0f
-		 */
-		public SoundType(String soundName, float volume, float frequency) {
-			super(soundName, volume, frequency);
-			this.soundNameStep = null;
-			this.soundNameBreak = null;
-			this.soundNamePlace = null;
-		}
+        /**
+         * Creates a SoundType with automatic names for step and break sounds. Sound names dig.soundName and
+         * step.soundName must be specified in the sounds.json
+         * 
+         * @param soundName block of the sound. Will automatically be expanded to "mod:dig.soundName" and
+         *                  "mod:step.soundName" respectively)
+         * @param volume    default 1.0f
+         * @param frequency default 1.0f
+         */
+        public SoundType(String soundName, float volume, float frequency) {
+            super(soundName, volume, frequency);
+            this.soundNameStep = null;
+            this.soundNameBreak = null;
+            this.soundNamePlace = null;
+        }
 
-		/**
-		 * Creates a SoundType with manual names for step and break sounds. Sound names must be specified in the sounds.json
-		 * 
-		 * @param soundNameBreak
-		 *            block break sound
-		 * @param soundNameStep
-		 *            block step sound
-		 * @param volume
-		 *            default 1.0f
-		 * @param frequency
-		 *            default 1.0f
-		 */
-		public SoundType(String soundNameBreak, String soundNameStep, float volume, float frequency) {
-			super(soundNameStep, volume, frequency);
-			this.soundNameStep = soundNameStep;
-			this.soundNameBreak = soundNameBreak;
-			this.soundNamePlace = null;
-		}
+        /**
+         * Creates a SoundType with manual names for step and break sounds. Sound names must be specified in the
+         * sounds.json
+         * 
+         * @param soundNameBreak block break sound
+         * @param soundNameStep  block step sound
+         * @param volume         default 1.0f
+         * @param frequency      default 1.0f
+         */
+        public SoundType(String soundNameBreak, String soundNameStep, float volume, float frequency) {
+            super(soundNameStep, volume, frequency);
+            this.soundNameStep = soundNameStep;
+            this.soundNameBreak = soundNameBreak;
+            this.soundNamePlace = null;
+        }
 
-		/**
-		 * Creates a SoundType with manual names for step, break and place sounds. Sound names must be specified in the sounds.json
-		 * 
-		 * @param soundNameBreak
-		 *            block break sound
-		 * @param soundNameStep
-		 *            block step sound
-		 * @param soundNamePlace
-		 *            block place sound
-		 * @param volume
-		 *            default 1.0f
-		 * @param frequency
-		 *            default 1.0f
-		 */
-		public SoundType(String soundNameBreak, String soundNameStep, String soundNamePlace, float volume, float frequency) {
-			super(soundNameStep, volume, frequency);
-			this.soundNameStep = soundNameStep;
-			this.soundNameBreak = soundNameBreak;
-			this.soundNamePlace = soundNamePlace;
-		}
+        /**
+         * Creates a SoundType with manual names for step, break and place sounds. Sound names must be specified in the
+         * sounds.json
+         * 
+         * @param soundNameBreak block break sound
+         * @param soundNameStep  block step sound
+         * @param soundNamePlace block place sound
+         * @param volume         default 1.0f
+         * @param frequency      default 1.0f
+         */
+        public SoundType(String soundNameBreak, String soundNameStep, String soundNamePlace, float volume,
+                float frequency) {
+            super(soundNameStep, volume, frequency);
+            this.soundNameStep = soundNameStep;
+            this.soundNameBreak = soundNameBreak;
+            this.soundNamePlace = soundNamePlace;
+        }
 
-		@Override
-		public String getBreakSound() {
-			if (soundNameBreak == null)
-				return Chisel.MOD_ID + ":dig." + this.soundName;
-			else
-				return this.soundNameBreak;
-		}
+        @Override
+        public String getBreakSound() {
+            if (soundNameBreak == null) return Chisel.MOD_ID + ":dig." + this.soundName;
+            else return this.soundNameBreak;
+        }
 
-		@Override
-		public String getStepResourcePath() {
-			if (soundNameStep == null)
-				return Chisel.MOD_ID + ":step." + this.soundName;
-			else
-				return this.soundNameStep;
-		}
+        @Override
+        public String getStepResourcePath() {
+            if (soundNameStep == null) return Chisel.MOD_ID + ":step." + this.soundName;
+            else return this.soundNameStep;
+        }
 
-		@Override
-		public String func_150496_b() {
-			if (soundNamePlace == null)
-				return getBreakSound();
-			else
-				return this.soundNamePlace;
-		}
-	}
+        @Override
+        public String func_150496_b() {
+            if (soundNamePlace == null) return getBreakSound();
+            else return this.soundNamePlace;
+        }
+    }
 }

src/main/java/team/chisel/block/BlockCarvableAntiBlock.java

@@ -1,19 +1,19 @@
 package team.chisel.block;
 
-import com.cricketcraft.chisel.api.ICarvable;
-
 import net.minecraft.block.material.Material;
 import net.minecraft.entity.EnumCreatureType;
 import net.minecraft.world.IBlockAccess;
 
+import com.cricketcraft.chisel.api.ICarvable;
+
 public class BlockCarvableAntiBlock extends BlockCarvableColor implements ICarvable {
 
-	public BlockCarvableAntiBlock() {
-		super(Material.rock);
-	}
+    public BlockCarvableAntiBlock() {
+        super(Material.rock);
+    }
 
-	@Override
-	public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess world, int x, int y, int z) {
-		return false;
-	}
+    @Override
+    public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess world, int x, int y, int z) {
+        return false;
+    }
 }

src/main/java/team/chisel/block/BlockCarvableBeacon.java

@@ -12,6 +12,7 @@ import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.MovingObjectPosition;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
+
 import team.chisel.block.tileentity.TileEntityCarvableBeacon;
 import team.chisel.init.ChiselBlocks;
 
@@ -22,77 +23,78 @@ import com.cricketcraft.chisel.api.carving.IVariationInfo;
 
 public class BlockCarvableBeacon extends BlockBeacon implements ICarvable {
 
-	public static int renderId;
+    public static int renderId;
 
-	public CarvableHelper carverHelper;
+    public CarvableHelper carverHelper;
 
-	public BlockCarvableBeacon() {
-		super();
-		setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
-		setLightLevel(5.0F);
-		setBlockTextureName("beacon");
-		carverHelper = new CarvableHelper(this);
-	}
+    public BlockCarvableBeacon() {
+        super();
+        setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
+        setLightLevel(5.0F);
+        setBlockTextureName("beacon");
+        carverHelper = new CarvableHelper(this);
+    }
 
-	@Override
-	public TileEntity createNewTileEntity(World world, int meta) {
-		return new TileEntityCarvableBeacon();
-	}
+    @Override
+    public TileEntity createNewTileEntity(World world, int meta) {
+        return new TileEntityCarvableBeacon();
+    }
 
-	@Override
-	public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int par5, float hitX, float hitY, float hitZ) {
-		if (world.isRemote) {
-			return true;
-		} else {
-			TileEntityCarvableBeacon tileentitybeacon = (TileEntityCarvableBeacon) world.getTileEntity(x, y, z);
+    @Override
+    public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int par5, float hitX,
+            float hitY, float hitZ) {
+        if (world.isRemote) {
+            return true;
+        } else {
+            TileEntityCarvableBeacon tileentitybeacon = (TileEntityCarvableBeacon) world.getTileEntity(x, y, z);
 
-			if (tileentitybeacon != null) {
-				player.func_146104_a(tileentitybeacon);
-			}
+            if (tileentitybeacon != null) {
+                player.func_146104_a(tileentitybeacon);
+            }
 
-			return true;
-		}
-	}
+            return true;
+        }
+    }
 
-	@SuppressWarnings({ "rawtypes", "unchecked" })
-	@Override
-	public void getSubBlocks(Item item, CreativeTabs p_149666_2_, List list) {
-		for (int i = 0; i < 16; i++) {
-			list.add(new ItemStack(item, 1, i));
-		}
-	}
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    @Override
+    public void getSubBlocks(Item item, CreativeTabs p_149666_2_, List list) {
+        for (int i = 0; i < 16; i++) {
+            list.add(new ItemStack(item, 1, i));
+        }
+    }
 
-	@Override
-	public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z) {
-		return new ItemStack(ChiselBlocks.beacon, 1, world.getBlockMetadata(x, y, z));
-	}
-	
-	@Override
-	public int damageDropped(int meta) {
-		return meta;
-	}
+    @Override
+    public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z) {
+        return new ItemStack(ChiselBlocks.beacon, 1, world.getBlockMetadata(x, y, z));
+    }
 
-	@Override
-	public int getRenderType() {
-		return renderId;
-	}
+    @Override
+    public int damageDropped(int meta) {
+        return meta;
+    }
 
-	@Override
-	public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase player, ItemStack stack) {
-		super.onBlockPlacedBy(world, x, y, z, player, stack);
+    @Override
+    public int getRenderType() {
+        return renderId;
+    }
 
-		if (stack.hasDisplayName()) {
-			((TileEntityCarvableBeacon) world.getTileEntity(x, y, z)).func_145999_a(stack.getDisplayName());
-		}
-	}
+    @Override
+    public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase player, ItemStack stack) {
+        super.onBlockPlacedBy(world, x, y, z, player, stack);
 
-	@Override
-	public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
-		return carverHelper.getVariation(metadata);
-	}
+        if (stack.hasDisplayName()) {
+            ((TileEntityCarvableBeacon) world.getTileEntity(x, y, z)).func_145999_a(stack.getDisplayName());
+        }
+    }
 
-	@Override
-	public IVariationInfo getManager(int meta) {
-		return carverHelper.getVariation(meta);
-	}
+    @Override
+    public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
+        return carverHelper.getVariation(metadata);
+    }
+
+    @Override
+    public IVariationInfo getManager(int meta) {
+        return carverHelper.getVariation(meta);
+    }
 }

src/main/java/team/chisel/block/BlockCarvableBookshelf.java

@@ -9,53 +9,52 @@ import net.minecraft.item.Item;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
+
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class BlockCarvableBookshelf extends BlockCarvable {
 
-	public BlockCarvableBookshelf() {
-		super(Material.wood);
-		setHarvestLevel("axe", 0);
-	}
+    public BlockCarvableBookshelf() {
+        super(Material.wood);
+        setHarvestLevel("axe", 0);
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public IIcon getIcon(int side, int metadata) {
-		if (side < 2)
-			return Blocks.planks.getBlockTextureFromSide(side);
-		return super.getIcon(side, metadata);
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIcon(int side, int metadata) {
+        if (side < 2) return Blocks.planks.getBlockTextureFromSide(side);
+        return super.getIcon(side, metadata);
+    }
 
-	@Override
-	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
-		if (side < 2)
-			return Blocks.planks.getBlockTextureFromSide(side);
-		return super.getIcon(world, x, y, z, side);
-	}
+    @Override
+    public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+        if (side < 2) return Blocks.planks.getBlockTextureFromSide(side);
+        return super.getIcon(world, x, y, z, side);
+    }
 
-	@Override
-	public int quantityDropped(Random random) {
-		return 3;
-	}
+    @Override
+    public int quantityDropped(Random random) {
+        return 3;
+    }
 
-	@Override
-	public Item getItemDropped(int ammount, Random random, int meta) {
-		return Items.book;
-	}
+    @Override
+    public Item getItemDropped(int ammount, Random random, int meta) {
+        return Items.book;
+    }
 
-	@Override
-	public int damageDropped(int damage) {
-		return 0;
-	}
+    @Override
+    public int damageDropped(int damage) {
+        return 0;
+    }
 
-	@Override
-	public int getDamageValue(World world, int x, int y, int z) {
-		return world.getBlockMetadata(x, y, z);
-	}
+    @Override
+    public int getDamageValue(World world, int x, int y, int z) {
+        return world.getBlockMetadata(x, y, z);
+    }
 
-	@Override
-	public float getEnchantPowerBonus(World world, int x, int y, int z) {
-		return 1;
-	}
+    @Override
+    public float getEnchantPowerBonus(World world, int x, int y, int z) {
+        return 1;
+    }
 }

src/main/java/team/chisel/block/BlockCarvableCarpet.java

@@ -2,11 +2,6 @@ package team.chisel.block;
 
 import java.util.List;
 
-import com.cricketcraft.chisel.api.ICarvable;
-import com.cricketcraft.chisel.api.carving.CarvableHelper;
-import com.cricketcraft.chisel.api.carving.IVariationInfo;
-import com.cricketcraft.chisel.api.rendering.ClientUtils;
-
 import net.minecraft.block.BlockCarpet;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.texture.IIconRegister;
@@ -15,52 +10,57 @@ import net.minecraft.item.Item;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
 
+import com.cricketcraft.chisel.api.ICarvable;
+import com.cricketcraft.chisel.api.carving.CarvableHelper;
+import com.cricketcraft.chisel.api.carving.IVariationInfo;
+import com.cricketcraft.chisel.api.rendering.ClientUtils;
+
 public class BlockCarvableCarpet extends BlockCarpet implements ICarvable {
 
-	public CarvableHelper carverHelper;
+    public CarvableHelper carverHelper;
 
-	public BlockCarvableCarpet(Material m) {
-		carverHelper = new CarvableHelper(this);
-	}
+    public BlockCarvableCarpet(Material m) {
+        carverHelper = new CarvableHelper(this);
+    }
 
-	@Override
-	public IIcon getIcon(int side, int metadata) {
-		return carverHelper.getIcon(side, metadata);
-	}
+    @Override
+    public IIcon getIcon(int side, int metadata) {
+        return carverHelper.getIcon(side, metadata);
+    }
 
-	@Override
-	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
-		return carverHelper.getIcon(world, x, y, z, side);
-	}
+    @Override
+    public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+        return carverHelper.getIcon(world, x, y, z, side);
+    }
 
-	@Override
-	public int damageDropped(int i) {
-		return i;
-	}
+    @Override
+    public int damageDropped(int i) {
+        return i;
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		carverHelper.registerBlockIcons("Chisel", this, register);
-	}
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+        carverHelper.registerBlockIcons("Chisel", this, register);
+    }
 
-	@SuppressWarnings({ "unchecked", "rawtypes" })
-	@Override
-	public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
-		carverHelper.registerSubBlocks(this, tabs, list);
-	}
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Override
+    public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
+        carverHelper.registerSubBlocks(this, tabs, list);
+    }
 
-	@Override
-	public int getRenderType() {
-		return ClientUtils.renderCTMId;
-	}
+    @Override
+    public int getRenderType() {
+        return ClientUtils.renderCTMId;
+    }
 
-	@Override
-	public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
-		return carverHelper.getVariation(metadata);
-	}
+    @Override
+    public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
+        return carverHelper.getVariation(metadata);
+    }
 
-	@Override
-	public IVariationInfo getManager(int meta) {
-		return carverHelper.getVariation(meta);
-	}
+    @Override
+    public IVariationInfo getManager(int meta) {
+        return carverHelper.getVariation(meta);
+    }
 }

src/main/java/team/chisel/block/BlockCarvableColor.java

@@ -6,21 +6,21 @@ import net.minecraftforge.common.util.ForgeDirection;
 
 public class BlockCarvableColor extends BlockCarvable {
 
-	public BlockCarvableColor() {
-		this(Material.rock);
-	}
+    public BlockCarvableColor() {
+        this(Material.rock);
+    }
 
-	public BlockCarvableColor(Material m) {
-		super(m);
-	}
+    public BlockCarvableColor(Material m) {
+        super(m);
+    }
 
-	@Override
-	public boolean recolourBlock(World world, int x, int y, int z, ForgeDirection side, int color) {
-		int newColor = 15 - color;
-		if (world.getBlockMetadata(x, y, z) != newColor) {
-			world.setBlockMetadataWithNotify(x, y, z, newColor, 3);
-			return true;
-		}
-		return false;
-	}
+    @Override
+    public boolean recolourBlock(World world, int x, int y, int z, ForgeDirection side, int color) {
+        int newColor = 15 - color;
+        if (world.getBlockMetadata(x, y, z) != newColor) {
+            world.setBlockMetadataWithNotify(x, y, z, newColor, 3);
+            return true;
+        }
+        return false;
+    }
 }

src/main/java/team/chisel/block/BlockCarvableGlass.java

@@ -11,6 +11,7 @@ import net.minecraft.item.Item;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
 import net.minecraftforge.common.util.ForgeDirection;
+
 import team.chisel.ctmlib.CTM;
 
 import com.cricketcraft.chisel.api.ChiselTabs;
@@ -24,84 +25,84 @@ import cpw.mods.fml.relauncher.SideOnly;
 
 public class BlockCarvableGlass extends BlockGlass implements ICarvable {
 
-	public CarvableHelper carverHelper;
-	private boolean isAlpha = false;
-	private CTM ctm = CTM.getInstance();
+    public CarvableHelper carverHelper;
+    private boolean isAlpha = false;
+    private CTM ctm = CTM.getInstance();
 
-	public BlockCarvableGlass() {
-		super(Material.glass, false);
+    public BlockCarvableGlass() {
+        super(Material.glass, false);
 
-		carverHelper = new CarvableHelper(this);
-		setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
-	}
+        carverHelper = new CarvableHelper(this);
+        setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
+    }
 
-	public BlockCarvableGlass setStained(boolean a) {
-		this.isAlpha = a;
-		return this;
-	}
+    public BlockCarvableGlass setStained(boolean a) {
+        this.isAlpha = a;
+        return this;
+    }
 
-	@Override
-	public boolean renderAsNormalBlock() {
-		return false;
-	}
+    @Override
+    public boolean renderAsNormalBlock() {
+        return false;
+    }
 
-	@Override
-	public boolean isNormalCube() {
-		return true;
-	}
+    @Override
+    public boolean isNormalCube() {
+        return true;
+    }
 
-	@Override
-	public int getRenderType() {
-		return ClientUtils.renderCTMId;
-	}
+    @Override
+    public int getRenderType() {
+        return ClientUtils.renderCTMId;
+    }
 
-	@Override
-	public IIcon getIcon(int side, int metadata) {
-		return carverHelper.getIcon(side, metadata);
-	}
-	
-	@Override
-	public boolean shouldSideBeRendered(IBlockAccess world, int x, int y, int z, int side) {
-		ForgeDirection face = ForgeDirection.getOrientation(side).getOpposite();
-		int meX = x + face.offsetX;
-		int meY = y + face.offsetY;
-		int meZ = z + face.offsetZ;
-		Block block = world.getBlock(meX, meY, meZ);
-		int meta = world.getBlockMetadata(meX, meY, meZ);
-		Block otherBlock = ctm.getBlockOrFacade(world, x, y, z, face.ordinal());
-		int otherMeta = ctm.getBlockOrFacadeMetadata(world, x, y, z, face.ordinal());
-		return block != otherBlock || meta != otherMeta;
-	}
+    @Override
+    public IIcon getIcon(int side, int metadata) {
+        return carverHelper.getIcon(side, metadata);
+    }
 
-	@Override
-	public int damageDropped(int i) {
-		return i;
-	}
+    @Override
+    public boolean shouldSideBeRendered(IBlockAccess world, int x, int y, int z, int side) {
+        ForgeDirection face = ForgeDirection.getOrientation(side).getOpposite();
+        int meX = x + face.offsetX;
+        int meY = y + face.offsetY;
+        int meZ = z + face.offsetZ;
+        Block block = world.getBlock(meX, meY, meZ);
+        int meta = world.getBlockMetadata(meX, meY, meZ);
+        Block otherBlock = ctm.getBlockOrFacade(world, x, y, z, face.ordinal());
+        int otherMeta = ctm.getBlockOrFacadeMetadata(world, x, y, z, face.ordinal());
+        return block != otherBlock || meta != otherMeta;
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		carverHelper.registerBlockIcons("Chisel", this, register);
-	}
+    @Override
+    public int damageDropped(int i) {
+        return i;
+    }
 
-	@SuppressWarnings({ "unchecked", "rawtypes" })
-	@Override
-	public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
-		carverHelper.registerSubBlocks(this, tabs, list);
-	}
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+        carverHelper.registerBlockIcons("Chisel", this, register);
+    }
 
-	@Override
-	public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
-		return carverHelper.getVariation(metadata);
-	}
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Override
+    public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
+        carverHelper.registerSubBlocks(this, tabs, list);
+    }
 
-	@Override
-	public IVariationInfo getManager(int meta) {
-		return carverHelper.getVariation(meta);
-	}
+    @Override
+    public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
+        return carverHelper.getVariation(metadata);
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public int getRenderBlockPass() {
-		return isAlpha ? 1 : 0;
-	}
+    @Override
+    public IVariationInfo getManager(int meta) {
+        return carverHelper.getVariation(meta);
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public int getRenderBlockPass() {
+        return isAlpha ? 1 : 0;
+    }
 }

src/main/java/team/chisel/block/BlockCarvableGlow.java

@@ -1,58 +1,59 @@
 package team.chisel.block;
 
-import team.chisel.Chisel;
-import team.chisel.client.render.SubmapManagerBase;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.util.IIcon;
+
+import team.chisel.Chisel;
+import team.chisel.client.render.SubmapManagerBase;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class BlockCarvableGlow extends BlockCarvableColor {
 
-	@SideOnly(Side.CLIENT)
-	private IIcon glowTexture;
+    @SideOnly(Side.CLIENT)
+    private IIcon glowTexture;
 
-	private SubmapManagerBase submapManagerBase;
-	private String glowTexturePath;
+    private SubmapManagerBase submapManagerBase;
+    private String glowTexturePath;
 
-	public BlockCarvableGlow(String glowTexture) {
-		super();
-		setLightLevel(0.5f);
-		this.glowTexturePath = glowTexture;
-	}
+    public BlockCarvableGlow(String glowTexture) {
+        super();
+        setLightLevel(0.5f);
+        this.glowTexturePath = glowTexture;
+    }
 
-	public BlockCarvableGlow(Material mat, String glowTexture) {
-		super(mat);
-		this.glowTexturePath = glowTexture;
-	}
+    public BlockCarvableGlow(Material mat, String glowTexture) {
+        super(mat);
+        this.glowTexturePath = glowTexture;
+    }
 
-	public BlockCarvableGlow(Material material, String glowTexture, SubmapManagerBase submapManagerBase) {
-		super(material);
-		this.glowTexturePath = glowTexture;
-		this.submapManagerBase = submapManagerBase;
-	}
+    public BlockCarvableGlow(Material material, String glowTexture, SubmapManagerBase submapManagerBase) {
+        super(material);
+        this.glowTexturePath = glowTexture;
+        this.submapManagerBase = submapManagerBase;
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		super.registerBlockIcons(register);
-		glowTexture = register.registerIcon(Chisel.MOD_ID + ":" + glowTexturePath);
-	}
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+        super.registerBlockIcons(register);
+        glowTexture = register.registerIcon(Chisel.MOD_ID + ":" + glowTexturePath);
+    }
 
-	public boolean hasSubmapManager() {
-		return submapManagerBase == null;
-	}
+    public boolean hasSubmapManager() {
+        return submapManagerBase == null;
+    }
 
-	public SubmapManagerBase getSubmapManager() {
-		return hasSubmapManager() ? submapManagerBase : null;
-	}
+    public SubmapManagerBase getSubmapManager() {
+        return hasSubmapManager() ? submapManagerBase : null;
+    }
 
-	public IIcon getGlowTexture() {
-		return glowTexture;
-	}
+    public IIcon getGlowTexture() {
+        return glowTexture;
+    }
 
-	@Override
-	public int getRenderType() {
-		return Chisel.renderGlowId;
-	}
+    @Override
+    public int getRenderType() {
+        return Chisel.renderGlowId;
+    }
 }

src/main/java/team/chisel/block/BlockCarvableGlowstone.java

@@ -14,29 +14,29 @@ import net.minecraft.world.World;
 
 public class BlockCarvableGlowstone extends BlockCarvable {
 
-	public BlockCarvableGlowstone() {
-		super(Material.glass);
-	}
+    public BlockCarvableGlowstone() {
+        super(Material.glass);
+    }
 
-	@Override
-	public int quantityDropped(Random random) {
-		return Blocks.glowstone.quantityDropped(random);
-	}
+    @Override
+    public int quantityDropped(Random random) {
+        return Blocks.glowstone.quantityDropped(random);
+    }
 
-	@Override
-	public Item getItemDropped(int i, Random random, int a) {
-		return Items.glowstone_dust;
-	}
+    @Override
+    public Item getItemDropped(int i, Random random, int a) {
+        return Items.glowstone_dust;
+    }
 
-	@Override
-	public int damageDropped(int i) {
-		return 0;
-	}
+    @Override
+    public int damageDropped(int i) {
+        return 0;
+    }
 
-	@Override
-	public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z, EntityPlayer player) {
-		Block glowstone = world.getBlock(x, y, z);
-		int meta = world.getBlockMetadata(x, y, z);
-		return new ItemStack(Item.getItemFromBlock(glowstone), 1, meta);
-	}
+    @Override
+    public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z, EntityPlayer player) {
+        Block glowstone = world.getBlock(x, y, z);
+        int meta = world.getBlockMetadata(x, y, z);
+        return new ItemStack(Item.getItemFromBlock(glowstone), 1, meta);
+    }
 }

src/main/java/team/chisel/block/BlockCarvableIce.java

@@ -2,11 +2,6 @@ package team.chisel.block;
 
 import java.util.List;
 
-import com.cricketcraft.chisel.api.ICarvable;
-import com.cricketcraft.chisel.api.carving.CarvableHelper;
-import com.cricketcraft.chisel.api.carving.IVariationInfo;
-import com.cricketcraft.chisel.api.rendering.ClientUtils;
-
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockIce;
 import net.minecraft.client.renderer.texture.IIconRegister;
@@ -18,58 +13,63 @@ import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 
+import com.cricketcraft.chisel.api.ICarvable;
+import com.cricketcraft.chisel.api.carving.CarvableHelper;
+import com.cricketcraft.chisel.api.carving.IVariationInfo;
+import com.cricketcraft.chisel.api.rendering.ClientUtils;
+
 public class BlockCarvableIce extends BlockIce implements ICarvable {
 
-	public CarvableHelper carverHelper;
+    public CarvableHelper carverHelper;
 
-	public BlockCarvableIce() {
-		super();
-		carverHelper = new CarvableHelper(this);
-	}
+    public BlockCarvableIce() {
+        super();
+        carverHelper = new CarvableHelper(this);
+    }
 
-	@Override
-	public int getRenderType() {
-		return ClientUtils.renderCTMId;
-	}
+    @Override
+    public int getRenderType() {
+        return ClientUtils.renderCTMId;
+    }
 
-	@Override
-	public IIcon getIcon(int side, int metadata) {
-		return carverHelper.getIcon(side, metadata);
-	}
+    @Override
+    public IIcon getIcon(int side, int metadata) {
+        return carverHelper.getIcon(side, metadata);
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		carverHelper.registerBlockIcons("Chisel", this, register);
-	}
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+        carverHelper.registerBlockIcons("Chisel", this, register);
+    }
 
-	@SuppressWarnings({ "unchecked", "rawtypes" })
-	@Override
-	public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
-		carverHelper.registerSubBlocks(this, tabs, list);
-	}
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Override
+    public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
+        carverHelper.registerSubBlocks(this, tabs, list);
+    }
 
-	@Override
-	public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) {
-		super.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
+    @Override
+    public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) {
+        super.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
 
-		par2EntityPlayer.addStat(StatList.mineBlockStatArray[Block.getIdFromBlock(this)], 1);
-		par2EntityPlayer.addExhaustion(0.025F);
+        par2EntityPlayer.addStat(StatList.mineBlockStatArray[Block.getIdFromBlock(this)], 1);
+        par2EntityPlayer.addExhaustion(0.025F);
 
-		/*
-		 * if(this.canSilkHarvest(par1World, par2EntityPlayer, par3, par4, par5, par6) && EnchantmentHelper.getSilkTouchModifier(par2EntityPlayer)) { ItemStack itemstack =
-		 * this.createStackedBlock(par6);
-		 * 
-		 * if(itemstack != null) { this.dropBlockAsItem(par1World, par3, par4, par5, itemstack); } }
-		 */
-	}
+        /*
+         * if(this.canSilkHarvest(par1World, par2EntityPlayer, par3, par4, par5, par6) &&
+         * EnchantmentHelper.getSilkTouchModifier(par2EntityPlayer)) { ItemStack itemstack =
+         * this.createStackedBlock(par6); if(itemstack != null) { this.dropBlockAsItem(par1World, par3, par4, par5,
+         * itemstack); } }
+         */
+    }
 
-	@Override
-	public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
-		return carverHelper.getVariation(metadata);
-	}
+    @Override
+    public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
+        return carverHelper.getVariation(metadata);
+    }
 
-	@Override
-	public IVariationInfo getManager(int meta) {
-		return carverHelper.getVariation(meta);
-	}
+    @Override
+    public IVariationInfo getManager(int meta) {
+        return carverHelper.getVariation(meta);
+    }
 }

src/main/java/team/chisel/block/BlockCarvableIceStairs.java

@@ -2,44 +2,45 @@ package team.chisel.block;
 
 import java.util.Random;
 
-import com.cricketcraft.chisel.api.carving.CarvableHelper;
-
-import team.chisel.init.ChiselBlocks;
 import net.minecraft.block.Block;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.world.World;
 
+import team.chisel.init.ChiselBlocks;
+
+import com.cricketcraft.chisel.api.carving.CarvableHelper;
+
 public class BlockCarvableIceStairs extends BlockCarvableStairs {
 
-	public BlockCarvableIceStairs(Block block, int meta, CarvableHelper helper) {
-		super(block, meta, helper);
+    public BlockCarvableIceStairs(Block block, int meta, CarvableHelper helper) {
+        super(block, meta, helper);
 
-		slipperiness = 0.98F;
-		setTickRandomly(true);
-	}
+        slipperiness = 0.98F;
+        setTickRandomly(true);
+    }
 
-	@Override
-	public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) {
-		ChiselBlocks.ice.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
-	}
+    @Override
+    public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) {
+        ChiselBlocks.ice.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
+    }
 
-	@Override
-	public int quantityDropped(Random par1Random) {
-		return ChiselBlocks.ice.quantityDropped(par1Random);
-	}
+    @Override
+    public int quantityDropped(Random par1Random) {
+        return ChiselBlocks.ice.quantityDropped(par1Random);
+    }
 
-	@Override
-	public int damageDropped(int i) {
-		return 0;
-	}
+    @Override
+    public int damageDropped(int i) {
+        return 0;
+    }
 
-	@Override
-	public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {
-		ChiselBlocks.ice.updateTick(par1World, par2, par3, par4, par5Random);
-	}
+    @Override
+    public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {
+        ChiselBlocks.ice.updateTick(par1World, par2, par3, par4, par5Random);
+    }
 
-	@Override
-	public int getMobilityFlag() {
-		return 0;
-	}
+    @Override
+    public int getMobilityFlag() {
+        return 0;
+    }
 }

src/main/java/team/chisel/block/BlockCarvableLamp.java

@@ -11,71 +11,70 @@ import net.minecraft.world.World;
 
 public class BlockCarvableLamp extends BlockCarvable {
 
-	BlockCarvableLamp blockUnpowered;
-	BlockCarvableLamp blockPowered;
-	boolean powered;
+    BlockCarvableLamp blockUnpowered;
+    BlockCarvableLamp blockPowered;
+    boolean powered;
 
-	public BlockCarvableLamp() {
-		super(Material.redstoneLight);
+    public BlockCarvableLamp() {
+        super(Material.redstoneLight);
 
-		powered = false;
-		blockUnpowered = this;
-		blockPowered = new BlockCarvableLamp(this);
+        powered = false;
+        blockUnpowered = this;
+        blockPowered = new BlockCarvableLamp(this);
 
-		setHardness(0.3F);
-	}
+        setHardness(0.3F);
+    }
 
-	public BlockCarvableLamp(BlockCarvableLamp unpoweredVersion) {
-		super(Material.redstoneLight);
+    public BlockCarvableLamp(BlockCarvableLamp unpoweredVersion) {
+        super(Material.redstoneLight);
 
-		carverHelper = unpoweredVersion.carverHelper;
+        carverHelper = unpoweredVersion.carverHelper;
 
-		powered = true;
-		blockUnpowered = unpoweredVersion;
-		blockPowered = this;
+        powered = true;
+        blockUnpowered = unpoweredVersion;
+        blockPowered = this;
 
-		setLightLevel(1.0F);
-		setHardness(0.3F);
-	}
+        setLightLevel(1.0F);
+        setHardness(0.3F);
+    }
 
-	public void checkPower(World world, int x, int y, int z) {
-		if (world.isRemote)
-			return;
+    public void checkPower(World world, int x, int y, int z) {
+        if (world.isRemote) return;
 
-		boolean isGettingPower = world.isBlockIndirectlyGettingPowered(x, y, z);
-		int meta = world.getBlockMetadata(x, y, z);
+        boolean isGettingPower = world.isBlockIndirectlyGettingPowered(x, y, z);
+        int meta = world.getBlockMetadata(x, y, z);
 
-		if (powered && !isGettingPower) {
-			world.setBlock(x, y, z, blockUnpowered, meta, 2);
-		} else if (!powered && isGettingPower) {
-			world.setBlock(x, y, z, blockPowered, meta, 2);
-		}
-	}
+        if (powered && !isGettingPower) {
+            world.setBlock(x, y, z, blockUnpowered, meta, 2);
+        } else if (!powered && isGettingPower) {
+            world.setBlock(x, y, z, blockPowered, meta, 2);
+        }
+    }
 
-	@Override
-	public void onBlockAdded(World world, int x, int y, int z) {
-		checkPower(world, x, y, z);
-	}
+    @Override
+    public void onBlockAdded(World world, int x, int y, int z) {
+        checkPower(world, x, y, z);
+    }
 
-	@Override
-	public void onNeighborBlockChange(World world, int x, int y, int z, Block block) {
-		checkPower(world, x, y, z);
-	}
+    @Override
+    public void onNeighborBlockChange(World world, int x, int y, int z, Block block) {
+        checkPower(world, x, y, z);
+    }
 
-	/*
-	 * @Override public void updateTick(World world, int x, int y, int z, Random rand){ if (world.isRemote) return;
-	 * 
-	 * if(powered && !world.isBlockIndirectlyGettingPowered(x, y, z)){ int meta=world.getBlockMetadata(x, y, z); world.setBlock(x, y, z, Block.redstoneLampIdle.blockID, meta, 2); } }
-	 */
+    /*
+     * @Override public void updateTick(World world, int x, int y, int z, Random rand){ if (world.isRemote) return;
+     * if(powered && !world.isBlockIndirectlyGettingPowered(x, y, z)){ int meta=world.getBlockMetadata(x, y, z);
+     * world.setBlock(x, y, z, Block.redstoneLampIdle.blockID, meta, 2); } }
+     */
 
-	@Override
-	public Item getItemDropped(int par1, Random par2Random, int par3) {
-		return Item.getItemFromBlock(blockUnpowered);
-	}
+    @Override
+    public Item getItemDropped(int par1, Random par2Random, int par3) {
+        return Item.getItemFromBlock(blockUnpowered);
+    }
 
-	@Override
-	public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z) {
-		return new ItemStack(blockUnpowered, 1, world.getBlockMetadata(x, y, z));
-	}
+    @Override
+    public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z) {
+        return new ItemStack(blockUnpowered, 1, world.getBlockMetadata(x, y, z));
+    }
 
 }

src/main/java/team/chisel/block/BlockCarvableLayered.java

@@ -1,35 +1,36 @@
 package team.chisel.block;
 
-import team.chisel.Chisel;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.util.IIcon;
+
+import team.chisel.Chisel;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class BlockCarvableLayered extends BlockCarvable {
 
-	@SideOnly(Side.CLIENT)
-	private IIcon baseTexture;
-	private String baseTexLocation;
+    @SideOnly(Side.CLIENT)
+    private IIcon baseTexture;
+    private String baseTexLocation;
 
-	public BlockCarvableLayered(Material mat, String baseTexLocation) {
-		super(mat);
-		this.baseTexLocation = baseTexLocation;
-	}
+    public BlockCarvableLayered(Material mat, String baseTexLocation) {
+        super(mat);
+        this.baseTexLocation = baseTexLocation;
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		super.registerBlockIcons(register);
-		baseTexture = register.registerIcon(Chisel.MOD_ID + ":" + baseTexLocation);
-	}
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+        super.registerBlockIcons(register);
+        baseTexture = register.registerIcon(Chisel.MOD_ID + ":" + baseTexLocation);
+    }
 
-	public IIcon getBaseTex() {
-		return baseTexture;
-	}
+    public IIcon getBaseTex() {
+        return baseTexture;
+    }
 
-	@Override
-	public int getRenderType() {
-		return Chisel.renderLayeredId;
-	}
+    @Override
+    public int getRenderType() {
+        return Chisel.renderLayeredId;
+    }
 }

src/main/java/team/chisel/block/BlockCarvablePackedIce.java

@@ -3,11 +3,6 @@ package team.chisel.block;
 import java.util.List;
 import java.util.Random;
 
-import com.cricketcraft.chisel.api.ICarvable;
-import com.cricketcraft.chisel.api.carving.CarvableHelper;
-import com.cricketcraft.chisel.api.carving.IVariationInfo;
-import com.cricketcraft.chisel.api.rendering.ClientUtils;
-
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.texture.IIconRegister;
@@ -20,64 +15,69 @@ import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 
+import com.cricketcraft.chisel.api.ICarvable;
+import com.cricketcraft.chisel.api.carving.CarvableHelper;
+import com.cricketcraft.chisel.api.carving.IVariationInfo;
+import com.cricketcraft.chisel.api.rendering.ClientUtils;
+
 public class BlockCarvablePackedIce extends Block implements ICarvable {
 
-	public CarvableHelper carverHelper;
+    public CarvableHelper carverHelper;
 
-	public BlockCarvablePackedIce() {
-		super(Material.ice);
-		carverHelper = new CarvableHelper(this);
-		this.slipperiness = Blocks.packed_ice.slipperiness;
-	}
+    public BlockCarvablePackedIce() {
+        super(Material.ice);
+        carverHelper = new CarvableHelper(this);
+        this.slipperiness = Blocks.packed_ice.slipperiness;
+    }
 
-	@Override
-	public int getRenderType() {
-		return ClientUtils.renderCTMId;
-	}
+    @Override
+    public int getRenderType() {
+        return ClientUtils.renderCTMId;
+    }
 
-	@Override
-	public IIcon getIcon(int side, int metadata) {
-		return carverHelper.getIcon(side, metadata);
-	}
+    @Override
+    public IIcon getIcon(int side, int metadata) {
+        return carverHelper.getIcon(side, metadata);
+    }
 
-	@Override
-	public int quantityDropped(int meta, int fortune, Random random) {
-		return 0;
-	}
+    @Override
+    public int quantityDropped(int meta, int fortune, Random random) {
+        return 0;
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		carverHelper.registerBlockIcons("Chisel", this, register);
-	}
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+        carverHelper.registerBlockIcons("Chisel", this, register);
+    }
 
-	@SuppressWarnings({ "unchecked", "rawtypes" })
-	@Override
-	public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
-		carverHelper.registerSubBlocks(this, tabs, list);
-	}
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Override
+    public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
+        carverHelper.registerSubBlocks(this, tabs, list);
+    }
 
-	@Override
-	public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) {
-		super.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
+    @Override
+    public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) {
+        super.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
 
-		par2EntityPlayer.addStat(StatList.mineBlockStatArray[Block.getIdFromBlock(this)], 1);
-		par2EntityPlayer.addExhaustion(0.025F);
+        par2EntityPlayer.addStat(StatList.mineBlockStatArray[Block.getIdFromBlock(this)], 1);
+        par2EntityPlayer.addExhaustion(0.025F);
 
-		/*
-		 * if(this.canSilkHarvest(par1World, par2EntityPlayer, par3, par4, par5, par6) && EnchantmentHelper.getSilkTouchModifier(par2EntityPlayer)) { ItemStack itemstack =
-		 * this.createStackedBlock(par6);
-		 * 
-		 * if(itemstack != null) { this.dropBlockAsItem(par1World, par3, par4, par5, itemstack); } }
-		 */
-	}
+        /*
+         * if(this.canSilkHarvest(par1World, par2EntityPlayer, par3, par4, par5, par6) &&
+         * EnchantmentHelper.getSilkTouchModifier(par2EntityPlayer)) { ItemStack itemstack =
+         * this.createStackedBlock(par6); if(itemstack != null) { this.dropBlockAsItem(par1World, par3, par4, par5,
+         * itemstack); } }
+         */
+    }
 
-	@Override
-	public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
-		return carverHelper.getVariation(metadata);
-	}
+    @Override
+    public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
+        return carverHelper.getVariation(metadata);
+    }
 
-	@Override
-	public IVariationInfo getManager(int meta) {
-		return carverHelper.getVariation(meta);
-	}
+    @Override
+    public IVariationInfo getManager(int meta) {
+        return carverHelper.getVariation(meta);
+    }
 }

src/main/java/team/chisel/block/BlockCarvablePackedIceStairs.java

@@ -2,44 +2,45 @@ package team.chisel.block;
 
 import java.util.Random;
 
-import com.cricketcraft.chisel.api.carving.CarvableHelper;
-
-import team.chisel.init.ChiselBlocks;
 import net.minecraft.block.Block;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.world.World;
 
+import team.chisel.init.ChiselBlocks;
+
+import com.cricketcraft.chisel.api.carving.CarvableHelper;
+
 public class BlockCarvablePackedIceStairs extends BlockCarvableStairs {
 
-	public BlockCarvablePackedIceStairs(Block block, int meta, CarvableHelper helper) {
-		super(block, meta, helper);
+    public BlockCarvablePackedIceStairs(Block block, int meta, CarvableHelper helper) {
+        super(block, meta, helper);
 
-		slipperiness = 0.98F;
-		setTickRandomly(true);
-	}
+        slipperiness = 0.98F;
+        setTickRandomly(true);
+    }
 
-	@Override
-	public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) {
-		ChiselBlocks.packedice.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
-	}
+    @Override
+    public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) {
+        ChiselBlocks.packedice.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
+    }
 
-	@Override
-	public int quantityDropped(Random par1Random) {
-		return ChiselBlocks.packedice.quantityDropped(par1Random);
-	}
+    @Override
+    public int quantityDropped(Random par1Random) {
+        return ChiselBlocks.packedice.quantityDropped(par1Random);
+    }
 
-	@Override
-	public int damageDropped(int i) {
-		return 0;
-	}
+    @Override
+    public int damageDropped(int i) {
+        return 0;
+    }
 
-	@Override
-	public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {
-		ChiselBlocks.packedice.updateTick(par1World, par2, par3, par4, par5Random);
-	}
+    @Override
+    public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {
+        ChiselBlocks.packedice.updateTick(par1World, par2, par3, par4, par5Random);
+    }
 
-	@Override
-	public int getMobilityFlag() {
-		return 0;
-	}
+    @Override
+    public int getMobilityFlag() {
+        return 0;
+    }
 }

src/main/java/team/chisel/block/BlockCarvablePane.java

@@ -2,12 +2,6 @@ package team.chisel.block;
 
 import java.util.List;
 
-import com.cricketcraft.chisel.api.ICarvable;
-import com.cricketcraft.chisel.api.carving.CarvableHelper;
-import com.cricketcraft.chisel.api.carving.IVariationInfo;
-
-import team.chisel.client.render.RendererCTMPane;
-import com.cricketcraft.chisel.api.ChiselTabs;
 import net.minecraft.block.BlockPane;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.texture.IIconRegister;
@@ -15,66 +9,74 @@ import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.item.Item;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
+
+import team.chisel.client.render.RendererCTMPane;
+
+import com.cricketcraft.chisel.api.ChiselTabs;
+import com.cricketcraft.chisel.api.ICarvable;
+import com.cricketcraft.chisel.api.carving.CarvableHelper;
+import com.cricketcraft.chisel.api.carving.IVariationInfo;
+
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class BlockCarvablePane extends BlockPane implements ICarvable {
 
-	public CarvableHelper carverHelper;
-	public boolean isAlpha;
+    public CarvableHelper carverHelper;
+    public boolean isAlpha;
 
-	public BlockCarvablePane(Material material, boolean drops) {
-		super("", "", material, drops);
+    public BlockCarvablePane(Material material, boolean drops) {
+        super("", "", material, drops);
 
-		carverHelper = new CarvableHelper(this);
+        carverHelper = new CarvableHelper(this);
 
-		setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
-	}
+        setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
+    }
 
-	public BlockCarvablePane setStained(boolean a) {
-		this.isAlpha = a;
-		return this;
-	}
+    public BlockCarvablePane setStained(boolean a) {
+        this.isAlpha = a;
+        return this;
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public int getRenderBlockPass() {
-		return isAlpha ? 1 : 0;
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public int getRenderBlockPass() {
+        return isAlpha ? 1 : 0;
+    }
 
-	@Override
-	public int getRenderType() {
-		return RendererCTMPane.id;
-	}
+    @Override
+    public int getRenderType() {
+        return RendererCTMPane.id;
+    }
 
-	@Override
-	public IIcon getIcon(int side, int metadata) {
-		return carverHelper.getIcon(side, metadata);
-	}
+    @Override
+    public IIcon getIcon(int side, int metadata) {
+        return carverHelper.getIcon(side, metadata);
+    }
 
-	@Override
-	public int damageDropped(int i) {
-		return i;
-	}
+    @Override
+    public int damageDropped(int i) {
+        return i;
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		carverHelper.registerBlockIcons("Chisel", this, register);
-	}
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+        carverHelper.registerBlockIcons("Chisel", this, register);
+    }
 
-	@SuppressWarnings({ "unchecked", "rawtypes" })
-	@Override
-	public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
-		carverHelper.registerSubBlocks(this, tabs, list);
-	}
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Override
+    public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
+        carverHelper.registerSubBlocks(this, tabs, list);
+    }
 
-	@Override
-	public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
-		return carverHelper.getVariation(metadata);
-	}
+    @Override
+    public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
+        return carverHelper.getVariation(metadata);
+    }
 
-	@Override
-	public IVariationInfo getManager(int meta) {
-		return carverHelper.getVariation(meta);
-	}
+    @Override
+    public IVariationInfo getManager(int meta) {
+        return carverHelper.getVariation(meta);
+    }
 }

src/main/java/team/chisel/block/BlockCarvablePowered.java

@@ -5,25 +5,26 @@ import net.minecraft.world.IBlockAccess;
 
 public class BlockCarvablePowered extends BlockCarvable {
 
-	public BlockCarvablePowered(Material m) {
-		super(m);
-	}
+    public BlockCarvablePowered(Material m) {
+        super(m);
+    }
 
-	/**
-	 * Can this block provide power. Only wire currently seems to have this change based on its state.
-	 */
-	@Override
-	public boolean canProvidePower() {
-		return true;
-	}
+    /**
+     * Can this block provide power. Only wire currently seems to have this change based on its state.
+     */
+    @Override
+    public boolean canProvidePower() {
+        return true;
+    }
 
-	/**
-	 * Returns true if the block is emitting indirect/weak redstone power on the specified side. If isBlockNormalCube returns true, standard redstone propagation rules will apply instead and this will
-	 * not be called. Args: World, X, Y, Z, side. Note that the side is reversed - eg it is 1 (up) when checking the bottom of the block.
-	 */
-	@Override
-	public int isProvidingWeakPower(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5) {
-		return 15;
-	}
+    /**
+     * Returns true if the block is emitting indirect/weak redstone power on the specified side. If isBlockNormalCube
+     * returns true, standard redstone propagation rules will apply instead and this will not be called. Args: World, X,
+     * Y, Z, side. Note that the side is reversed - eg it is 1 (up) when checking the bottom of the block.
+     */
+    @Override
+    public int isProvidingWeakPower(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5) {
+        return 15;
+    }
 
 }

src/main/java/team/chisel/block/BlockCarvablePumpkin.java

@@ -1,11 +1,5 @@
 package team.chisel.block;
 
-import com.cricketcraft.chisel.api.ICarvable;
-import com.cricketcraft.chisel.api.carving.CarvableHelper;
-import com.cricketcraft.chisel.api.carving.IVariationInfo;
-
-import team.chisel.Chisel;
-import team.chisel.entity.EntityChiselSnowman;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockPumpkin;
 import net.minecraft.client.renderer.texture.IIconRegister;
@@ -15,111 +9,132 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
+
+import team.chisel.Chisel;
+import team.chisel.entity.EntityChiselSnowman;
+
+import com.cricketcraft.chisel.api.ICarvable;
+import com.cricketcraft.chisel.api.carving.CarvableHelper;
+import com.cricketcraft.chisel.api.carving.IVariationInfo;
+
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class BlockCarvablePumpkin extends BlockPumpkin implements ICarvable {
 
-	public CarvableHelper carverHelper;
+    public CarvableHelper carverHelper;
 
-	@SideOnly(Side.CLIENT)
-	private IIcon top, face;
+    @SideOnly(Side.CLIENT)
+    private IIcon top, face;
 
-	private String faceLocation;
+    private String faceLocation;
 
-	public BlockCarvablePumpkin(boolean isOn) {
-		super(isOn);
-		this.setStepSound(Block.soundTypeWood);
-		if (isOn)
-			setLightLevel(10.0F);
-		carverHelper = new CarvableHelper(this);
-	}
+    public BlockCarvablePumpkin(boolean isOn) {
+        super(isOn);
+        this.setStepSound(Block.soundTypeWood);
+        if (isOn) setLightLevel(10.0F);
+        carverHelper = new CarvableHelper(this);
+    }
 
-	@Override
-	public void onBlockAdded(World world, int x, int y, int z) {
-		if (world.getBlock(x, y - 1, z) == Blocks.snow && world.getBlock(x, y - 2, z) == Blocks.snow) {
-			if (!world.isRemote) {
-				// Let's grab the pumpkin before we start
-				ItemStack pumpkin = new ItemStack(world.getBlock(x, y, z), world.getBlockMetadata(x, y, z));
+    @Override
+    public void onBlockAdded(World world, int x, int y, int z) {
+        if (world.getBlock(x, y - 1, z) == Blocks.snow && world.getBlock(x, y - 2, z) == Blocks.snow) {
+            if (!world.isRemote) {
+                // Let's grab the pumpkin before we start
+                ItemStack pumpkin = new ItemStack(world.getBlock(x, y, z), world.getBlockMetadata(x, y, z));
 
-				world.setBlock(x, y, z, Blocks.air, 0, 2);
-				world.setBlock(x, y - 1, z, Blocks.air, 0, 2);
-				world.setBlock(x, y - 2, z, Blocks.air, 0, 2);
-				EntityChiselSnowman snowman = new EntityChiselSnowman(world);
-				snowman.setCurrentItemOrArmor(2, pumpkin);
-				snowman.setLocationAndAngles(x + 0.5D, y - 1.95D, z + 0.5D, 0.0F, 0.0F);
-				world.spawnEntityInWorld(snowman);
-				world.notifyBlockChange(x, y, z, Blocks.air);
-				world.notifyBlockChange(x, y - 1, z, Blocks.air);
-				world.notifyBlockChange(x, y - 2, z, Blocks.air);
-			}
+                world.setBlock(x, y, z, Blocks.air, 0, 2);
+                world.setBlock(x, y - 1, z, Blocks.air, 0, 2);
+                world.setBlock(x, y - 2, z, Blocks.air, 0, 2);
+                EntityChiselSnowman snowman = new EntityChiselSnowman(world);
+                snowman.setCurrentItemOrArmor(2, pumpkin);
+                snowman.setLocationAndAngles(x + 0.5D, y - 1.95D, z + 0.5D, 0.0F, 0.0F);
+                world.spawnEntityInWorld(snowman);
+                world.notifyBlockChange(x, y, z, Blocks.air);
+                world.notifyBlockChange(x, y - 1, z, Blocks.air);
+                world.notifyBlockChange(x, y - 2, z, Blocks.air);
+            }
 
-			// Spawn some lovely particles
-			for (int c = 0; c < 120; ++c) {
-				world.spawnParticle("snowshovel", x + world.rand.nextDouble(), y - 2 + world.rand.nextDouble() * 2.5D, z + world.rand.nextDouble(), 0.0D, 0.0D, 0.0D);
-			}
-		} else if (world.getBlock(x, y - 1, z) == Blocks.iron_block || world.getBlock(x, y - 2, z) == Blocks.iron_block) {
-			boolean flag = world.getBlock(x - 1, y - 1, z) == Blocks.iron_block && world.getBlock(x + 1, y - 1, z) == Blocks.iron_block;
-			boolean flag1 = world.getBlock(x, y - 1, z - 1) == Blocks.iron_block && world.getBlock(x, y - 1, z + 1) == Blocks.iron_block;
+            // Spawn some lovely particles
+            for (int c = 0; c < 120; ++c) {
+                world.spawnParticle(
+                        "snowshovel",
+                        x + world.rand.nextDouble(),
+                        y - 2 + world.rand.nextDouble() * 2.5D,
+                        z + world.rand.nextDouble(),
+                        0.0D,
+                        0.0D,
+                        0.0D);
+            }
+        } else
+            if (world.getBlock(x, y - 1, z) == Blocks.iron_block || world.getBlock(x, y - 2, z) == Blocks.iron_block) {
+                boolean flag = world.getBlock(x - 1, y - 1, z) == Blocks.iron_block
+                        && world.getBlock(x + 1, y - 1, z) == Blocks.iron_block;
+                boolean flag1 = world.getBlock(x, y - 1, z - 1) == Blocks.iron_block
+                        && world.getBlock(x, y - 1, z + 1) == Blocks.iron_block;
 
-			if (flag || flag1) {
-				world.setBlock(x, y, z, Blocks.air, 0, 2);
-				world.setBlock(x, y - 1, z, Blocks.air, 0, 2);
-				world.setBlock(x, y - 2, z, Blocks.air, 0, 2);
+                if (flag || flag1) {
+                    world.setBlock(x, y, z, Blocks.air, 0, 2);
+                    world.setBlock(x, y - 1, z, Blocks.air, 0, 2);
+                    world.setBlock(x, y - 2, z, Blocks.air, 0, 2);
 
-				if (flag) {
-					world.setBlock(x - 1, y - 1, z, Blocks.air, 0, 2);
-					world.setBlock(x + 1, y - 1, z, Blocks.air, 0, 2);
-				} else {
-					world.setBlock(x, y - 1, z - 1, Blocks.air, 0, 2);
-					world.setBlock(x, y - 1, z + 1, Blocks.air, 0, 2);
-				}
+                    if (flag) {
+                        world.setBlock(x - 1, y - 1, z, Blocks.air, 0, 2);
+                        world.setBlock(x + 1, y - 1, z, Blocks.air, 0, 2);
+                    } else {
+                        world.setBlock(x, y - 1, z - 1, Blocks.air, 0, 2);
+                        world.setBlock(x, y - 1, z + 1, Blocks.air, 0, 2);
+                    }
 
-				EntityIronGolem ironGolem = new EntityIronGolem(world);
-				ironGolem.setPlayerCreated(true);
-				ironGolem.setLocationAndAngles(x + 0.5D, y - 1.95D, z + 0.5D, 0.0F, 0.0F);
-				world.spawnEntityInWorld(ironGolem);
+                    EntityIronGolem ironGolem = new EntityIronGolem(world);
+                    ironGolem.setPlayerCreated(true);
+                    ironGolem.setLocationAndAngles(x + 0.5D, y - 1.95D, z + 0.5D, 0.0F, 0.0F);
+                    world.spawnEntityInWorld(ironGolem);
 
-				world.notifyBlockChange(x, y, z, Blocks.air);
-				world.notifyBlockChange(x, y - 1, z, Blocks.air);
-				world.notifyBlockChange(x, y - 2, z, Blocks.air);
+                    world.notifyBlockChange(x, y, z, Blocks.air);
+                    world.notifyBlockChange(x, y - 1, z, Blocks.air);
+                    world.notifyBlockChange(x, y - 2, z, Blocks.air);
 
-				if (flag) {
-					world.notifyBlockChange(x - 1, y - 1, z, Blocks.air);
-					world.notifyBlockChange(x + 1, y - 1, z, Blocks.air);
-				} else {
-					world.notifyBlockChange(x, y - 1, z - 1, Blocks.air);
-					world.notifyBlockChange(x, y - 1, z + 1, Blocks.air);
-				}
-			}
-		}
-	}
+                    if (flag) {
+                        world.notifyBlockChange(x - 1, y - 1, z, Blocks.air);
+                        world.notifyBlockChange(x + 1, y - 1, z, Blocks.air);
+                    } else {
+                        world.notifyBlockChange(x, y - 1, z - 1, Blocks.air);
+                        world.notifyBlockChange(x, y - 1, z + 1, Blocks.air);
+                    }
+                }
+            }
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public IIcon getIcon(int side, int meta) {
-		return side == 1 ? top : (side == 0 ? top : (meta == 2 && side == 2 ? face : (meta == 3 && side == 5 ? face
-				: (meta == 0 && side == 3 ? face : (meta == 1 && side == 4 ? face : this.blockIcon)))));
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIcon(int side, int meta) {
+        return side == 1 ? top
+                : (side == 0 ? top
+                        : (meta == 2 && side == 2 ? face
+                                : (meta == 3 && side == 5 ? face
+                                        : (meta == 0 && side == 3 ? face
+                                                : (meta == 1 && side == 4 ? face : this.blockIcon)))));
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister icon) {
-		top = icon.registerIcon(Chisel.MOD_ID + ":pumpkin/pumpkin_top");
-		face = icon.registerIcon(Chisel.MOD_ID + ":" + faceLocation);
-		this.blockIcon = icon.registerIcon(Chisel.MOD_ID + ":pumpkin/pumpkin_side");
-	}
+    @Override
+    public void registerBlockIcons(IIconRegister icon) {
+        top = icon.registerIcon(Chisel.MOD_ID + ":pumpkin/pumpkin_top");
+        face = icon.registerIcon(Chisel.MOD_ID + ":" + faceLocation);
+        this.blockIcon = icon.registerIcon(Chisel.MOD_ID + ":pumpkin/pumpkin_side");
+    }
 
-	@Override
-	public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
-		return carverHelper.getVariation(metadata);
-	}
+    @Override
+    public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
+        return carverHelper.getVariation(metadata);
+    }
 
-	@Override
-	public IVariationInfo getManager(int meta) {
-		return carverHelper.getVariation(meta);
-	}
+    @Override
+    public IVariationInfo getManager(int meta) {
+        return carverHelper.getVariation(meta);
+    }
 
-	public void setInformation(String textureLocation) {
-		this.faceLocation = textureLocation;
-	}
+    public void setInformation(String textureLocation) {
+        this.faceLocation = textureLocation;
+    }
 }

src/main/java/team/chisel/block/BlockCarvableSand.java

@@ -2,13 +2,6 @@ package team.chisel.block;
 
 import java.util.List;
 
-import com.cricketcraft.chisel.api.ICarvable;
-import com.cricketcraft.chisel.api.carving.CarvableHelper;
-import com.cricketcraft.chisel.api.carving.IVariationInfo;
-import com.cricketcraft.chisel.api.rendering.ClientUtils;
-
-import team.chisel.Chisel;
-import com.cricketcraft.chisel.api.ChiselTabs;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockSand;
 import net.minecraft.client.renderer.texture.IIconRegister;
@@ -16,158 +9,154 @@ import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.item.Item;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
+
+import team.chisel.Chisel;
+
+import com.cricketcraft.chisel.api.ChiselTabs;
+import com.cricketcraft.chisel.api.ICarvable;
+import com.cricketcraft.chisel.api.carving.CarvableHelper;
+import com.cricketcraft.chisel.api.carving.IVariationInfo;
+import com.cricketcraft.chisel.api.rendering.ClientUtils;
+
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class BlockCarvableSand extends BlockSand implements ICarvable {
 
-	public CarvableHelper carverHelper;
-	private boolean isAlpha;
+    public CarvableHelper carverHelper;
+    private boolean isAlpha;
 
-	public BlockCarvableSand() {
-		super();
-		carverHelper = new CarvableHelper(this);
-		setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
-	}
+    public BlockCarvableSand() {
+        super();
+        carverHelper = new CarvableHelper(this);
+        setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
+    }
 
-	public BlockCarvableSand setStained(boolean a) {
-		this.isAlpha = a;
-		return this;
-	}
+    public BlockCarvableSand setStained(boolean a) {
+        this.isAlpha = a;
+        return this;
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public int getRenderBlockPass() {
-		return isAlpha ? 1 : 0;
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public int getRenderBlockPass() {
+        return isAlpha ? 1 : 0;
+    }
 
-	@Override
-	public IIcon getIcon(int side, int metadata) {
-		return carverHelper.getIcon(side, metadata);
-	}
+    @Override
+    public IIcon getIcon(int side, int metadata) {
+        return carverHelper.getIcon(side, metadata);
+    }
 
-	@Override
-	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
-		return carverHelper.getIcon(world, x, y, z, side);
-	}
+    @Override
+    public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+        return carverHelper.getIcon(world, x, y, z, side);
+    }
 
-	@Override
-	public int damageDropped(int i) {
-		return i;
-	}
+    @Override
+    public int damageDropped(int i) {
+        return i;
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		carverHelper.registerBlockIcons("Chisel", this, register);
-	}
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+        carverHelper.registerBlockIcons("Chisel", this, register);
+    }
 
-	@SuppressWarnings({ "unchecked", "rawtypes" })
-	@Override
-	public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
-		carverHelper.registerSubBlocks(this, tabs, list);
-	}
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Override
+    public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
+        carverHelper.registerSubBlocks(this, tabs, list);
+    }
 
-	@Override
-	public int getRenderType() {
-		return ClientUtils.renderCTMId;
-	}
+    @Override
+    public int getRenderType() {
+        return ClientUtils.renderCTMId;
+    }
 
-	@Override
-	public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
-		return carverHelper.getVariation(metadata);
-	}
+    @Override
+    public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
+        return carverHelper.getVariation(metadata);
+    }
 
-	@Override
-	public IVariationInfo getManager(int meta) {
-		return carverHelper.getVariation(meta);
-	}
+    @Override
+    public IVariationInfo getManager(int meta) {
+        return carverHelper.getVariation(meta);
+    }
 
-	public static class SoundType extends Block.SoundType {
+    public static class SoundType extends Block.SoundType {
 
-		public final String soundNameStep;
-		public final String soundNameBreak;
-		public final String soundNamePlace;
+        public final String soundNameStep;
+        public final String soundNameBreak;
+        public final String soundNamePlace;
 
-		/**
-		 * Creates a SoundType with automatic names for step and break sounds. Sound names dig.soundName and step.soundName must be specified in the sounds.json
-		 * 
-		 * @param soundName
-		 *            block of the sound. Will automatically be expanded to "mod:dig.soundName" and "mod:step.soundName" respectively)
-		 * @param volume
-		 *            default 1.0f
-		 * @param frequency
-		 *            default 1.0f
-		 */
-		public SoundType(String soundName, float volume, float frequency) {
-			super(soundName, volume, frequency);
-			this.soundNameStep = null;
-			this.soundNameBreak = null;
-			this.soundNamePlace = null;
-		}
+        /**
+         * Creates a SoundType with automatic names for step and break sounds. Sound names dig.soundName and
+         * step.soundName must be specified in the sounds.json
+         * 
+         * @param soundName block of the sound. Will automatically be expanded to "mod:dig.soundName" and
+         *                  "mod:step.soundName" respectively)
+         * @param volume    default 1.0f
+         * @param frequency default 1.0f
+         */
+        public SoundType(String soundName, float volume, float frequency) {
+            super(soundName, volume, frequency);
+            this.soundNameStep = null;
+            this.soundNameBreak = null;
+            this.soundNamePlace = null;
+        }
 
-		/**
-		 * Creates a SoundType with manual names for step and break sounds. Sound names must be specified in the sounds.json
-		 * 
-		 * @param soundNameBreak
-		 *            block break sound
-		 * @param soundNameStep
-		 *            block step sound
-		 * @param volume
-		 *            default 1.0f
-		 * @param frequency
-		 *            default 1.0f
-		 */
-		public SoundType(String soundNameBreak, String soundNameStep, float volume, float frequency) {
-			super(soundNameStep, volume, frequency);
-			this.soundNameStep = soundNameStep;
-			this.soundNameBreak = soundNameBreak;
-			this.soundNamePlace = null;
-		}
+        /**
+         * Creates a SoundType with manual names for step and break sounds. Sound names must be specified in the
+         * sounds.json
+         * 
+         * @param soundNameBreak block break sound
+         * @param soundNameStep  block step sound
+         * @param volume         default 1.0f
+         * @param frequency      default 1.0f
+         */
+        public SoundType(String soundNameBreak, String soundNameStep, float volume, float frequency) {
+            super(soundNameStep, volume, frequency);
+            this.soundNameStep = soundNameStep;
+            this.soundNameBreak = soundNameBreak;
+            this.soundNamePlace = null;
+        }
 
-		/**
-		 * Creates a SoundType with manual names for step, break and place sounds. Sound names must be specified in the sounds.json
-		 * 
-		 * @param soundNameBreak
-		 *            block break sound
-		 * @param soundNameStep
-		 *            block step sound
-		 * @param soundNamePlace
-		 *            block place sound
-		 * @param volume
-		 *            default 1.0f
-		 * @param frequency
-		 *            default 1.0f
-		 */
-		public SoundType(String soundNameBreak, String soundNameStep, String soundNamePlace, float volume, float frequency) {
-			super(soundNameStep, volume, frequency);
-			this.soundNameStep = soundNameStep;
-			this.soundNameBreak = soundNameBreak;
-			this.soundNamePlace = soundNamePlace;
-		}
+        /**
+         * Creates a SoundType with manual names for step, break and place sounds. Sound names must be specified in the
+         * sounds.json
+         * 
+         * @param soundNameBreak block break sound
+         * @param soundNameStep  block step sound
+         * @param soundNamePlace block place sound
+         * @param volume         default 1.0f
+         * @param frequency      default 1.0f
+         */
+        public SoundType(String soundNameBreak, String soundNameStep, String soundNamePlace, float volume,
+                float frequency) {
+            super(soundNameStep, volume, frequency);
+            this.soundNameStep = soundNameStep;
+            this.soundNameBreak = soundNameBreak;
+            this.soundNamePlace = soundNamePlace;
+        }
 
-		@Override
-		public String getBreakSound() {
-			if (soundNameBreak == null)
-				return Chisel.MOD_ID + ":dig." + this.soundName;
-			else
-				return this.soundNameBreak;
-		}
+        @Override
+        public String getBreakSound() {
+            if (soundNameBreak == null) return Chisel.MOD_ID + ":dig." + this.soundName;
+            else return this.soundNameBreak;
+        }
 
-		@Override
-		public String getStepResourcePath() {
-			if (soundNameStep == null)
-				return Chisel.MOD_ID + ":step." + this.soundName;
-			else
-				return this.soundNameStep;
-		}
+        @Override
+        public String getStepResourcePath() {
+            if (soundNameStep == null) return Chisel.MOD_ID + ":step." + this.soundName;
+            else return this.soundNameStep;
+        }
 
-		@Override
-		public String func_150496_b() {
-			if (soundNamePlace == null)
-				return getBreakSound();
-			else
-				return this.soundNamePlace;
-		}
-	}
+        @Override
+        public String func_150496_b() {
+            if (soundNamePlace == null) return getBreakSound();
+            else return this.soundNamePlace;
+        }
+    }
 
 }

src/main/java/team/chisel/block/BlockCarvableSlab.java

@@ -1,5 +1,7 @@
 package team.chisel.block;
 
+import static net.minecraftforge.common.util.ForgeDirection.UP;
+
 import java.util.List;
 import java.util.Random;
 
@@ -14,126 +16,121 @@ import net.minecraft.util.MovingObjectPosition;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
+
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import static net.minecraftforge.common.util.ForgeDirection.UP;
 
 public class BlockCarvableSlab extends BlockCarvable {
 
-	public Block master;
-	public BlockCarvableSlab bottom;
-	public BlockCarvableSlab top;
-	public boolean isBottom;
+    public Block master;
+    public BlockCarvableSlab bottom;
+    public BlockCarvableSlab top;
+    public boolean isBottom;
 
-	public BlockCarvableSlab(BlockCarvable marble) {
-		opaque = true;
+    public BlockCarvableSlab(BlockCarvable marble) {
+        opaque = true;
 
-		setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
+        setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
 
-		master = marble;
-		bottom = this;
-		top = new BlockCarvableSlab(this);
+        master = marble;
+        bottom = this;
+        top = new BlockCarvableSlab(this);
 
-		isBottom = true;
-	}
+        isBottom = true;
+    }
 
-	public BlockCarvableSlab(BlockCarvableSlab bottomBlock) {
-		super();
-		setBlockBounds(0.0F, 0.5F, 0.0F, 1.0F, 1.0F, 1.0F);
-		master = bottomBlock.master;
-		bottom = bottomBlock;
-		top = this;
+    public BlockCarvableSlab(BlockCarvableSlab bottomBlock) {
+        super();
+        setBlockBounds(0.0F, 0.5F, 0.0F, 1.0F, 1.0F, 1.0F);
+        master = bottomBlock.master;
+        bottom = bottomBlock;
+        top = this;
 
-		carverHelper = bottomBlock.carverHelper;
-		isBottom = false;
-	}
+        carverHelper = bottomBlock.carverHelper;
+        isBottom = false;
+    }
 
-	@Override
-	public Block setBlockName(String p_149663_1_) {
-		if (this != top) {
-			top.setBlockName(p_149663_1_);
-		}
-		return super.setBlockName(p_149663_1_);
-	}
+    @Override
+    public Block setBlockName(String p_149663_1_) {
+        if (this != top) {
+            top.setBlockName(p_149663_1_);
+        }
+        return super.setBlockName(p_149663_1_);
+    }
 
-	@Override
-	public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4) {
-		if (isBottom) {
-			setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
-		} else {
-			setBlockBounds(0.0F, 0.5F, 0.0F, 1.0F, 1.0F, 1.0F);
-		}
-	}
+    @Override
+    public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4) {
+        if (isBottom) {
+            setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
+        } else {
+            setBlockBounds(0.0F, 0.5F, 0.0F, 1.0F, 1.0F, 1.0F);
+        }
+    }
 
-	@Override
-	public void setBlockBoundsForItemRender() {
-		setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
-	}
+    @Override
+    public void setBlockBoundsForItemRender() {
+        setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
+    }
 
-	@SuppressWarnings("rawtypes")
-	@Override
-	public void addCollisionBoxesToList(World par1World, int par2, int par3, int par4, AxisAlignedBB par5AxisAlignedBB, List par6List, Entity par7Entity) {
-		setBlockBoundsBasedOnState(par1World, par2, par3, par4);
-		super.addCollisionBoxesToList(par1World, par2, par3, par4, par5AxisAlignedBB, par6List, par7Entity);
-	}
+    @SuppressWarnings("rawtypes")
+    @Override
+    public void addCollisionBoxesToList(World par1World, int par2, int par3, int par4, AxisAlignedBB par5AxisAlignedBB,
+            List par6List, Entity par7Entity) {
+        setBlockBoundsBasedOnState(par1World, par2, par3, par4);
+        super.addCollisionBoxesToList(par1World, par2, par3, par4, par5AxisAlignedBB, par6List, par7Entity);
+    }
 
-	@Override
-	public boolean isOpaqueCube() {
-		return false;
-	}
+    @Override
+    public boolean isOpaqueCube() {
+        return false;
+    }
 
-	@Override
-	public int damageDropped(int meta) {
-		return meta;
-	}
+    @Override
+    public int damageDropped(int meta) {
+        return meta;
+    }
 
-	@Override
-	public Item getItemDropped(int par1, Random par2Random, int par3) {
-		return Item.getItemFromBlock(bottom);
-	}
+    @Override
+    public Item getItemDropped(int par1, Random par2Random, int par3) {
+        return Item.getItemFromBlock(bottom);
+    }
 
-	@Override
-	public boolean renderAsNormalBlock() {
-		return false;
-	}
+    @Override
+    public boolean renderAsNormalBlock() {
+        return false;
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public ItemStack getPickBlock(MovingObjectPosition mop, World world, int x, int y, int z) {
-		return new ItemStack(bottom, 1, world.getBlockMetadata(x, y, z));
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public ItemStack getPickBlock(MovingObjectPosition mop, World world, int x, int y, int z) {
+        return new ItemStack(bottom, 1, world.getBlockMetadata(x, y, z));
+    }
 
-	@Override
-	public IIcon getIcon(int side, int metadata) {
-		return carverHelper.getIcon(side, metadata);
-		// return master.getIcon(side, metadata);
-	}
+    @Override
+    public IIcon getIcon(int side, int metadata) {
+        return carverHelper.getIcon(side, metadata);
+        // return master.getIcon(side, metadata);
+    }
 
-	@SuppressWarnings("rawtypes")
-	@Override
-	public void getSubBlocks(Item block, CreativeTabs tabs, List list) {
-		if (isBottom)
-			super.getSubBlocks(block, tabs, list);
-	}
+    @SuppressWarnings("rawtypes")
+    @Override
+    public void getSubBlocks(Item block, CreativeTabs tabs, List list) {
+        if (isBottom) super.getSubBlocks(block, tabs, list);
+    }
 
-	/**
-	 * Checks if the block is a solid face on the given side, used by placement logic.
-	 *
-	 * @param world
-	 *            The current world
-	 * @param x
-	 *            X Position
-	 * @param y
-	 *            Y position
-	 * @param z
-	 *            Z position
-	 * @param side
-	 *            The side to check
-	 * @return True if the block is solid on the specified side.
-	 */
-	@Override
-	public boolean isSideSolid(IBlockAccess world, int x, int y, int z, ForgeDirection side) {
-		return !isBottom && (side == UP);
-	}
+    /**
+     * Checks if the block is a solid face on the given side, used by placement logic.
+     *
+     * @param world The current world
+     * @param x     X Position
+     * @param y     Y position
+     * @param z     Z position
+     * @param side  The side to check
+     * @return True if the block is solid on the specified side.
+     */
+    @Override
+    public boolean isSideSolid(IBlockAccess world, int x, int y, int z, ForgeDirection side) {
+        return !isBottom && (side == UP);
+    }
 
 }

src/main/java/team/chisel/block/BlockCarvableStairs.java

@@ -2,11 +2,6 @@ package team.chisel.block;
 
 import java.util.List;
 
-import com.cricketcraft.chisel.api.ICarvable;
-import com.cricketcraft.chisel.api.carving.CarvableHelper;
-import com.cricketcraft.chisel.api.carving.IVariationInfo;
-
-import team.chisel.client.render.RendererStairs;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockStairs;
 import net.minecraft.client.renderer.texture.IIconRegister;
@@ -19,75 +14,81 @@ import net.minecraft.util.MathHelper;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 
+import team.chisel.client.render.RendererStairs;
+
+import com.cricketcraft.chisel.api.ICarvable;
+import com.cricketcraft.chisel.api.carving.CarvableHelper;
+import com.cricketcraft.chisel.api.carving.IVariationInfo;
+
 public class BlockCarvableStairs extends BlockStairs implements ICarvable {
 
-	CarvableHelper carverHelper;
-	int blockMeta;
+    CarvableHelper carverHelper;
+    int blockMeta;
 
-	public BlockCarvableStairs(Block block, int meta, CarvableHelper helper) {
-		super(block, meta);
+    public BlockCarvableStairs(Block block, int meta, CarvableHelper helper) {
+        super(block, meta);
 
-		this.useNeighborBrightness = true;
-		carverHelper = helper;
-		blockMeta = meta;
-	}
+        this.useNeighborBrightness = true;
+        carverHelper = helper;
+        blockMeta = meta;
+    }
 
-	@Override
-	public IIcon getIcon(int side, int metadata) {
-		return carverHelper.getIcon(side, blockMeta + metadata / 8);
-	}
+    @Override
+    public IIcon getIcon(int side, int metadata) {
+        return carverHelper.getIcon(side, blockMeta + metadata / 8);
+    }
 
-	@Override
-	public int damageDropped(int i) {
-		return i / 8;
-	}
+    @Override
+    public int damageDropped(int i) {
+        return i / 8;
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		if (blockMeta == 0)
-			carverHelper.registerBlockIcons("Chisel", this, register);
-	}
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+        if (blockMeta == 0) carverHelper.registerBlockIcons("Chisel", this, register);
+    }
 
-	@SuppressWarnings({ "unchecked", "rawtypes" })
-	@Override
-	public void getSubBlocks(Item block, CreativeTabs tabs, List list) {
-		list.add(new ItemStack(block, 1, 0));
-		list.add(new ItemStack(block, 1, 8));
-	}
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Override
+    public void getSubBlocks(Item block, CreativeTabs tabs, List list) {
+        list.add(new ItemStack(block, 1, 0));
+        list.add(new ItemStack(block, 1, 8));
+    }
 
-	@Override
-	public int getRenderType() {
-		return RendererStairs.id;
-	}
+    @Override
+    public int getRenderType() {
+        return RendererStairs.id;
+    }
 
-	@Override
-	public void onBlockPlacedBy(World par1World, int par2, int par3, int par4, EntityLivingBase par5EntityLiving, ItemStack par6ItemStack) {
-		int meta = MathHelper.floor_double((par5EntityLiving.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;
+    @Override
+    public void onBlockPlacedBy(World par1World, int par2, int par3, int par4, EntityLivingBase par5EntityLiving,
+            ItemStack par6ItemStack) {
+        int meta = MathHelper.floor_double((par5EntityLiving.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;
 
-		// 0->2 2->3 3->0 1->1
-		meta = meta == 0 ? 2 : meta == 2 ? 3 : meta == 3 ? 0 : 1;
+        // 0->2 2->3 3->0 1->1
+        meta = meta == 0 ? 2 : meta == 2 ? 3 : meta == 3 ? 0 : 1;
 
-		meta += par1World.getBlockMetadata(par2, par3, par4) % 8; // add upside-down-ness
+        meta += par1World.getBlockMetadata(par2, par3, par4) % 8; // add upside-down-ness
 
-		if (par6ItemStack.getItemDamage() >= 8) {
-			meta += 8;
-		}
+        if (par6ItemStack.getItemDamage() >= 8) {
+            meta += 8;
+        }
 
-		par1World.setBlockMetadataWithNotify(par2, par3, par4, meta, 2);
-	}
+        par1World.setBlockMetadataWithNotify(par2, par3, par4, meta, 2);
+    }
 
-	@Override
-	public int onBlockPlaced(World world, int x, int y, int z, int side, float hx, float hy, float hz, int damage) {
-		return side != 0 && (side == 1 || hy <= 0.5D) ? damage : damage + 4;
-	}
+    @Override
+    public int onBlockPlaced(World world, int x, int y, int z, int side, float hx, float hy, float hz, int damage) {
+        return side != 0 && (side == 1 || hy <= 0.5D) ? damage : damage + 4;
+    }
 
-	@Override
-	public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
-		return carverHelper.getVariation(blockMeta + (metadata / 8));
-	}
+    @Override
+    public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
+        return carverHelper.getVariation(blockMeta + (metadata / 8));
+    }
 
-	@Override
-	public IVariationInfo getManager(int meta) {
-		return carverHelper.getVariation(blockMeta + (meta / 8));
-	}
+    @Override
+    public IVariationInfo getManager(int meta) {
+        return carverHelper.getVariation(blockMeta + (meta / 8));
+    }
 }

src/main/java/team/chisel/block/BlockCarvableTorch.java

@@ -2,83 +2,86 @@ package team.chisel.block;
 
 import java.util.Random;
 
-import com.cricketcraft.chisel.api.ICarvable;
-import com.cricketcraft.chisel.api.carving.CarvableHelper;
-import com.cricketcraft.chisel.api.carving.IVariationInfo;
-
-import team.chisel.Chisel;
-import com.cricketcraft.chisel.api.ChiselTabs;
 import net.minecraft.block.BlockTorch;
 import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
+
+import team.chisel.Chisel;
+
+import com.cricketcraft.chisel.api.ChiselTabs;
+import com.cricketcraft.chisel.api.ICarvable;
+import com.cricketcraft.chisel.api.carving.CarvableHelper;
+import com.cricketcraft.chisel.api.carving.IVariationInfo;
+
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class BlockCarvableTorch extends BlockTorch implements ICarvable {
 
-	public CarvableHelper carverHelper;
-	private String texLocation;
-	protected boolean emitsParticles = true;
-	public int idx;
+    public CarvableHelper carverHelper;
+    private String texLocation;
+    protected boolean emitsParticles = true;
+    public int idx;
 
-	public BlockCarvableTorch(int idx, String tex) {
-		super();
-		carverHelper = new CarvableHelper(this);
-		setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
-		setLightLevel(0.9375F);
-		setBlockName("torch");
-		this.idx = idx;
-		this.texLocation = tex;
-	}
+    public BlockCarvableTorch(int idx, String tex) {
+        super();
+        carverHelper = new CarvableHelper(this);
+        setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
+        setLightLevel(0.9375F);
+        setBlockName("torch");
+        this.idx = idx;
+        this.texLocation = tex;
+    }
 
-	@Override
-	public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
-		return carverHelper.getVariation(metadata);
-	}
+    @Override
+    public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
+        return carverHelper.getVariation(metadata);
+    }
 
-	@Override
-	public IVariationInfo getManager(int meta) {
-		return carverHelper.getVariation(meta);
-	}
+    @Override
+    public IVariationInfo getManager(int meta) {
+        return carverHelper.getVariation(meta);
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister icon) {
-		this.blockIcon = icon.registerIcon(Chisel.MOD_ID + ":torch/" + texLocation);
-	}
+    @Override
+    public void registerBlockIcons(IIconRegister icon) {
+        this.blockIcon = icon.registerIcon(Chisel.MOD_ID + ":torch/" + texLocation);
+    }
 
-	public BlockCarvableTorch disableParticles() {
-		this.emitsParticles = false;
-		return this;
-	}
+    public BlockCarvableTorch disableParticles() {
+        this.emitsParticles = false;
+        return this;
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public void randomDisplayTick(World p_149734_1_, int p_149734_2_, int p_149734_3_, int p_149734_4_, Random p_149734_5_) {
-		if (emitsParticles) {
-			int l = p_149734_1_.getBlockMetadata(p_149734_2_, p_149734_3_, p_149734_4_);
-			double d0 = p_149734_2_ + 0.5F;
-			double d1 = p_149734_3_ + 0.7F;
-			double d2 = p_149734_4_ + 0.5F;
-			double d3 = 0.2199999988079071D;
-			double d4 = 0.27000001072883606D;
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void randomDisplayTick(World p_149734_1_, int p_149734_2_, int p_149734_3_, int p_149734_4_,
+            Random p_149734_5_) {
+        if (emitsParticles) {
+            int l = p_149734_1_.getBlockMetadata(p_149734_2_, p_149734_3_, p_149734_4_);
+            double d0 = p_149734_2_ + 0.5F;
+            double d1 = p_149734_3_ + 0.7F;
+            double d2 = p_149734_4_ + 0.5F;
+            double d3 = 0.2199999988079071D;
+            double d4 = 0.27000001072883606D;
 
-			if (l == 1) {
-				p_149734_1_.spawnParticle("smoke", d0 - d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
-				p_149734_1_.spawnParticle("flame", d0 - d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
-			} else if (l == 2) {
-				p_149734_1_.spawnParticle("smoke", d0 + d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
-				p_149734_1_.spawnParticle("flame", d0 + d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
-			} else if (l == 3) {
-				p_149734_1_.spawnParticle("smoke", d0, d1 + d3, d2 - d4, 0.0D, 0.0D, 0.0D);
-				p_149734_1_.spawnParticle("flame", d0, d1 + d3, d2 - d4, 0.0D, 0.0D, 0.0D);
-			} else if (l == 4) {
-				p_149734_1_.spawnParticle("smoke", d0, d1 + d3, d2 + d4, 0.0D, 0.0D, 0.0D);
-				p_149734_1_.spawnParticle("flame", d0, d1 + d3, d2 + d4, 0.0D, 0.0D, 0.0D);
-			} else {
-				p_149734_1_.spawnParticle("smoke", d0, d1, d2, 0.0D, 0.0D, 0.0D);
-				p_149734_1_.spawnParticle("flame", d0, d1, d2, 0.0D, 0.0D, 0.0D);
-			}
-		}
-	}
-}
+            if (l == 1) {
+                p_149734_1_.spawnParticle("smoke", d0 - d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
+                p_149734_1_.spawnParticle("flame", d0 - d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
+            } else if (l == 2) {
+                p_149734_1_.spawnParticle("smoke", d0 + d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
+                p_149734_1_.spawnParticle("flame", d0 + d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
+            } else if (l == 3) {
+                p_149734_1_.spawnParticle("smoke", d0, d1 + d3, d2 - d4, 0.0D, 0.0D, 0.0D);
+                p_149734_1_.spawnParticle("flame", d0, d1 + d3, d2 - d4, 0.0D, 0.0D, 0.0D);
+            } else if (l == 4) {
+                p_149734_1_.spawnParticle("smoke", d0, d1 + d3, d2 + d4, 0.0D, 0.0D, 0.0D);
+                p_149734_1_.spawnParticle("flame", d0, d1 + d3, d2 + d4, 0.0D, 0.0D, 0.0D);
+            } else {
+                p_149734_1_.spawnParticle("smoke", d0, d1, d2, 0.0D, 0.0D, 0.0D);
+                p_149734_1_.spawnParticle("flame", d0, d1, d2, 0.0D, 0.0D, 0.0D);
+            }
+        }
+    }
+}

src/main/java/team/chisel/block/BlockCarvableWall.java

@@ -2,8 +2,6 @@ package team.chisel.block;
 
 import java.util.List;
 
-import com.cricketcraft.chisel.api.carving.CarvableHelper;
-
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockWall;
 import net.minecraft.client.renderer.texture.IIconRegister;
@@ -11,34 +9,36 @@ import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.item.Item;
 import net.minecraft.util.IIcon;
 
+import com.cricketcraft.chisel.api.carving.CarvableHelper;
+
 public class BlockCarvableWall extends BlockWall {
 
-	CarvableHelper carverHelper;
+    CarvableHelper carverHelper;
 
-	public BlockCarvableWall(Block block) {
-		super(block);
+    public BlockCarvableWall(Block block) {
+        super(block);
 
-		carverHelper = new CarvableHelper(this);
-	}
+        carverHelper = new CarvableHelper(this);
+    }
 
-	@Override
-	public IIcon getIcon(int side, int metadata) {
-		return carverHelper.getIcon(side, metadata);
-	}
+    @Override
+    public IIcon getIcon(int side, int metadata) {
+        return carverHelper.getIcon(side, metadata);
+    }
 
-	@Override
-	public int damageDropped(int i) {
-		return i;
-	}
+    @Override
+    public int damageDropped(int i) {
+        return i;
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		carverHelper.registerBlockIcons("Chisel", this, register);
-	}
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+        carverHelper.registerBlockIcons("Chisel", this, register);
+    }
 
-	@SuppressWarnings({ "unchecked", "rawtypes" })
-	@Override
-	public void getSubBlocks(Item block, CreativeTabs tabs, List list) {
-		carverHelper.registerSubBlocks(this, tabs, list);
-	}
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Override
+    public void getSubBlocks(Item block, CreativeTabs tabs, List list) {
+        carverHelper.registerSubBlocks(this, tabs, list);
+    }
 }

src/main/java/team/chisel/block/BlockCloud.java

@@ -2,7 +2,6 @@ package team.chisel.block;
 
 import java.util.Random;
 
-import team.chisel.config.Configurations;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.entity.Entity;
@@ -10,65 +9,67 @@ import net.minecraft.item.Item;
 import net.minecraft.util.AxisAlignedBB;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
+
+import team.chisel.config.Configurations;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class BlockCloud extends BlockCarvable {
 
-	public BlockCloud() {
-		super(Material.ice);
-		useNeighborBrightness = true;
-	}
+    public BlockCloud() {
+        super(Material.ice);
+        useNeighborBrightness = true;
+    }
 
-	@Override
-	public void onEntityCollidedWithBlock(World world, int i, int j, int k, Entity entity) {
-		entity.fallDistance = 0.0F;
+    @Override
+    public void onEntityCollidedWithBlock(World world, int i, int j, int k, Entity entity) {
+        entity.fallDistance = 0.0F;
 
-		if (entity.motionY < 0.0D) {
-			entity.motionY *= 0.0050000000000000001D;
-		} else if (entity.motionY > 0) {
-			entity.motionY += 0.0285;
-		}
-	}
+        if (entity.motionY < 0.0D) {
+            entity.motionY *= 0.0050000000000000001D;
+        } else if (entity.motionY > 0) {
+            entity.motionY += 0.0285;
+        }
+    }
 
-	@Override
-	public boolean isOpaqueCube() {
-		return false;
-	}
+    @Override
+    public boolean isOpaqueCube() {
+        return false;
+    }
 
-	@Override
-	public int getRenderBlockPass() {
-		return Configurations.ghostCloud ? 1 : 0;
-	}
+    @Override
+    public int getRenderBlockPass() {
+        return Configurations.ghostCloud ? 1 : 0;
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public boolean shouldSideBeRendered(IBlockAccess world, int x, int y, int z, int side) {
-		Block block = world.getBlock(x, y, z);
-		if (block == this) {
-			return false;
-		}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public boolean shouldSideBeRendered(IBlockAccess world, int x, int y, int z, int side) {
+        Block block = world.getBlock(x, y, z);
+        if (block == this) {
+            return false;
+        }
 
-		return super.shouldSideBeRendered(world, x, y, z, side);
-	}
+        return super.shouldSideBeRendered(world, x, y, z, side);
+    }
 
-	@Override
-	public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int i, int j, int k) {
-		return AxisAlignedBB.getBoundingBox(i + 0.2, j, k + 0.2, i + 0.8, j + 0.2, k + 0.8);
-	}
+    @Override
+    public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int i, int j, int k) {
+        return AxisAlignedBB.getBoundingBox(i + 0.2, j, k + 0.2, i + 0.8, j + 0.2, k + 0.8);
+    }
 
-	@Override
-	public Item getItemDropped(int par1, Random rand, int par3) {
-		return Item.getItemFromBlock(this);
-	}
+    @Override
+    public Item getItemDropped(int par1, Random rand, int par3) {
+        return Item.getItemFromBlock(this);
+    }
 
-	@Override
-	public int quantityDropped(Random rand) {
-		return rand.nextInt(2);
-	}
+    @Override
+    public int quantityDropped(Random rand) {
+        return rand.nextInt(2);
+    }
 
-	@Override
-	public int damageDropped(int meta) {
-		return meta;
-	}
+    @Override
+    public int damageDropped(int meta) {
+        return meta;
+    }
 }

src/main/java/team/chisel/block/BlockConcrete.java

@@ -6,6 +6,7 @@ import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.util.MathHelper;
 import net.minecraft.util.MovementInput;
 import net.minecraft.util.MovementInputFromOptions;
+
 import team.chisel.config.Configurations;
 import cpw.mods.fml.common.FMLCommonHandler;
 import cpw.mods.fml.common.eventhandler.SubscribeEvent;
@@ -16,30 +17,35 @@ import cpw.mods.fml.relauncher.SideOnly;
 
 public class BlockConcrete extends BlockCarvable {
 
-	public BlockConcrete() {
-		super();
-		FMLCommonHandler.instance().bus().register(this);
-	}
+    public BlockConcrete() {
+        super();
+        FMLCommonHandler.instance().bus().register(this);
+    }
 
-	@SideOnly(Side.CLIENT)
-	private static MovementInput manualInputCheck;
+    @SideOnly(Side.CLIENT)
+    private static MovementInput manualInputCheck;
 
-	@SubscribeEvent
-	@SideOnly(Side.CLIENT)
-	public void speedupPlayer(PlayerTickEvent event) {
-		if (event.phase == Phase.START && event.side.isClient() && event.player.onGround && event.player instanceof EntityPlayerSP) {
-			if (manualInputCheck == null) {
-				manualInputCheck = new MovementInputFromOptions(Minecraft.getMinecraft().gameSettings);
-			}
-			EntityPlayerSP player = (EntityPlayerSP) event.player;
-			Block below = player.worldObj.getBlock(MathHelper.floor_double(player.posX), MathHelper.floor_double(player.posY) - 2, MathHelper.floor_double(player.posZ));
-			if (below == this) {
-				manualInputCheck.updatePlayerMoveState();
-				if (manualInputCheck.moveForward != 0 || manualInputCheck.moveStrafe != 0) {
-					player.motionX *= Configurations.concreteVelocityMult + 0.05;
-					player.motionZ *= Configurations.concreteVelocityMult + 0.05;
-				}
-			}
-		}
-	}
+    @SubscribeEvent
+    @SideOnly(Side.CLIENT)
+    public void speedupPlayer(PlayerTickEvent event) {
+        if (event.phase == Phase.START && event.side.isClient()
+                && event.player.onGround
+                && event.player instanceof EntityPlayerSP) {
+            if (manualInputCheck == null) {
+                manualInputCheck = new MovementInputFromOptions(Minecraft.getMinecraft().gameSettings);
+            }
+            EntityPlayerSP player = (EntityPlayerSP) event.player;
+            Block below = player.worldObj.getBlock(
+                    MathHelper.floor_double(player.posX),
+                    MathHelper.floor_double(player.posY) - 2,
+                    MathHelper.floor_double(player.posZ));
+            if (below == this) {
+                manualInputCheck.updatePlayerMoveState();
+                if (manualInputCheck.moveForward != 0 || manualInputCheck.moveStrafe != 0) {
+                    player.motionX *= Configurations.concreteVelocityMult + 0.05;
+                    player.motionZ *= Configurations.concreteVelocityMult + 0.05;
+                }
+            }
+        }
+    }
 }

src/main/java/team/chisel/block/BlockEldritch.java

@@ -4,13 +4,13 @@ import team.chisel.Chisel;
 
 public class BlockEldritch extends BlockCarvable {
 
-	public BlockEldritch() {
-		super();
-	}
+    public BlockEldritch() {
+        super();
+    }
 
-	@Override
-	public int getRenderType() {
-		return Chisel.renderEldritchId;
-	}
+    @Override
+    public int getRenderType() {
+        return Chisel.renderEldritchId;
+    }
 
 }

src/main/java/team/chisel/block/BlockGrimstone.java

@@ -2,33 +2,33 @@ package team.chisel.block;
 
 import java.util.Random;
 
-import team.chisel.Chisel;
-import team.chisel.client.GeneralChiselClient;
-import team.chisel.utils.General;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.World;
 
+import team.chisel.Chisel;
+import team.chisel.client.GeneralChiselClient;
+import team.chisel.utils.General;
+
 public class BlockGrimstone extends BlockCarvable {
 
-	public IIcon iconStar;
+    public IIcon iconStar;
 
-	public BlockGrimstone(Material m) {
-		super(m);
-	}
+    public BlockGrimstone(Material m) {
+        super(m);
+    }
 
-	@Override
-	public void randomDisplayTick(World world, int x, int y, int z, Random random) {
-		if (General.rand.nextInt(4) == 0 && world.isRemote)
-			GeneralChiselClient.spawnGrimstoneFX(world, this, x, y, z);
-	}
+    @Override
+    public void randomDisplayTick(World world, int x, int y, int z, Random random) {
+        if (General.rand.nextInt(4) == 0 && world.isRemote) GeneralChiselClient.spawnGrimstoneFX(world, this, x, y, z);
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		super.registerBlockIcons(register);
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+        super.registerBlockIcons(register);
 
-		iconStar = register.registerIcon(Chisel.MOD_ID + ":grimstone/particles/star");
-	}
+        iconStar = register.registerIcon(Chisel.MOD_ID + ":grimstone/particles/star");
+    }
 
 }

src/main/java/team/chisel/block/BlockHolystone.java

@@ -2,34 +2,34 @@ package team.chisel.block;
 
 import java.util.Random;
 
-import team.chisel.client.GeneralChiselClient;
-import team.chisel.utils.General;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.World;
 
+import team.chisel.client.GeneralChiselClient;
+import team.chisel.utils.General;
+
 public class BlockHolystone extends BlockCarvable {
 
-	public IIcon iconStar;
+    public IIcon iconStar;
 
-	public BlockHolystone(Material m) {
-		super(m);
+    public BlockHolystone(Material m) {
+        super(m);
 
-		this.setLightLevel(0.25F);
-	}
+        this.setLightLevel(0.25F);
+    }
 
-	@Override
-	public void randomDisplayTick(World world, int x, int y, int z, Random random) {
-		if (General.rand.nextInt(4) == 0 && world.isRemote)
-			GeneralChiselClient.spawnHolystoneFX(world, this, x, y, z);
-	}
+    @Override
+    public void randomDisplayTick(World world, int x, int y, int z, Random random) {
+        if (General.rand.nextInt(4) == 0 && world.isRemote) GeneralChiselClient.spawnHolystoneFX(world, this, x, y, z);
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		super.registerBlockIcons(register);
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+        super.registerBlockIcons(register);
 
-		iconStar = register.registerIcon("Chisel:holystone/particles/star");
-	}
+        iconStar = register.registerIcon("Chisel:holystone/particles/star");
+    }
 
 }

src/main/java/team/chisel/block/BlockLavastone.java

@@ -2,26 +2,26 @@ package team.chisel.block;
 
 import java.util.Random;
 
-import team.chisel.client.GeneralChiselClient;
 import net.minecraft.block.material.Material;
 import net.minecraft.world.World;
 
+import team.chisel.client.GeneralChiselClient;
+
 public class BlockLavastone extends BlockMultiLayer {
 
-	public BlockLavastone(Material mat, String baseIcon) {
-		super(mat, baseIcon);
-		setLightLevel(1F);
-	}
+    public BlockLavastone(Material mat, String baseIcon) {
+        super(mat, baseIcon);
+        setLightLevel(1F);
+    }
 
-	@Override
-	public void randomDisplayTick(World world, int x, int y, int z, Random random) {
-		if (random.nextInt(8) == 0 && world.isRemote)
-			GeneralChiselClient.spawnLavastoneFX(world, this, x, y, z);
-	}
+    @Override
+    public void randomDisplayTick(World world, int x, int y, int z, Random random) {
+        if (random.nextInt(8) == 0 && world.isRemote) GeneralChiselClient.spawnLavastoneFX(world, this, x, y, z);
+    }
 
-	@Override
-	public boolean renderAsNormalBlock() {
-		return true;
-	}
+    @Override
+    public boolean renderAsNormalBlock() {
+        return true;
+    }
 
 }

src/main/java/team/chisel/block/BlockLeaf.java

@@ -5,12 +5,12 @@ import net.minecraft.init.Blocks;
 
 public class BlockLeaf extends BlockCarvable {
 
-	public BlockLeaf(Material material) {
-		super(material);
-	}
+    public BlockLeaf(Material material) {
+        super(material);
+    }
 
-	@Override
-	public boolean isOpaqueCube() {
-		return Blocks.leaves.isOpaqueCube();
-	}
+    @Override
+    public boolean isOpaqueCube() {
+        return Blocks.leaves.isOpaqueCube();
+    }
 }

src/main/java/team/chisel/block/BlockMultiLayer.java

@@ -2,10 +2,6 @@ package team.chisel.block;
 
 import java.util.List;
 
-import com.cricketcraft.chisel.api.ICarvable;
-import com.cricketcraft.chisel.api.carving.CarvableHelper;
-import com.cricketcraft.chisel.api.carving.IVariationInfo;
-
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.texture.IIconRegister;
@@ -14,52 +10,56 @@ import net.minecraft.item.Item;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
 
+import com.cricketcraft.chisel.api.ICarvable;
+import com.cricketcraft.chisel.api.carving.CarvableHelper;
+import com.cricketcraft.chisel.api.carving.IVariationInfo;
+
 public class BlockMultiLayer extends BlockMultiLayerBase implements ICarvable {
 
-	public CarvableHelper carverHelper;
+    public CarvableHelper carverHelper;
 
-	public BlockMultiLayer(Material mat, String baseIcon) {
-		super(mat, baseIcon);
+    public BlockMultiLayer(Material mat, String baseIcon) {
+        super(mat, baseIcon);
 
-		carverHelper = new CarvableHelper(this);
-	}
+        carverHelper = new CarvableHelper(this);
+    }
 
-	public BlockMultiLayer(Material mat, Block block) {
-		super(mat, block);
+    public BlockMultiLayer(Material mat, Block block) {
+        super(mat, block);
 
-		carverHelper = new CarvableHelper(this);
-	}
+        carverHelper = new CarvableHelper(this);
+    }
 
-	@Override
-	public IIcon getIcon(int side, int metadata) {
-		return carverHelper.getIcon(side, metadata);
-	}
+    @Override
+    public IIcon getIcon(int side, int metadata) {
+        return carverHelper.getIcon(side, metadata);
+    }
 
-	@Override
-	public int damageDropped(int i) {
-		return i;
-	}
+    @Override
+    public int damageDropped(int i) {
+        return i;
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		super.registerBlockIcons(register);
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+        super.registerBlockIcons(register);
 
-		carverHelper.registerBlockIcons("Chisel", this, register);
-	}
+        carverHelper.registerBlockIcons("Chisel", this, register);
+    }
 
-	@SuppressWarnings({ "unchecked", "rawtypes" })
-	@Override
-	public void getSubBlocks(Item block, CreativeTabs tabs, List list) {
-		carverHelper.registerSubBlocks(this, tabs, list);
-	}
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Override
+    public void getSubBlocks(Item block, CreativeTabs tabs, List list) {
+        carverHelper.registerSubBlocks(this, tabs, list);
+    }
 
-	@Override
-	public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
-		return carverHelper.getVariation(metadata);
-	}
+    @Override
+    public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
+        return carverHelper.getVariation(metadata);
+    }
 
-	@Override
-	public IVariationInfo getManager(int meta) {
-		return carverHelper.getVariation(meta);
-	}
+    @Override
+    public IVariationInfo getManager(int meta) {
+        return carverHelper.getVariation(meta);
+    }
 }

src/main/java/team/chisel/block/BlockMultiLayerBase.java

@@ -1,55 +1,55 @@
 package team.chisel.block;
 
-import team.chisel.client.render.RendererMultiLayer;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.util.IIcon;
 import net.minecraftforge.client.ForgeHooksClient;
 
+import team.chisel.client.render.RendererMultiLayer;
+
 public abstract class BlockMultiLayerBase extends Block {
 
-	public Block base;
-	public IIcon icon;
-	String iconFile;
+    public Block base;
+    public IIcon icon;
+    String iconFile;
 
-	public BlockMultiLayerBase(Material mat, Block base) {
-		super(mat);
+    public BlockMultiLayerBase(Material mat, Block base) {
+        super(mat);
 
-		this.base = base;
-	}
+        this.base = base;
+    }
 
-	public BlockMultiLayerBase(Material mat, String iconFile) {
-		super(mat);
+    public BlockMultiLayerBase(Material mat, String iconFile) {
+        super(mat);
 
-		this.iconFile = iconFile;
-	}
+        this.iconFile = iconFile;
+    }
 
-	@Override
-	public boolean renderAsNormalBlock() {
-		return false;
-	}
+    @Override
+    public boolean renderAsNormalBlock() {
+        return false;
+    }
 
-	@Override
-	public int getRenderType() {
-		return RendererMultiLayer.id;
-	}
+    @Override
+    public int getRenderType() {
+        return RendererMultiLayer.id;
+    }
 
-	@Override
-	public int getRenderBlockPass() {
-		return 1;
-	}
+    @Override
+    public int getRenderBlockPass() {
+        return 1;
+    }
 
-	@Override
-	public boolean canRenderInPass(int pass) {
-		ForgeHooksClient.setRenderPass(pass);
-		return pass == 1 || pass == 0;
-	}
+    @Override
+    public boolean canRenderInPass(int pass) {
+        ForgeHooksClient.setRenderPass(pass);
+        return pass == 1 || pass == 0;
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		if (iconFile != null)
-			icon = register.registerIcon(iconFile);
-	}
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+        if (iconFile != null) icon = register.registerIcon(iconFile);
+    }
 
 }

src/main/java/team/chisel/block/BlockPresent.java

@@ -2,12 +2,6 @@ package team.chisel.block;
 
 import java.util.List;
 
-import com.cricketcraft.chisel.api.ICarvable;
-import com.cricketcraft.chisel.api.carving.CarvableHelper;
-import com.cricketcraft.chisel.api.carving.IVariationInfo;
-
-import team.chisel.Chisel;
-import team.chisel.block.tileentity.TileEntityPresent;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.texture.IIconRegister;
@@ -24,206 +18,226 @@ import net.minecraft.util.MovingObjectPosition;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
+
+import team.chisel.Chisel;
+import team.chisel.block.tileentity.TileEntityPresent;
+
+import com.cricketcraft.chisel.api.ICarvable;
+import com.cricketcraft.chisel.api.carving.CarvableHelper;
+import com.cricketcraft.chisel.api.carving.IVariationInfo;
+
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class BlockPresent extends Block implements ICarvable {
 
-	public CarvableHelper carverHelper;
+    public CarvableHelper carverHelper;
 
-	private float minX, minY, minZ, maxX, maxY, maxZ;
+    private float minX, minY, minZ, maxX, maxY, maxZ;
 
-	public BlockPresent() {
-		super(Material.wood);
-		carverHelper = new CarvableHelper(this);
-		minX = 0.0625F;
-		minZ = 0.0625F;
-		maxX = 0.9375F;
-		maxY = 0.875F;
-		maxZ = 0.9375F;
-		setBlockBounds(minX, minY, minZ, maxX, maxY, maxZ);
-	}
+    public BlockPresent() {
+        super(Material.wood);
+        carverHelper = new CarvableHelper(this);
+        minX = 0.0625F;
+        minZ = 0.0625F;
+        maxX = 0.9375F;
+        maxY = 0.875F;
+        maxZ = 0.9375F;
+        setBlockBounds(minX, minY, minZ, maxX, maxY, maxZ);
+    }
 
-	public String getModelTexture(int type) {
-		return "textures/blocks/present/presentChest" + type;
-	}
+    public String getModelTexture(int type) {
+        return "textures/blocks/present/presentChest" + type;
+    }
 
-	@SuppressWarnings({ "unchecked", "rawtypes" })
-	@Override
-	public void getSubBlocks(Item item, CreativeTabs tab, List list) {
-		for (int i = 0; i < 16; i++) {
-			list.add(new ItemStack(item, 1, i));
-		}
-	}
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Override
+    public void getSubBlocks(Item item, CreativeTabs tab, List list) {
+        for (int i = 0; i < 16; i++) {
+            list.add(new ItemStack(item, 1, i));
+        }
+    }
 
-	@Override
-	public boolean isOpaqueCube() {
-		return false;
-	}
+    @Override
+    public boolean isOpaqueCube() {
+        return false;
+    }
 
-	@Override
-	public boolean renderAsNormalBlock() {
-		return false;
-	}
+    @Override
+    public boolean renderAsNormalBlock() {
+        return false;
+    }
 
-	@Override
-	public int getRenderType() {
-		return -1;
-	}
+    @Override
+    public int getRenderType() {
+        return -1;
+    }
 
-	@Override
-	public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase player, ItemStack stack) {
-		super.onBlockPlacedBy(world, x, y, z, player, stack);
-		int heading = MathHelper.floor_double(player.rotationYaw * 4.0F / 360.0F + 0.5D) & 3;
-		TileEntityPresent te = (TileEntityPresent) world.getTileEntity(x, y, z);
-		world.setBlockMetadataWithNotify(x, y, z, stack.getItemDamage(), 3);
-		te.setRotation(heading);
-		te.findConnections();
-		if (te.isConnected()) {
-			TileEntityPresent other = te.getConnection();
-			other.setRotation(heading);
-		}
-		world.markBlockForUpdate(x, y, z);
-	}
+    @Override
+    public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase player, ItemStack stack) {
+        super.onBlockPlacedBy(world, x, y, z, player, stack);
+        int heading = MathHelper.floor_double(player.rotationYaw * 4.0F / 360.0F + 0.5D) & 3;
+        TileEntityPresent te = (TileEntityPresent) world.getTileEntity(x, y, z);
+        world.setBlockMetadataWithNotify(x, y, z, stack.getItemDamage(), 3);
+        te.setRotation(heading);
+        te.findConnections();
+        if (te.isConnected()) {
+            TileEntityPresent other = te.getConnection();
+            other.setRotation(heading);
+        }
+        world.markBlockForUpdate(x, y, z);
+    }
 
-	@Override
-	public void breakBlock(World world, int x, int y, int z, Block present, int meta) {
+    @Override
+    public void breakBlock(World world, int x, int y, int z, Block present, int meta) {
 
-		TileEntityPresent tileEntityPresent = (TileEntityPresent) world.getTileEntity(x, y, z);
+        TileEntityPresent tileEntityPresent = (TileEntityPresent) world.getTileEntity(x, y, z);
 
-		if (tileEntityPresent != null) {
-			for (int c = 0; c < tileEntityPresent.getTrueSizeInventory(); c++) {
-				ItemStack itemStack = tileEntityPresent.getTrueStackInSlot(c);
+        if (tileEntityPresent != null) {
+            for (int c = 0; c < tileEntityPresent.getTrueSizeInventory(); c++) {
+                ItemStack itemStack = tileEntityPresent.getTrueStackInSlot(c);
 
-				if (itemStack != null) {
-					dropBlockAsItem(world, x, y, z, itemStack);
-				}
-			}
+                if (itemStack != null) {
+                    dropBlockAsItem(world, x, y, z, itemStack);
+                }
+            }
 
-			world.func_147453_f(x, y, z, this);
-		}
+            world.func_147453_f(x, y, z, this);
+        }
 
-		super.breakBlock(world, x, y, z, this, meta);
-	}
+        super.breakBlock(world, x, y, z, this, meta);
+    }
 
-	@Override
-	public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int hitX, float hitY, float hitZ, float p_149727_9_) {
-		if (!world.isSideSolid(x, y + 1, z, ForgeDirection.DOWN)) {
-			if (!world.isRemote) {
-				player.openGui(Chisel.instance, 2, world, x, y, z);
-	        }
-			return true;
-		}
-		return false;
-	}
+    @Override
+    public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int hitX, float hitY,
+            float hitZ, float p_149727_9_) {
+        if (!world.isSideSolid(x, y + 1, z, ForgeDirection.DOWN)) {
+            if (!world.isRemote) {
+                player.openGui(Chisel.instance, 2, world, x, y, z);
+            }
+            return true;
+        }
+        return false;
+    }
 
-	@Override
-	public AxisAlignedBB getSelectedBoundingBoxFromPool(World world, int x, int y, int z) {
-		if (world.getTileEntity(x, y, z) instanceof TileEntityPresent)
-			return getBoundingBox((TileEntityPresent) world.getTileEntity(x, y, z));
-		else
-			return null;
-	}
+    @Override
+    public AxisAlignedBB getSelectedBoundingBoxFromPool(World world, int x, int y, int z) {
+        if (world.getTileEntity(x, y, z) instanceof TileEntityPresent)
+            return getBoundingBox((TileEntityPresent) world.getTileEntity(x, y, z));
+        else return null;
+    }
 
-	@Override
-	public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int x, int y, int z) {
-		if (world.getTileEntity(x, y, z) instanceof TileEntityPresent)
-			return getBoundingBox((TileEntityPresent) world.getTileEntity(x, y, z));
-		else
-			return null;
-	}
+    @Override
+    public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int x, int y, int z) {
+        if (world.getTileEntity(x, y, z) instanceof TileEntityPresent)
+            return getBoundingBox((TileEntityPresent) world.getTileEntity(x, y, z));
+        else return null;
+    }
 
-	public AxisAlignedBB getBoundingBox(TileEntityPresent me) {
-		if (me == null) {
-			return AxisAlignedBB.getBoundingBox(minX, minY, minZ, maxX, maxY, maxZ);
-		}
-		int x = me.xCoord, y = me.yCoord, z = me.zCoord;
-		if (me.isConnected()) {
-			ForgeDirection dir = me.getConnectionDir();
-			// warning: magic below! Do not change this conditional
-			if (dir == ForgeDirection.EAST || (me.isParent() && dir == ForgeDirection.SOUTH) || (!me.isParent() && dir == ForgeDirection.SOUTH)) {
-				return AxisAlignedBB.getBoundingBox(x + minX, y + minY, z + minZ, x + maxX + dir.offsetX, y + maxY, z + maxZ + dir.offsetZ);
-			} else {
-				return AxisAlignedBB.getBoundingBox(x + dir.offsetX + minX, y + minY, z + dir.offsetZ + minZ, x + maxX, y + maxY, z + maxZ);
-			}
-		}
-		return AxisAlignedBB.getBoundingBox(x + minX, y + minY, z + minZ, x + maxX, y + maxY, z + maxZ);
-	}
+    public AxisAlignedBB getBoundingBox(TileEntityPresent me) {
+        if (me == null) {
+            return AxisAlignedBB.getBoundingBox(minX, minY, minZ, maxX, maxY, maxZ);
+        }
+        int x = me.xCoord, y = me.yCoord, z = me.zCoord;
+        if (me.isConnected()) {
+            ForgeDirection dir = me.getConnectionDir();
+            // warning: magic below! Do not change this conditional
+            if (dir == ForgeDirection.EAST || (me.isParent() && dir == ForgeDirection.SOUTH)
+                    || (!me.isParent() && dir == ForgeDirection.SOUTH)) {
+                return AxisAlignedBB.getBoundingBox(
+                        x + minX,
+                        y + minY,
+                        z + minZ,
+                        x + maxX + dir.offsetX,
+                        y + maxY,
+                        z + maxZ + dir.offsetZ);
+            } else {
+                return AxisAlignedBB.getBoundingBox(
+                        x + dir.offsetX + minX,
+                        y + minY,
+                        z + dir.offsetZ + minZ,
+                        x + maxX,
+                        y + maxY,
+                        z + maxZ);
+            }
+        }
+        return AxisAlignedBB.getBoundingBox(x + minX, y + minY, z + minZ, x + maxX, y + maxY, z + maxZ);
+    }
 
-	@Override
-	public void setBlockBoundsBasedOnState(IBlockAccess world, int x, int y, int z) {
-		TileEntityPresent te = (TileEntityPresent) world.getTileEntity(x, y, z);
-		if (!te.isConnected()) {
-			setBlockBounds(0.0625F, 0, 0.0625F, 0.9375F, 0.875F, 0.9365F);
-		} else {
-			ForgeDirection dir = te.getConnectionDir();
-			switch (dir) {
-			case EAST:
-				setBlockBounds(0.0625F, 0, 0.0625F, 1, 0.875F, 0.9365F);
-				break;
-			case NORTH:
-				setBlockBounds(0.0625F, 0, 0, 0.9375F, 0.875F, 0.9365F);
-				break;
-			case SOUTH:
-				setBlockBounds(0.0625F, 0, 0.0625F, 0.9375F, 0.875F, 1);
-				break;
-			case WEST:
-				setBlockBounds(0, 0, 0.0625F, 0.9375F, 0.875F, 0.9365F);
-				break;
-			default:
-				setBlockBounds(0.0625F, 0, 0.0625F, 0.9375F, 0.875F, 0.9365F);
-				break;
-			}
-		}
-	}
+    @Override
+    public void setBlockBoundsBasedOnState(IBlockAccess world, int x, int y, int z) {
+        TileEntityPresent te = (TileEntityPresent) world.getTileEntity(x, y, z);
+        if (!te.isConnected()) {
+            setBlockBounds(0.0625F, 0, 0.0625F, 0.9375F, 0.875F, 0.9365F);
+        } else {
+            ForgeDirection dir = te.getConnectionDir();
+            switch (dir) {
+                case EAST:
+                    setBlockBounds(0.0625F, 0, 0.0625F, 1, 0.875F, 0.9365F);
+                    break;
+                case NORTH:
+                    setBlockBounds(0.0625F, 0, 0, 0.9375F, 0.875F, 0.9365F);
+                    break;
+                case SOUTH:
+                    setBlockBounds(0.0625F, 0, 0.0625F, 0.9375F, 0.875F, 1);
+                    break;
+                case WEST:
+                    setBlockBounds(0, 0, 0.0625F, 0.9375F, 0.875F, 0.9365F);
+                    break;
+                default:
+                    setBlockBounds(0.0625F, 0, 0.0625F, 0.9375F, 0.875F, 0.9365F);
+                    break;
+            }
+        }
+    }
 
-	@Override
-	public boolean hasTileEntity(int metadata) {
-		return true;
-	}
+    @Override
+    public boolean hasTileEntity(int metadata) {
+        return true;
+    }
 
-	@Override
-	public TileEntity createTileEntity(World world, int metadata) {
-		return new TileEntityPresent();
-	}
+    @Override
+    public TileEntity createTileEntity(World world, int metadata) {
+        return new TileEntityPresent();
+    }
 
-	@Override
-	public boolean hasComparatorInputOverride() {
-		return true;
-	}
+    @Override
+    public boolean hasComparatorInputOverride() {
+        return true;
+    }
 
-	@Override
-	public int getComparatorInputOverride(World world, int x, int y, int z, int strength) {
-		TileEntity te = world.getTileEntity(x, y, z);
-		if (te instanceof TileEntityPresent) {
-			return Container.calcRedstoneFromInventory((TileEntityPresent) te);
-		}
-		return 0;
-	}
+    @Override
+    public int getComparatorInputOverride(World world, int x, int y, int z, int strength) {
+        TileEntity te = world.getTileEntity(x, y, z);
+        if (te instanceof TileEntityPresent) {
+            return Container.calcRedstoneFromInventory((TileEntityPresent) te);
+        }
+        return 0;
+    }
 
-	@Override
-	public int damageDropped(int meta) {
-		return meta;
-	}
+    @Override
+    public int damageDropped(int meta) {
+        return meta;
+    }
 
-	@Override
-	public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z) {
-		return new ItemStack(this, 1, world.getBlockMetadata(x, y, z));
-	}
+    @Override
+    public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z) {
+        return new ItemStack(this, 1, world.getBlockMetadata(x, y, z));
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public void registerBlockIcons(IIconRegister register) {
-		this.blockIcon = register.registerIcon("planks_oak");
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerBlockIcons(IIconRegister register) {
+        this.blockIcon = register.registerIcon("planks_oak");
+    }
 
-	@Override
-	public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
-		return carverHelper.getVariation(metadata);
-	}
+    @Override
+    public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
+        return carverHelper.getVariation(metadata);
+    }
 
-	@Override
-	public IVariationInfo getManager(int meta) {
-		return carverHelper.getVariation(meta);
-	}
-}
+    @Override
+    public IVariationInfo getManager(int meta) {
+        return carverHelper.getVariation(meta);
+    }
+}

src/main/java/team/chisel/block/BlockRoadLine.java

@@ -1,7 +1,5 @@
 package team.chisel.block;
 
-import team.chisel.Chisel;
-import team.chisel.config.Configurations;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.texture.IIconRegister;
@@ -10,83 +8,86 @@ import net.minecraft.util.AxisAlignedBB;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
+
+import team.chisel.Chisel;
+import team.chisel.config.Configurations;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class BlockRoadLine extends BlockCarvable {
 
-	public IIcon aloneIcon[] = new IIcon[4];
-	public IIcon halfLineIcon[] = new IIcon[4];
-	public IIcon fullLineIcon[] = new IIcon[4];
+    public IIcon aloneIcon[] = new IIcon[4];
+    public IIcon halfLineIcon[] = new IIcon[4];
+    public IIcon fullLineIcon[] = new IIcon[4];
 
-	public BlockRoadLine() {
-		super(Material.circuits);
+    public BlockRoadLine() {
+        super(Material.circuits);
 
-		if (Configurations.useRoadLineTool) {
-			this.setHarvestLevel(Configurations.getRoadLineTool, Configurations.roadLineToolLevel);
-		}
-		this.setBlockBounds(0.0f, 0.0f, 0.0f, 1.0f, 0.00390625f, 1.0f);
-		// this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.0625F, 1.0F);
-	}
+        if (Configurations.useRoadLineTool) {
+            this.setHarvestLevel(Configurations.getRoadLineTool, Configurations.roadLineToolLevel);
+        }
+        this.setBlockBounds(0.0f, 0.0f, 0.0f, 1.0f, 0.00390625f, 1.0f);
+        // this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.0625F, 1.0F);
+    }
 
-	@Override
-	public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4) {
-		return null;
-	}
+    @Override
+    public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4) {
+        return null;
+    }
 
-	@Override
-	public boolean isOpaqueCube() {
-		return false;
-	}
+    @Override
+    public boolean isOpaqueCube() {
+        return false;
+    }
 
-	@Override
-	public boolean renderAsNormalBlock() {
-		return false;
-	}
+    @Override
+    public boolean renderAsNormalBlock() {
+        return false;
+    }
 
-	@Override
-	public int getRenderType() {
-		return Chisel.roadLineId;
-	}
+    @Override
+    public int getRenderType() {
+        return Chisel.roadLineId;
+    }
 
-	@Override
-	public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4) {
-		return World.doesBlockHaveSolidTopSurface(par1World, par2, par3 - 1, par4) || par1World.getBlock(par2, par3 - 1, par4).equals(Blocks.glowstone);
-	}
+    @Override
+    public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4) {
+        return World.doesBlockHaveSolidTopSurface(par1World, par2, par3 - 1, par4)
+                || par1World.getBlock(par2, par3 - 1, par4).equals(Blocks.glowstone);
+    }
 
-	@Override
-	public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, Block block) {
-		if (par1World.isRemote)
-			return;
+    @Override
+    public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, Block block) {
+        if (par1World.isRemote) return;
 
-		if (!this.canPlaceBlockAt(par1World, par2, par3, par4)) {
-			this.dropBlockAsItem(par1World, par2, par3, par4, 0, 0);
-			par1World.setBlockToAir(par2, par3, par4);
-		}
+        if (!this.canPlaceBlockAt(par1World, par2, par3, par4)) {
+            this.dropBlockAsItem(par1World, par2, par3, par4, 0, 0);
+            par1World.setBlockToAir(par2, par3, par4);
+        }
 
-		super.onNeighborBlockChange(par1World, par2, par3, par4, block);
-	}
+        super.onNeighborBlockChange(par1World, par2, par3, par4, block);
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public void registerBlockIcons(IIconRegister reg) {
-		for (int i = 0; i < 4; i++) {
-			String[] texNames = { "white", "yellow", "double-white", "double-yellow" };
-			aloneIcon[i] = reg.registerIcon("Chisel:line-marking/" + texNames[i] + "-center");
-			halfLineIcon[i] = reg.registerIcon("Chisel:line-marking/" + texNames[i] + "-side");
-			fullLineIcon[i] = reg.registerIcon("Chisel:line-marking/" + texNames[i] + "-long");
-		}
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerBlockIcons(IIconRegister reg) {
+        for (int i = 0; i < 4; i++) {
+            String[] texNames = { "white", "yellow", "double-white", "double-yellow" };
+            aloneIcon[i] = reg.registerIcon("Chisel:line-marking/" + texNames[i] + "-center");
+            halfLineIcon[i] = reg.registerIcon("Chisel:line-marking/" + texNames[i] + "-side");
+            fullLineIcon[i] = reg.registerIcon("Chisel:line-marking/" + texNames[i] + "-long");
+        }
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public IIcon getIcon(int side, int metadata) {
-		return aloneIcon[metadata % aloneIcon.length];
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIcon(int side, int metadata) {
+        return aloneIcon[metadata % aloneIcon.length];
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
-		return getIcon(side, world.getBlockMetadata(x, y, z));
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+        return getIcon(side, world.getBlockMetadata(x, y, z));
+    }
 }

src/main/java/team/chisel/block/BlockSnakestoneObsidian.java

@@ -2,34 +2,35 @@ package team.chisel.block;
 
 import java.util.Random;
 
-import team.chisel.client.GeneralChiselClient;
 import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.World;
 
+import team.chisel.client.GeneralChiselClient;
+
 public class BlockSnakestoneObsidian extends BlockSnakestone {
 
-	public static IIcon[] particles = new IIcon[8];
+    public static IIcon[] particles = new IIcon[8];
 
-	public BlockSnakestoneObsidian(String iconPrefix) {
-		super(iconPrefix);
+    public BlockSnakestoneObsidian(String iconPrefix) {
+        super(iconPrefix);
 
-		flipTopTextures = true;
+        flipTopTextures = true;
 
-	}
+    }
 
-	@Override
-	public void randomDisplayTick(World world, int x, int y, int z, Random random) {
-		GeneralChiselClient.spawnSnakestoneObsidianFX(world, this, x, y, z);
-	}
+    @Override
+    public void randomDisplayTick(World world, int x, int y, int z, Random random) {
+        GeneralChiselClient.spawnSnakestoneObsidianFX(world, this, x, y, z);
+    }
 
-	@Override
-	public void registerBlockIcons(IIconRegister register) {
-		super.registerBlockIcons(register);
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+        super.registerBlockIcons(register);
 
-		for (int i = 0; i < particles.length; i++) {
-			particles[i] = register.registerIcon(iconPrefix + "particles/" + i);
-		}
-	}
+        for (int i = 0; i < particles.length; i++) {
+            particles[i] = register.registerIcon(iconPrefix + "particles/" + i);
+        }
+    }
 
 }

src/main/java/team/chisel/block/BlockWaterstone.java

@@ -4,12 +4,12 @@ import net.minecraft.block.material.Material;
 
 public class BlockWaterstone extends BlockMultiLayer {
 
-	public BlockWaterstone(Material mat, String baseIcon) {
-		super(mat, baseIcon);
-	}
+    public BlockWaterstone(Material mat, String baseIcon) {
+        super(mat, baseIcon);
+    }
 
-	@Override
-	public boolean renderAsNormalBlock() {
-		return true;
-	}
+    @Override
+    public boolean renderAsNormalBlock() {
+        return true;
+    }
 }

src/main/java/team/chisel/block/CarvableStairsMaker.java

@@ -2,41 +2,48 @@ package team.chisel.block;
 
 import net.minecraft.block.Block;
 import net.minecraft.item.ItemStack;
+
 import team.chisel.carving.Carving;
 import team.chisel.item.ItemCarvable;
 
 import com.cricketcraft.chisel.api.ChiselTabs;
 import com.cricketcraft.chisel.api.carving.CarvableHelper;
 import com.cricketcraft.chisel.api.carving.CarvingUtils;
-
 import cpw.mods.fml.common.registry.GameRegistry;
 
 public class CarvableStairsMaker {
 
-	public final CarvableHelper carverHelper;
-	private Block blockBase;
+    public final CarvableHelper carverHelper;
+    private Block blockBase;
 
-	public CarvableStairsMaker(Block base) {
-		blockBase = base;
-		carverHelper = new CarvableHelper(base);
-	}
+    public CarvableStairsMaker(Block base) {
+        blockBase = base;
+        carverHelper = new CarvableHelper(base);
+    }
 
-	public void create(String name, Block[] blocks) {
-		create(null, name, blocks);
-	}
+    public void create(String name, Block[] blocks) {
+        create(null, name, blocks);
+    }
 
-	public void create(IStairsCreator creator, String name, Block[] blocks) {
-		for (int i = 0; i < blocks.length; i++) {
-			String n = name + "." + i;
-			blocks[i] = creator == null ? new BlockCarvableStairs(blockBase, i * 2, carverHelper) : creator.create(blockBase, i * 2, carverHelper);
+    public void create(IStairsCreator creator, String name, Block[] blocks) {
+        for (int i = 0; i < blocks.length; i++) {
+            String n = name + "." + i;
+            blocks[i] = creator == null ? new BlockCarvableStairs(blockBase, i * 2, carverHelper)
+                    : creator.create(blockBase, i * 2, carverHelper);
 
-			blocks[i].setBlockName("chisel." + n).setCreativeTab(ChiselTabs.tabStairChiselBlocks);
-			GameRegistry.registerBlock(blocks[i], ItemCarvable.class, n);
+            blocks[i].setBlockName("chisel." + n).setCreativeTab(ChiselTabs.tabStairChiselBlocks);
+            GameRegistry.registerBlock(blocks[i], ItemCarvable.class, n);
 
-			for (int meta = 0; meta < 2 && i * 2 + meta < carverHelper.infoList.size(); meta++) {
-				Carving.chisel.addVariation(name, CarvingUtils.getDefaultVariationFor(blocks[i], meta * 8, i));
-				GameRegistry.addRecipe(new ItemStack(blocks[i], 4, meta * 8), "*  ", "** ", "***", '*', new ItemStack(blockBase, 1, i * 2 + meta));
-			}
-		}
-	}
+            for (int meta = 0; meta < 2 && i * 2 + meta < carverHelper.infoList.size(); meta++) {
+                Carving.chisel.addVariation(name, CarvingUtils.getDefaultVariationFor(blocks[i], meta * 8, i));
+                GameRegistry.addRecipe(
+                        new ItemStack(blocks[i], 4, meta * 8),
+                        "*  ",
+                        "** ",
+                        "***",
+                        '*',
+                        new ItemStack(blockBase, 1, i * 2 + meta));
+            }
+        }
+    }
 }

src/main/java/team/chisel/block/IStairsCreator.java

@@ -1,10 +1,10 @@
 package team.chisel.block;
 
-import com.cricketcraft.chisel.api.carving.CarvableHelper;
-
 import net.minecraft.block.Block;
 
+import com.cricketcraft.chisel.api.carving.CarvableHelper;
+
 public interface IStairsCreator {
 
-	public BlockCarvableStairs create(Block block, int meta, CarvableHelper helper);
+    public BlockCarvableStairs create(Block block, int meta, CarvableHelper helper);
 }

src/main/java/team/chisel/block/tileentity/IDoubleChest.java

@@ -4,26 +4,23 @@ import net.minecraft.item.ItemStack;
 
 public interface IDoubleChest {
 
-	/**
-	 * @return The size of this specific chest's inventory. Does not account for the connection.
-	 */
-	int getTrueSizeInventory();
+    /**
+     * @return The size of this specific chest's inventory. Does not account for the connection.
+     */
+    int getTrueSizeInventory();
 
-	/**
-	 * @param slot
-	 *            The true slot index.
-	 * @return The actual stack in this chest's slot. Does not account for the connection.
-	 */
-	ItemStack getTrueStackInSlot(int slot);
+    /**
+     * @param slot The true slot index.
+     * @return The actual stack in this chest's slot. Does not account for the connection.
+     */
+    ItemStack getTrueStackInSlot(int slot);
 
-	/**
-	 * Puts a stack in this chest's real slot at the given true index.
-	 * 
-	 * @param slot
-	 *            The true slot index.
-	 * @param stack
-	 *            The ItemStack to place in the slot.
-	 */
-	void putStackInTrueSlot(int slot, ItemStack stack);
+    /**
+     * Puts a stack in this chest's real slot at the given true index.
+     * 
+     * @param slot  The true slot index.
+     * @param stack The ItemStack to place in the slot.
+     */
+    void putStackInTrueSlot(int slot, ItemStack stack);
 
 }

src/main/java/team/chisel/block/tileentity/TileEntityAutoChisel.java

@@ -14,6 +14,7 @@ import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.EnumChatFormatting;
 import net.minecraft.util.StatCollector;
+
 import team.chisel.Features;
 import team.chisel.carving.Carving;
 import team.chisel.client.GeneralChiselClient;
@@ -30,437 +31,450 @@ import cpw.mods.fml.relauncher.SideOnly;
 
 public class TileEntityAutoChisel extends TileEntity implements ISidedInventory {
 
-	public enum Upgrade {
-		SPEED,
-		AUTOMATION,
-		STACK,
-		REVERSION;
-
-		public String getUnlocalizedName() {
-			if (Features.AUTO_CHISEL_UPGRADES.enabled()) {
-				return "item.upgrade_" + this.name().toLowerCase();
-			}
-			return "chisel.autochisel.upgrade.disabled";
-		}
-
-		public String getLocalizedName() {
-			String ret = StatCollector.translateToLocal("autochisel.slot." + this.name().toLowerCase() + ".tooltip");
-			if (!Features.AUTO_CHISEL_UPGRADES.enabled()) {
-				ret = EnumChatFormatting.RED.toString().concat(ret);
-			}
-			return ret;
-		}
-	}
-
-	public static final int BASE = 0, TARGET = 1, OUTPUT = 2, CHISEL = 3, MIN_UPGRADE = 4;
-	private static final int FAST_SPEED = 1, SLOW_SPEED = 4;
-
-	private int progress = 0;
-
-	private static EntityItem ghostItem;
-	boolean equal = false;
-	private ItemStack[] inventory = new ItemStack[8];
-	private String name = "autoChisel";
-
-	// client animation fields
-
-	// used for floating target
-	public float xRot, yRot, zRot;
-
-	// used for chisel item rotation
-	public static final int maxRot = 60;
-	public static final int rotAmnt = 15;
-	public float chiselRot;
-	public boolean chiseling = false, breakChisel = false;;
-	public int toChisel = 1;
-
-	private ItemStack lastBase;
-
-	@Override
-	public boolean canUpdate() {
-		return true;
-	}
-
-	@Override
-	public ItemStack decrStackSize(int slot, int size) {
-		if (inventory[slot] != null) {
-			ItemStack is;
-			if (inventory[slot].stackSize <= size) {
-				is = inventory[slot];
-				inventory[slot] = null;
-				return is;
-			} else {
-				is = inventory[slot].splitStack(size);
-				if (inventory[slot].stackSize == 0)
-					inventory[slot] = null;
-				return is;
-			}
-		} else {
-			return null;
-		}
-	}
-
-	@Override
-	public void readFromNBT(NBTTagCompound nbt) {
-		super.readFromNBT(nbt);
-		NBTTagList tags = nbt.getTagList("Items", 10);
-		inventory = new ItemStack[getSizeInventory()];
-
-		for (int i = 0; i < tags.tagCount(); i++) {
-			NBTTagCompound data = tags.getCompoundTagAt(i);
-			int j = data.getByte("Slot") & 255;
-
-			if (j >= 0 && j < inventory.length) {
-				inventory[j] = ItemStack.loadItemStackFromNBT(data);
-			}
-		}
-
-		if (nbt.hasKey("CustomName", 8)) {
-			this.name = nbt.getString("CustomName");
-		}
-	}
-
-	@Override
-	public void updateEntity() {
-
-		ItemStack base = inventory[BASE], target = getTarget(), output = inventory[OUTPUT];
-
-		if (!worldObj.isRemote && hasChisel() && base != null && target != null) {
-			if (canBeMadeFrom(base, target)) {
-				if (progress >= (hasUpgrade(Upgrade.SPEED) ? FAST_SPEED : SLOW_SPEED)) {
-
-					// reset progress
-					progress = 0;
-
-					// the max possible for this craft
-					int canBeMade = target.getMaxStackSize();
-
-					// if there are items in the output, they count towards the max we can make
-					if (output != null) {
-						canBeMade -= output.stackSize;
-					}
-
-					// can't make more than we have
-					canBeMade = Math.min(base.stackSize, canBeMade);
-
-					// if we can't make any, forget it
-					if (canBeMade <= 0) {
-						return;
-					}
-
-					// result will always be a copy of the target
-					ItemStack chiseled = target.copy();
-
-					// if we have the stack upgrade, boost the stack size to the max possible, otherwise just one
-					chiseled.stackSize = hasUpgrade(Upgrade.STACK) ? canBeMade : 1;
-
-					if (canChisel(chiseled)) {
-						// if our output is empty, just use the current result
-						if (output == null) {
-							setInventorySlotContents(OUTPUT, chiseled);
-						} else {
-							// otherwise just add our result to the existing stack
-							inventory[OUTPUT].stackSize += chiseled.stackSize;
-							slotChanged(OUTPUT);
-						}
-
-						chiselItem(chiseled.stackSize, target);
-
-						// remove what we made from the stack
-						base.stackSize -= chiseled.stackSize;
-						if (base.stackSize <= 0) {
-							setInventorySlotContents(BASE, null); // clear out 0 size itemstacks
-						}
-					}
-				} else if (worldObj.getTotalWorldTime() % 10 == 0) {
-					progress++;
-				}
-			}
-		} else if (worldObj.isRemote) {
-			if (chiseling) {
-				chiselRot += rotAmnt;
-				if (chiselRot >= maxRot) {
-					chiselItem(0, getTarget());
-				}
-			} else {
-				chiselRot = Math.max(chiselRot - rotAmnt, 0);
-			}
-		}
-	}
-
-	private ItemStack getTarget() {
-		if (inventory[BASE] != null && hasUpgrade(Upgrade.REVERSION)) {
-			// if we have a reversion upgrade, use that for the target
-			List<ItemStack> possible = Carving.chisel.getItemsForChiseling(inventory[BASE]);
-			return possible.isEmpty() ? null : possible.get(0);
-		} else {
-			return inventory[TARGET];
-		}
-	}
-
-	// lets make sure the user isn't trying to make something from a block that doesn't have this as a valid target
-	private boolean canBeMadeFrom(ItemStack from, ItemStack to) {
-		List<ItemStack> results = Carving.chisel.getItemsForChiseling(from);
-		for (ItemStack s : results) {
-			if (s.getItem() == to.getItem() && s.getItemDamage() == to.getItemDamage()) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	private boolean canChisel(ItemStack toMerge) {
-		// if the output slot is empty we can merge without checking
-		if (inventory[OUTPUT] == null) {
-			return true;
-		}
-
-		// need to check NBT as well as item
-		if (!toMerge.isItemEqual(inventory[OUTPUT]) || !ItemStack.areItemStackTagsEqual(toMerge, inventory[OUTPUT])) {
-			return false;
-		}
-
-		// we only care about metadata if the item has subtypes
-		if (toMerge.getHasSubtypes() && toMerge.getItemDamage() != inventory[OUTPUT].getItemDamage()) {
-			return false;
-		}
-
-		return ((IChiselItem) inventory[CHISEL].getItem()).canChisel(worldObj, inventory[CHISEL], General.getVariation(getTarget()));
-	}
-
-	private boolean hasChisel() {
-		return inventory[CHISEL] != null && inventory[CHISEL].getItem() instanceof IChiselItem && inventory[CHISEL].stackSize >= 1;
-	}
-
-	/** Calls IChiselItem#onChisel() and sends the chisel packet for sound/animation */
-	private void chiselItem(int chiseled, ItemStack target) {
-		if (!worldObj.isRemote) {
-			boolean breakChisel = false;
-			if (((IChiselItem) inventory[CHISEL].getItem()).onChisel(worldObj, inventory[CHISEL], General.getVariation(target))) {
-				inventory[CHISEL].setItemDamage(inventory[CHISEL].getItemDamage() + 1);
-				if (inventory[CHISEL].getItemDamage() >= inventory[CHISEL].getMaxDamage()) {
-					setInventorySlotContents(CHISEL, null);
-					breakChisel = true;
-				}
-			}
-			PacketHandler.INSTANCE.sendToDimension(new MessageAutoChisel(this, chiseled, true, breakChisel), worldObj.provider.dimensionId);
-		} else {
-			if (breakChisel) {
-				worldObj.playSound(xCoord + 0.5, yCoord + 0.5, zCoord + 0.5, "random.break", 0.8F, 0.8F + worldObj.rand.nextFloat() * 0.4F, false);
-			}
-			GeneralChiselClient.spawnAutoChiselFX(this, lastBase != null ? lastBase : inventory[BASE]);
-			chiseling = false;
-			if (lastBase != null) {
-				lastBase.stackSize -= toChisel;
-				if (lastBase.stackSize <= 0) {
-					lastBase = null;
-				}
-			}
-		}
-	}
-
-	@Override
-	public void writeToNBT(NBTTagCompound nbt) {
-		super.writeToNBT(nbt);
-		NBTTagList tags = new NBTTagList();
-
-		for (int i = 0; i < inventory.length; i++) {
-			if (inventory[i] != null) {
-				NBTTagCompound data = new NBTTagCompound();
-				data.setByte("Slot", (byte) i);
-				inventory[i].writeToNBT(data);
-				tags.appendTag(data);
-			}
-		}
-
-		nbt.setTag("Items", tags);
-
-		if (this.hasCustomInventoryName()) {
-			nbt.setString("CustomName", this.name);
-		}
-	}
-
-	@Override
-	public int getSizeInventory() {
-		return inventory.length;
-	}
-
-	@Override
-	public ItemStack getStackInSlot(int slot) {
-		return inventory[slot];
-	}
-
-	@Override
-	public ItemStack getStackInSlotOnClosing(int slot) {
-		if (inventory[slot] != null) {
-			ItemStack is = inventory[slot];
-			inventory[slot] = null;
-			return is;
-		} else
-			return null;
-	}
-
-	@Override
-	public void setInventorySlotContents(int slot, ItemStack stack) {
-		inventory[slot] = stack;
-
-		if (stack != null && stack.stackSize > getInventoryStackLimit()) {
-			stack.stackSize = getInventoryStackLimit();
-		}
-
-		if (worldObj.isRemote && slot == BASE && stack != null) {
-			lastBase = stack.copy();
-		}
-
-		if (!worldObj.isRemote) {
-			slotChanged(slot);
-		}
-	}
-
-	private void slotChanged(int slot) {
-		PacketHandler.INSTANCE.sendToDimension(new MessageSlotUpdate(this, slot, inventory[slot]), worldObj.provider.dimensionId);
-		markDirty();
-	}
-
-	@Override
-	public String getInventoryName() {
-		return name;
-	}
-
-	@Override
-	public final boolean isUseableByPlayer(EntityPlayer player) {
-		return true;
-	}
-
-	@Override
-	public int getInventoryStackLimit() {
-		return 64;
-	}
-
-	@Override
-	public boolean hasCustomInventoryName() {
-		return false;
-	}
-
-	@Override
-	public int[] getAccessibleSlotsFromSide(int side) {
-		return new int[] { BASE, TARGET, OUTPUT, CHISEL };
-	}
-
-	@Override
-	public boolean isItemValidForSlot(int slot, ItemStack itemStack) {
-		if (itemStack == null) {
-			return false;
-		}
-
-		switch (slot) {
-		case BASE:
-		case TARGET:
-			return !Carving.chisel.getItemsForChiseling(itemStack).isEmpty();
-		case OUTPUT:
-			return false;
-		case CHISEL:
-			return itemStack.getItem() instanceof IChiselItem;
-		default:
-			return Features.AUTO_CHISEL_UPGRADES.enabled() && itemStack.getItem() == ChiselItems.upgrade && Upgrade.values()[slot - MIN_UPGRADE].ordinal() == itemStack.getItemDamage();
-		}
-	}
-
-	@Override
-	public boolean canInsertItem(int slot, ItemStack itemStack, int side) {
-		return hasUpgrade(Upgrade.AUTOMATION) && (slot == BASE || slot == TARGET || slot == CHISEL);
-	}
-
-	@Override
-	public boolean canExtractItem(int slot, ItemStack itemStack, int side) {
-		return hasUpgrade(Upgrade.AUTOMATION) && slot == OUTPUT;
-	}
-
-	@Override
-	public void openInventory() {
-		;
-	}
-
-	@Override
-	public void closeInventory() {
-		;
-	}
-
-	@SideOnly(Side.CLIENT)
-	public EntityItem getItemForRendering(int slot) {
-		if (ghostItem == null) {
-			ghostItem = new EntityItem(worldObj);
-			ghostItem.hoverStart = 0.0F;
-		}
-
-		if (slot == BASE && lastBase != null) {
-			ghostItem.setEntityItemStack(lastBase.copy());
-			return ghostItem;
-		} else if (slot == TARGET) {
-			ItemStack target = getTarget();
-			if (target != null) {
-				ghostItem.setEntityItemStack(target);
-				return ghostItem;
-			}
-			return null;
-		} else if (inventory[slot] == null) {
-			return null;
-		} else {
-			ghostItem.setEntityItemStack(inventory[slot].copy());
-			return ghostItem;
-		}
-	}
-
-	@Override
-	public Packet getDescriptionPacket() {
-		NBTTagCompound tag = new NBTTagCompound();
-		writeToNBT(tag);
-		return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, 1, tag);
-	}
-
-	@Override
-	public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity packet) {
-		readFromNBT(packet.func_148857_g());
-	}
-
-	public boolean hasUpgrade(Upgrade upgrade) {
-		if (Features.AUTO_CHISEL_UPGRADES.enabled()) {
-			ItemStack stack = inventory[MIN_UPGRADE + upgrade.ordinal()];
-			if (stack != null) {
-				return stack.getItem() == ChiselItems.upgrade && stack.getItemDamage() == upgrade.ordinal();
-			}
-			return false;
-		}
-
-		return upgrade == Upgrade.REVERSION ? false : true;
-	}
-
-	public String getSlotTooltipUnloc(int slotNumber) {
-		String base = "autochisel.slot.%s.tooltip";
-		String name = null;
-		if (slotNumber < MIN_UPGRADE) {
-			if (slotNumber == TARGET) {
-				name = "target";
-			} else if (slotNumber == CHISEL) {
-				name = "chisel";
-			}
-			String unloc = name == null ? null : String.format(base, name);
-			return StatCollector.translateToLocal(unloc);
-		} else {
-			return Upgrade.values()[slotNumber - MIN_UPGRADE].getLocalizedName();
-		}
-	}
-
-	public void doChiselAnim(ItemStack lastChiseled, int chiseled, boolean playSound, boolean breakChisel) {
-		this.lastBase = lastChiseled == null ? null : lastChiseled.copy();
-		this.toChisel = chiseled;
-		if (playSound) {
-			this.chiseling = true;
-		}
-		this.breakChisel = breakChisel;
-	}
-
-	public ItemStack getLastBase() {
-		return lastBase == null ? null : lastBase.copy();
-	}
+    public enum Upgrade {
+
+        SPEED,
+        AUTOMATION,
+        STACK,
+        REVERSION;
+
+        public String getUnlocalizedName() {
+            if (Features.AUTO_CHISEL_UPGRADES.enabled()) {
+                return "item.upgrade_" + this.name().toLowerCase();
+            }
+            return "chisel.autochisel.upgrade.disabled";
+        }
+
+        public String getLocalizedName() {
+            String ret = StatCollector.translateToLocal("autochisel.slot." + this.name().toLowerCase() + ".tooltip");
+            if (!Features.AUTO_CHISEL_UPGRADES.enabled()) {
+                ret = EnumChatFormatting.RED.toString().concat(ret);
+            }
+            return ret;
+        }
+    }
+
+    public static final int BASE = 0, TARGET = 1, OUTPUT = 2, CHISEL = 3, MIN_UPGRADE = 4;
+    private static final int FAST_SPEED = 1, SLOW_SPEED = 4;
+
+    private int progress = 0;
+
+    private static EntityItem ghostItem;
+    boolean equal = false;
+    private ItemStack[] inventory = new ItemStack[8];
+    private String name = "autoChisel";
+
+    // client animation fields
+
+    // used for floating target
+    public float xRot, yRot, zRot;
+
+    // used for chisel item rotation
+    public static final int maxRot = 60;
+    public static final int rotAmnt = 15;
+    public float chiselRot;
+    public boolean chiseling = false, breakChisel = false;;
+    public int toChisel = 1;
+
+    private ItemStack lastBase;
+
+    @Override
+    public boolean canUpdate() {
+        return true;
+    }
+
+    @Override
+    public ItemStack decrStackSize(int slot, int size) {
+        if (inventory[slot] != null) {
+            ItemStack is;
+            if (inventory[slot].stackSize <= size) {
+                is = inventory[slot];
+                inventory[slot] = null;
+                return is;
+            } else {
+                is = inventory[slot].splitStack(size);
+                if (inventory[slot].stackSize == 0) inventory[slot] = null;
+                return is;
+            }
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound nbt) {
+        super.readFromNBT(nbt);
+        NBTTagList tags = nbt.getTagList("Items", 10);
+        inventory = new ItemStack[getSizeInventory()];
+
+        for (int i = 0; i < tags.tagCount(); i++) {
+            NBTTagCompound data = tags.getCompoundTagAt(i);
+            int j = data.getByte("Slot") & 255;
+
+            if (j >= 0 && j < inventory.length) {
+                inventory[j] = ItemStack.loadItemStackFromNBT(data);
+            }
+        }
+
+        if (nbt.hasKey("CustomName", 8)) {
+            this.name = nbt.getString("CustomName");
+        }
+    }
+
+    @Override
+    public void updateEntity() {
+
+        ItemStack base = inventory[BASE], target = getTarget(), output = inventory[OUTPUT];
+
+        if (!worldObj.isRemote && hasChisel() && base != null && target != null) {
+            if (canBeMadeFrom(base, target)) {
+                if (progress >= (hasUpgrade(Upgrade.SPEED) ? FAST_SPEED : SLOW_SPEED)) {
+
+                    // reset progress
+                    progress = 0;
+
+                    // the max possible for this craft
+                    int canBeMade = target.getMaxStackSize();
+
+                    // if there are items in the output, they count towards the max we can make
+                    if (output != null) {
+                        canBeMade -= output.stackSize;
+                    }
+
+                    // can't make more than we have
+                    canBeMade = Math.min(base.stackSize, canBeMade);
+
+                    // if we can't make any, forget it
+                    if (canBeMade <= 0) {
+                        return;
+                    }
+
+                    // result will always be a copy of the target
+                    ItemStack chiseled = target.copy();
+
+                    // if we have the stack upgrade, boost the stack size to the max possible, otherwise just one
+                    chiseled.stackSize = hasUpgrade(Upgrade.STACK) ? canBeMade : 1;
+
+                    if (canChisel(chiseled)) {
+                        // if our output is empty, just use the current result
+                        if (output == null) {
+                            setInventorySlotContents(OUTPUT, chiseled);
+                        } else {
+                            // otherwise just add our result to the existing stack
+                            inventory[OUTPUT].stackSize += chiseled.stackSize;
+                            slotChanged(OUTPUT);
+                        }
+
+                        chiselItem(chiseled.stackSize, target);
+
+                        // remove what we made from the stack
+                        base.stackSize -= chiseled.stackSize;
+                        if (base.stackSize <= 0) {
+                            setInventorySlotContents(BASE, null); // clear out 0 size itemstacks
+                        }
+                    }
+                } else if (worldObj.getTotalWorldTime() % 10 == 0) {
+                    progress++;
+                }
+            }
+        } else if (worldObj.isRemote) {
+            if (chiseling) {
+                chiselRot += rotAmnt;
+                if (chiselRot >= maxRot) {
+                    chiselItem(0, getTarget());
+                }
+            } else {
+                chiselRot = Math.max(chiselRot - rotAmnt, 0);
+            }
+        }
+    }
+
+    private ItemStack getTarget() {
+        if (inventory[BASE] != null && hasUpgrade(Upgrade.REVERSION)) {
+            // if we have a reversion upgrade, use that for the target
+            List<ItemStack> possible = Carving.chisel.getItemsForChiseling(inventory[BASE]);
+            return possible.isEmpty() ? null : possible.get(0);
+        } else {
+            return inventory[TARGET];
+        }
+    }
+
+    // lets make sure the user isn't trying to make something from a block that doesn't have this as a valid target
+    private boolean canBeMadeFrom(ItemStack from, ItemStack to) {
+        List<ItemStack> results = Carving.chisel.getItemsForChiseling(from);
+        for (ItemStack s : results) {
+            if (s.getItem() == to.getItem() && s.getItemDamage() == to.getItemDamage()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean canChisel(ItemStack toMerge) {
+        // if the output slot is empty we can merge without checking
+        if (inventory[OUTPUT] == null) {
+            return true;
+        }
+
+        // need to check NBT as well as item
+        if (!toMerge.isItemEqual(inventory[OUTPUT]) || !ItemStack.areItemStackTagsEqual(toMerge, inventory[OUTPUT])) {
+            return false;
+        }
+
+        // we only care about metadata if the item has subtypes
+        if (toMerge.getHasSubtypes() && toMerge.getItemDamage() != inventory[OUTPUT].getItemDamage()) {
+            return false;
+        }
+
+        return ((IChiselItem) inventory[CHISEL].getItem())
+                .canChisel(worldObj, inventory[CHISEL], General.getVariation(getTarget()));
+    }
+
+    private boolean hasChisel() {
+        return inventory[CHISEL] != null && inventory[CHISEL].getItem() instanceof IChiselItem
+                && inventory[CHISEL].stackSize >= 1;
+    }
+
+    /** Calls IChiselItem#onChisel() and sends the chisel packet for sound/animation */
+    private void chiselItem(int chiseled, ItemStack target) {
+        if (!worldObj.isRemote) {
+            boolean breakChisel = false;
+            if (((IChiselItem) inventory[CHISEL].getItem())
+                    .onChisel(worldObj, inventory[CHISEL], General.getVariation(target))) {
+                inventory[CHISEL].setItemDamage(inventory[CHISEL].getItemDamage() + 1);
+                if (inventory[CHISEL].getItemDamage() >= inventory[CHISEL].getMaxDamage()) {
+                    setInventorySlotContents(CHISEL, null);
+                    breakChisel = true;
+                }
+            }
+            PacketHandler.INSTANCE.sendToDimension(
+                    new MessageAutoChisel(this, chiseled, true, breakChisel),
+                    worldObj.provider.dimensionId);
+        } else {
+            if (breakChisel) {
+                worldObj.playSound(
+                        xCoord + 0.5,
+                        yCoord + 0.5,
+                        zCoord + 0.5,
+                        "random.break",
+                        0.8F,
+                        0.8F + worldObj.rand.nextFloat() * 0.4F,
+                        false);
+            }
+            GeneralChiselClient.spawnAutoChiselFX(this, lastBase != null ? lastBase : inventory[BASE]);
+            chiseling = false;
+            if (lastBase != null) {
+                lastBase.stackSize -= toChisel;
+                if (lastBase.stackSize <= 0) {
+                    lastBase = null;
+                }
+            }
+        }
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound nbt) {
+        super.writeToNBT(nbt);
+        NBTTagList tags = new NBTTagList();
+
+        for (int i = 0; i < inventory.length; i++) {
+            if (inventory[i] != null) {
+                NBTTagCompound data = new NBTTagCompound();
+                data.setByte("Slot", (byte) i);
+                inventory[i].writeToNBT(data);
+                tags.appendTag(data);
+            }
+        }
+
+        nbt.setTag("Items", tags);
+
+        if (this.hasCustomInventoryName()) {
+            nbt.setString("CustomName", this.name);
+        }
+    }
+
+    @Override
+    public int getSizeInventory() {
+        return inventory.length;
+    }
+
+    @Override
+    public ItemStack getStackInSlot(int slot) {
+        return inventory[slot];
+    }
+
+    @Override
+    public ItemStack getStackInSlotOnClosing(int slot) {
+        if (inventory[slot] != null) {
+            ItemStack is = inventory[slot];
+            inventory[slot] = null;
+            return is;
+        } else return null;
+    }
+
+    @Override
+    public void setInventorySlotContents(int slot, ItemStack stack) {
+        inventory[slot] = stack;
+
+        if (stack != null && stack.stackSize > getInventoryStackLimit()) {
+            stack.stackSize = getInventoryStackLimit();
+        }
+
+        if (worldObj.isRemote && slot == BASE && stack != null) {
+            lastBase = stack.copy();
+        }
+
+        if (!worldObj.isRemote) {
+            slotChanged(slot);
+        }
+    }
+
+    private void slotChanged(int slot) {
+        PacketHandler.INSTANCE
+                .sendToDimension(new MessageSlotUpdate(this, slot, inventory[slot]), worldObj.provider.dimensionId);
+        markDirty();
+    }
+
+    @Override
+    public String getInventoryName() {
+        return name;
+    }
+
+    @Override
+    public final boolean isUseableByPlayer(EntityPlayer player) {
+        return true;
+    }
+
+    @Override
+    public int getInventoryStackLimit() {
+        return 64;
+    }
+
+    @Override
+    public boolean hasCustomInventoryName() {
+        return false;
+    }
+
+    @Override
+    public int[] getAccessibleSlotsFromSide(int side) {
+        return new int[] { BASE, TARGET, OUTPUT, CHISEL };
+    }
+
+    @Override
+    public boolean isItemValidForSlot(int slot, ItemStack itemStack) {
+        if (itemStack == null) {
+            return false;
+        }
+
+        switch (slot) {
+            case BASE:
+            case TARGET:
+                return !Carving.chisel.getItemsForChiseling(itemStack).isEmpty();
+            case OUTPUT:
+                return false;
+            case CHISEL:
+                return itemStack.getItem() instanceof IChiselItem;
+            default:
+                return Features.AUTO_CHISEL_UPGRADES.enabled() && itemStack.getItem() == ChiselItems.upgrade
+                        && Upgrade.values()[slot - MIN_UPGRADE].ordinal() == itemStack.getItemDamage();
+        }
+    }
+
+    @Override
+    public boolean canInsertItem(int slot, ItemStack itemStack, int side) {
+        return hasUpgrade(Upgrade.AUTOMATION) && (slot == BASE || slot == TARGET || slot == CHISEL);
+    }
+
+    @Override
+    public boolean canExtractItem(int slot, ItemStack itemStack, int side) {
+        return hasUpgrade(Upgrade.AUTOMATION) && slot == OUTPUT;
+    }
+
+    @Override
+    public void openInventory() {
+        ;
+    }
+
+    @Override
+    public void closeInventory() {
+        ;
+    }
+
+    @SideOnly(Side.CLIENT)
+    public EntityItem getItemForRendering(int slot) {
+        if (ghostItem == null) {
+            ghostItem = new EntityItem(worldObj);
+            ghostItem.hoverStart = 0.0F;
+        }
+
+        if (slot == BASE && lastBase != null) {
+            ghostItem.setEntityItemStack(lastBase.copy());
+            return ghostItem;
+        } else if (slot == TARGET) {
+            ItemStack target = getTarget();
+            if (target != null) {
+                ghostItem.setEntityItemStack(target);
+                return ghostItem;
+            }
+            return null;
+        } else if (inventory[slot] == null) {
+            return null;
+        } else {
+            ghostItem.setEntityItemStack(inventory[slot].copy());
+            return ghostItem;
+        }
+    }
+
+    @Override
+    public Packet getDescriptionPacket() {
+        NBTTagCompound tag = new NBTTagCompound();
+        writeToNBT(tag);
+        return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, 1, tag);
+    }
+
+    @Override
+    public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity packet) {
+        readFromNBT(packet.func_148857_g());
+    }
+
+    public boolean hasUpgrade(Upgrade upgrade) {
+        if (Features.AUTO_CHISEL_UPGRADES.enabled()) {
+            ItemStack stack = inventory[MIN_UPGRADE + upgrade.ordinal()];
+            if (stack != null) {
+                return stack.getItem() == ChiselItems.upgrade && stack.getItemDamage() == upgrade.ordinal();
+            }
+            return false;
+        }
+
+        return upgrade == Upgrade.REVERSION ? false : true;
+    }
+
+    public String getSlotTooltipUnloc(int slotNumber) {
+        String base = "autochisel.slot.%s.tooltip";
+        String name = null;
+        if (slotNumber < MIN_UPGRADE) {
+            if (slotNumber == TARGET) {
+                name = "target";
+            } else if (slotNumber == CHISEL) {
+                name = "chisel";
+            }
+            String unloc = name == null ? null : String.format(base, name);
+            return StatCollector.translateToLocal(unloc);
+        } else {
+            return Upgrade.values()[slotNumber - MIN_UPGRADE].getLocalizedName();
+        }
+    }
+
+    public void doChiselAnim(ItemStack lastChiseled, int chiseled, boolean playSound, boolean breakChisel) {
+        this.lastBase = lastChiseled == null ? null : lastChiseled.copy();
+        this.toChisel = chiseled;
+        if (playSound) {
+            this.chiseling = true;
+        }
+        this.breakChisel = breakChisel;
+    }
+
+    public ItemStack getLastBase() {
+        return lastBase == null ? null : lastBase.copy();
+    }
 }

src/main/java/team/chisel/block/tileentity/TileEntityCarvableBeacon.java

@@ -2,14 +2,15 @@ package team.chisel.block.tileentity;
 
 import net.minecraft.tileentity.TileEntityBeacon;
 import net.minecraft.util.AxisAlignedBB;
+
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class TileEntityCarvableBeacon extends TileEntityBeacon {
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public AxisAlignedBB getRenderBoundingBox() {
-		return INFINITE_EXTENT_AABB;
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public AxisAlignedBB getRenderBoundingBox() {
+        return INFINITE_EXTENT_AABB;
+    }
 }

src/main/java/team/chisel/block/tileentity/TileEntityPresent.java

@@ -1,8 +1,5 @@
 package team.chisel.block.tileentity;
 
-import team.chisel.init.ChiselBlocks;
-import team.chisel.network.PacketHandler;
-import team.chisel.network.message.MessagePresentConnect;
 import net.minecraft.block.Block;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.IInventory;
@@ -17,349 +14,358 @@ import net.minecraft.util.AxisAlignedBB;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
 
+import team.chisel.init.ChiselBlocks;
+import team.chisel.network.PacketHandler;
+import team.chisel.network.message.MessagePresentConnect;
+
 public class TileEntityPresent extends TileEntity implements IInventory, IDoubleChest {
 
-	private TileEntityPresent connection = null;
-	// If cachedDir is non-null, but connection is null, this present must be
-	// connected to an unloaded present. This is handled appropriately.
-	private ForgeDirection cachedDir = null;
-	private boolean isParent;
-	private final ItemStack[] inventory = new ItemStack[27];
-	private int rotation;
-	private boolean autoSearch = true;
+    private TileEntityPresent connection = null;
+    // If cachedDir is non-null, but connection is null, this present must be
+    // connected to an unloaded present. This is handled appropriately.
+    private ForgeDirection cachedDir = null;
+    private boolean isParent;
+    private final ItemStack[] inventory = new ItemStack[27];
+    private int rotation;
+    private boolean autoSearch = true;
 
-	@Override
-	public void updateEntity() {
-		if (!isConnected() && autoSearch && worldObj != null /* ugh */) {
-			if (cachedDir != null) {
-				connectTo(cachedDir);
-			} else if (!worldObj.isRemote) {
-				findConnections();
-			}
-			autoSearch = false;
-		}
-	}
+    @Override
+    public void updateEntity() {
+        if (!isConnected() && autoSearch && worldObj != null /* ugh */) {
+            if (cachedDir != null) {
+                connectTo(cachedDir);
+            } else if (!worldObj.isRemote) {
+                findConnections();
+            }
+            autoSearch = false;
+        }
+    }
 
-	public boolean isConnected() {
-		return connection != null;
-	}
+    public boolean isConnected() {
+        return connection != null;
+    }
 
-	private boolean connectTo(TileEntityPresent present, ForgeDirection dir) {
-		if (present.getBlockMetadata() == getBlockMetadata() && !present.isConnected() && (present.cachedDir == null || present.cachedDir == dir.getOpposite())
-				&& Math.abs(present.xCoord - xCoord + present.yCoord - yCoord + present.zCoord - zCoord) == 1) {
-			connection = present;
-			connection.connection = this;
-			connection.cachedDir = dir.getOpposite();
-			connection.markDirty();
-			cachedDir = dir;
-			isParent = !present.isParent;
-			markDirty();
-			PacketHandler.INSTANCE.sendToDimension(new MessagePresentConnect(this, dir, true), worldObj.provider.dimensionId);
-			return true;
-		}
-		return false;
-	}
+    private boolean connectTo(TileEntityPresent present, ForgeDirection dir) {
+        if (present.getBlockMetadata() == getBlockMetadata() && !present.isConnected()
+                && (present.cachedDir == null || present.cachedDir == dir.getOpposite())
+                && Math.abs(present.xCoord - xCoord + present.yCoord - yCoord + present.zCoord - zCoord) == 1) {
+            connection = present;
+            connection.connection = this;
+            connection.cachedDir = dir.getOpposite();
+            connection.markDirty();
+            cachedDir = dir;
+            isParent = !present.isParent;
+            markDirty();
+            PacketHandler.INSTANCE
+                    .sendToDimension(new MessagePresentConnect(this, dir, true), worldObj.provider.dimensionId);
+            return true;
+        }
+        return false;
+    }
 
-	public boolean connectTo(ForgeDirection dir) {
-		int x = xCoord + dir.offsetX, y = yCoord + dir.offsetY, z = zCoord + dir.offsetZ;
-		TileEntity te = getTileSafe(x, y, z);
-		if (te instanceof TileEntityPresent) {
-			return connectTo((TileEntityPresent) te, dir);
-		}
-		return !exists(x, y, z);
-	}
+    public boolean connectTo(ForgeDirection dir) {
+        int x = xCoord + dir.offsetX, y = yCoord + dir.offsetY, z = zCoord + dir.offsetZ;
+        TileEntity te = getTileSafe(x, y, z);
+        if (te instanceof TileEntityPresent) {
+            return connectTo((TileEntityPresent) te, dir);
+        }
+        return !exists(x, y, z);
+    }
 
-	/**
-	 * @param preserveDir
-	 *            If true, this is only a virtual disconnect, meaning the other chest still exists, but is still loaded, so maintain a cachedDir for reconnection upon chunk load.
-	 */
-	public void disconnect(boolean preserveDir) {
-		if (isConnected()) {
-			if (!preserveDir) {
-				this.connection.cachedDir = null;
-				this.cachedDir = null;
-			}
-			this.connection.connection = null;
-			this.connection.markDirty();
-			this.connection = null;
-			this.markDirty();
-			PacketHandler.INSTANCE.sendToDimension(new MessagePresentConnect(this, ForgeDirection.UNKNOWN, false, preserveDir), worldObj.provider.dimensionId);
-		}
-	}
+    /**
+     * @param preserveDir If true, this is only a virtual disconnect, meaning the other chest still exists, but is still
+     *                    loaded, so maintain a cachedDir for reconnection upon chunk load.
+     */
+    public void disconnect(boolean preserveDir) {
+        if (isConnected()) {
+            if (!preserveDir) {
+                this.connection.cachedDir = null;
+                this.cachedDir = null;
+            }
+            this.connection.connection = null;
+            this.connection.markDirty();
+            this.connection = null;
+            this.markDirty();
+            PacketHandler.INSTANCE.sendToDimension(
+                    new MessagePresentConnect(this, ForgeDirection.UNKNOWN, false, preserveDir),
+                    worldObj.provider.dimensionId);
+        }
+    }
 
-	public TileEntityPresent getConnection() {
-		return connection;
-	}
+    public TileEntityPresent getConnection() {
+        return connection;
+    }
 
-	public ForgeDirection getConnectionDir() {
-		return cachedDir == null ? ForgeDirection.UNKNOWN : cachedDir;
-	}
+    public ForgeDirection getConnectionDir() {
+        return cachedDir == null ? ForgeDirection.UNKNOWN : cachedDir;
+    }
 
-	public boolean isParent() {
-		return isParent || !isConnected();
-	}
+    public boolean isParent() {
+        return isParent || !isConnected();
+    }
 
-	public int getRotation() {
-		return rotation;
-	}
+    public int getRotation() {
+        return rotation;
+    }
 
-	public void setRotation(int rot) {
-		this.rotation = rot;
-	}
+    public void setRotation(int rot) {
+        this.rotation = rot;
+    }
 
-	public void findConnections() {
-		if (!isConnected()) {
-			if (cachedDir != null) {
-				if (connectTo(cachedDir)) {
-					return;
-				}
-			}
-			for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
-				if (dir != ForgeDirection.UP && dir != ForgeDirection.DOWN) {
-					if (connectTo(dir)) {
-						return;
-					}
-				}
-			}
-		}
-	}
+    public void findConnections() {
+        if (!isConnected()) {
+            if (cachedDir != null) {
+                if (connectTo(cachedDir)) {
+                    return;
+                }
+            }
+            for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
+                if (dir != ForgeDirection.UP && dir != ForgeDirection.DOWN) {
+                    if (connectTo(dir)) {
+                        return;
+                    }
+                }
+            }
+        }
+    }
 
-	public TileEntityPresent getParent() {
-		return isParent || connection == null ? this : connection;
-	}
+    public TileEntityPresent getParent() {
+        return isParent || connection == null ? this : connection;
+    }
 
-	@Override
-	public AxisAlignedBB getRenderBoundingBox() {
-		return ChiselBlocks.present.getBoundingBox(this);
-	}
+    @Override
+    public AxisAlignedBB getRenderBoundingBox() {
+        return ChiselBlocks.present.getBoundingBox(this);
+    }
 
-	@Override
-	public void writeToNBT(NBTTagCompound tag) {
-		super.writeToNBT(tag);
-		NBTTagList nbttaglist = new NBTTagList();
+    @Override
+    public void writeToNBT(NBTTagCompound tag) {
+        super.writeToNBT(tag);
+        NBTTagList nbttaglist = new NBTTagList();
 
-		for (int i = 0; i < getTrueSizeInventory(); ++i) {
-			if (inventory[i] != null) {
-				NBTTagCompound nbttagcompound1 = new NBTTagCompound();
-				nbttagcompound1.setByte("Slot", (byte) i);
-				inventory[i].writeToNBT(nbttagcompound1);
-				nbttaglist.appendTag(nbttagcompound1);
-			}
-		}
+        for (int i = 0; i < getTrueSizeInventory(); ++i) {
+            if (inventory[i] != null) {
+                NBTTagCompound nbttagcompound1 = new NBTTagCompound();
+                nbttagcompound1.setByte("Slot", (byte) i);
+                inventory[i].writeToNBT(nbttagcompound1);
+                nbttaglist.appendTag(nbttagcompound1);
+            }
+        }
 
-		tag.setTag("Items", nbttaglist);
-		tag.setBoolean("isParent", isParent);
-		tag.setInteger("rotation", rotation);
-		if (cachedDir != null) {
-			tag.setInteger("conDir", cachedDir.ordinal());
-		}
-	}
+        tag.setTag("Items", nbttaglist);
+        tag.setBoolean("isParent", isParent);
+        tag.setInteger("rotation", rotation);
+        if (cachedDir != null) {
+            tag.setInteger("conDir", cachedDir.ordinal());
+        }
+    }
 
-	@Override
-	public void readFromNBT(NBTTagCompound tag) {
-		super.readFromNBT(tag);
-		NBTTagList nbttaglist = tag.getTagList("Items", 10);
+    @Override
+    public void readFromNBT(NBTTagCompound tag) {
+        super.readFromNBT(tag);
+        NBTTagList nbttaglist = tag.getTagList("Items", 10);
 
-		for (int i = 0; i < nbttaglist.tagCount(); ++i) {
-			NBTTagCompound nbttagcompound1 = nbttaglist.getCompoundTagAt(i);
-			int j = nbttagcompound1.getByte("Slot") & 255;
+        for (int i = 0; i < nbttaglist.tagCount(); ++i) {
+            NBTTagCompound nbttagcompound1 = nbttaglist.getCompoundTagAt(i);
+            int j = nbttagcompound1.getByte("Slot") & 255;
 
-			if (j >= 0 && j < getTrueSizeInventory()) {
-				inventory[j] = ItemStack.loadItemStackFromNBT(nbttagcompound1);
-			}
-		}
+            if (j >= 0 && j < getTrueSizeInventory()) {
+                inventory[j] = ItemStack.loadItemStackFromNBT(nbttagcompound1);
+            }
+        }
 
-		this.isParent = tag.getBoolean("isParent");
+        this.isParent = tag.getBoolean("isParent");
 
-		this.rotation = tag.getInteger("rotation");
-		if (tag.hasKey("conDir")) {
-			cachedDir = ForgeDirection.values()[tag.getInteger("conDir")];
-		}
-		autoSearch = true;
-	}
+        this.rotation = tag.getInteger("rotation");
+        if (tag.hasKey("conDir")) {
+            cachedDir = ForgeDirection.values()[tag.getInteger("conDir")];
+        }
+        autoSearch = true;
+    }
 
-	@Override
-	public Packet getDescriptionPacket() {
-		NBTTagCompound tag = new NBTTagCompound();
-		writeToNBT(tag);
-		return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, 1, tag);
-	}
+    @Override
+    public Packet getDescriptionPacket() {
+        NBTTagCompound tag = new NBTTagCompound();
+        writeToNBT(tag);
+        return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, 1, tag);
+    }
 
-	@Override
-	public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity packet) {
-		readFromNBT(packet.func_148857_g());
-	}
+    @Override
+    public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity packet) {
+        readFromNBT(packet.func_148857_g());
+    }
 
-	@Override
-	public boolean shouldRefresh(Block oldBlock, Block newBlock, int oldMeta, int newMeta, World world, int x, int y, int z) {
-		// prevent losing TE data when in-world chiseling
-		return oldBlock != newBlock;
-	}
+    @Override
+    public boolean shouldRefresh(Block oldBlock, Block newBlock, int oldMeta, int newMeta, World world, int x, int y,
+            int z) {
+        // prevent losing TE data when in-world chiseling
+        return oldBlock != newBlock;
+    }
 
-	@Override
-	public void invalidate() {
-		super.invalidate();
-		if (isConnected()) {
-			disconnect(false);
-		}
-	}
+    @Override
+    public void invalidate() {
+        super.invalidate();
+        if (isConnected()) {
+            disconnect(false);
+        }
+    }
 
-	@Override
-	public void onChunkUnload() {
-		super.onChunkUnload();
-		if (isConnected()) {
-			disconnect(true);
-		}
-	}
+    @Override
+    public void onChunkUnload() {
+        super.onChunkUnload();
+        if (isConnected()) {
+            disconnect(true);
+        }
+    }
 
-	private int getAdjustedSlot(int slot) {
-		slot %= getSizeInventory();
-		if (isConnected() && !isParent) {
-			slot = (slot + getTrueSizeInventory()) % getSizeInventory();
-		}
-		return slot;
-	}
+    private int getAdjustedSlot(int slot) {
+        slot %= getSizeInventory();
+        if (isConnected() && !isParent) {
+            slot = (slot + getTrueSizeInventory()) % getSizeInventory();
+        }
+        return slot;
+    }
 
-	private TileEntity getTileSafe(int x, int y, int z) {
-		if (exists(x, y, z)) {
-			return worldObj.getTileEntity(x, y, z);
-		}
-		return null;
-	}
+    private TileEntity getTileSafe(int x, int y, int z) {
+        if (exists(x, y, z)) {
+            return worldObj.getTileEntity(x, y, z);
+        }
+        return null;
+    }
 
-	// private Block getBlockSafe(int x, int y, int z) {
-	// if (exists(x, y, z)) {
-	// return worldObj.getBlock(x, y, z);
-	// }
-	// return null;
-	// }
-	//
-	// private int getMetaSafe(int x, int y, int z) {
-	// if (exists(x, y, z)) {
-	// return worldObj.getBlockMetadata(x, y, z);
-	// }
-	// return 0;
-	// }
-	//
-	private boolean exists(int x, int y, int z) {
-		return worldObj.blockExists(x, y, z);
-	}
+    // private Block getBlockSafe(int x, int y, int z) {
+    // if (exists(x, y, z)) {
+    // return worldObj.getBlock(x, y, z);
+    // }
+    // return null;
+    // }
+    //
+    // private int getMetaSafe(int x, int y, int z) {
+    // if (exists(x, y, z)) {
+    // return worldObj.getBlockMetadata(x, y, z);
+    // }
+    // return 0;
+    // }
+    //
+    private boolean exists(int x, int y, int z) {
+        return worldObj.blockExists(x, y, z);
+    }
 
-	/* IInventory */
+    /* IInventory */
 
-	@Override
-	public int getSizeInventory() {
-		return isConnected() ? getTrueSizeInventory() + connection.getTrueSizeInventory() : getTrueSizeInventory();
-	}
+    @Override
+    public int getSizeInventory() {
+        return isConnected() ? getTrueSizeInventory() + connection.getTrueSizeInventory() : getTrueSizeInventory();
+    }
 
-	@Override
-	public ItemStack getStackInSlot(int slot) {
-		slot = getAdjustedSlot(slot);
-		if (slot >= getTrueSizeInventory()) {
-			return isConnected() ? connection.inventory[slot % getTrueSizeInventory()] : null;
-		} else {
-			return inventory[slot];
-		}
-	}
+    @Override
+    public ItemStack getStackInSlot(int slot) {
+        slot = getAdjustedSlot(slot);
+        if (slot >= getTrueSizeInventory()) {
+            return isConnected() ? connection.inventory[slot % getTrueSizeInventory()] : null;
+        } else {
+            return inventory[slot];
+        }
+    }
 
-	@Override
-	public ItemStack decrStackSize(int slot, int amount) {
-		slot = getAdjustedSlot(slot);
-		ItemStack[] inv = inventory;
-		if (isConnected() && slot >= getTrueSizeInventory()) {
-			inv = connection.inventory;
-			slot %= getTrueSizeInventory();
-			connection.markDirty();
-		}
+    @Override
+    public ItemStack decrStackSize(int slot, int amount) {
+        slot = getAdjustedSlot(slot);
+        ItemStack[] inv = inventory;
+        if (isConnected() && slot >= getTrueSizeInventory()) {
+            inv = connection.inventory;
+            slot %= getTrueSizeInventory();
+            connection.markDirty();
+        }
 
-		if (inv[slot] != null) {
-			ItemStack itemstack;
+        if (inv[slot] != null) {
+            ItemStack itemstack;
 
-			if (inv[slot].stackSize <= amount) {
-				itemstack = inv[slot];
-				inv[slot] = null;
-				this.markDirty();
-				return itemstack;
-			} else {
-				itemstack = inv[slot].splitStack(amount);
+            if (inv[slot].stackSize <= amount) {
+                itemstack = inv[slot];
+                inv[slot] = null;
+                this.markDirty();
+                return itemstack;
+            } else {
+                itemstack = inv[slot].splitStack(amount);
 
-				if (inv[slot].stackSize == 0) {
-					inv[slot] = null;
-				}
+                if (inv[slot].stackSize == 0) {
+                    inv[slot] = null;
+                }
 
-				this.markDirty();
-				return itemstack;
-			}
-		} else {
-			return null;
-		}
-	}
+                this.markDirty();
+                return itemstack;
+            }
+        } else {
+            return null;
+        }
+    }
 
-	@Override
-	public ItemStack getStackInSlotOnClosing(int slot) {
-		return getStackInSlot(slot);
-	}
+    @Override
+    public ItemStack getStackInSlotOnClosing(int slot) {
+        return getStackInSlot(slot);
+    }
 
-	@Override
-	public void setInventorySlotContents(int slot, ItemStack stack) {
-		slot = getAdjustedSlot(slot);
-		if (slot < getTrueSizeInventory()) {
-			inventory[slot] = stack;
-		} else if (isConnected()) {
-			connection.inventory[slot % getTrueSizeInventory()] = stack;
-			connection.markDirty();
-		}
-	}
+    @Override
+    public void setInventorySlotContents(int slot, ItemStack stack) {
+        slot = getAdjustedSlot(slot);
+        if (slot < getTrueSizeInventory()) {
+            inventory[slot] = stack;
+        } else if (isConnected()) {
+            connection.inventory[slot % getTrueSizeInventory()] = stack;
+            connection.markDirty();
+        }
+    }
 
-	@Override
-	public String getInventoryName() {
-		return "chisel.present";
-	}
+    @Override
+    public String getInventoryName() {
+        return "chisel.present";
+    }
 
-	@Override
-	public boolean hasCustomInventoryName() {
-		return false;
-	}
+    @Override
+    public boolean hasCustomInventoryName() {
+        return false;
+    }
 
-	@Override
-	public int getInventoryStackLimit() {
-		return 64;
-	}
+    @Override
+    public int getInventoryStackLimit() {
+        return 64;
+    }
 
-	@Override
-	public boolean isUseableByPlayer(EntityPlayer p_70300_1_) {
-		return true;
-	}
+    @Override
+    public boolean isUseableByPlayer(EntityPlayer p_70300_1_) {
+        return true;
+    }
 
-	@Override
-	public void openInventory() {
-		;
-	}
+    @Override
+    public void openInventory() {
+        ;
+    }
 
-	@Override
-	public void closeInventory() {
-		;
-	}
+    @Override
+    public void closeInventory() {
+        ;
+    }
 
-	@Override
-	public boolean isItemValidForSlot(int p_94041_1_, ItemStack p_94041_2_) {
-		return true;
-	}
+    @Override
+    public boolean isItemValidForSlot(int p_94041_1_, ItemStack p_94041_2_) {
+        return true;
+    }
 
-	/* IDoubleChest */
+    /* IDoubleChest */
 
-	@Override
-	public int getTrueSizeInventory() {
-		return inventory.length;
-	}
+    @Override
+    public int getTrueSizeInventory() {
+        return inventory.length;
+    }
 
-	@Override
-	public ItemStack getTrueStackInSlot(int slot) {
-		return inventory[slot % getTrueSizeInventory()];
-	}
+    @Override
+    public ItemStack getTrueStackInSlot(int slot) {
+        return inventory[slot % getTrueSizeInventory()];
+    }
 
-	@Override
-	public void putStackInTrueSlot(int slot, ItemStack stack) {
-		inventory[slot % getTrueSizeInventory()] = stack;
-	}
+    @Override
+    public void putStackInTrueSlot(int slot, ItemStack stack) {
+        inventory[slot % getTrueSizeInventory()] = stack;
+    }
 }

src/main/java/team/chisel/carving/Carving.java

@@ -2,214 +2,212 @@ package team.chisel.carving;
 
 import java.util.*;
 
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.oredict.OreDictionary;
+
+import team.chisel.Chisel;
+
 import com.cricketcraft.chisel.api.carving.CarvingUtils;
 import com.cricketcraft.chisel.api.carving.ICarvingGroup;
 import com.cricketcraft.chisel.api.carving.ICarvingRegistry;
 import com.cricketcraft.chisel.api.carving.ICarvingVariation;
 
-import team.chisel.Chisel;
-import net.minecraft.block.Block;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraftforge.oredict.OreDictionary;
-
 public class Carving implements ICarvingRegistry {
 
-	GroupList groups = new GroupList();
+    GroupList groups = new GroupList();
 
-	public static final ICarvingRegistry chisel = new Carving();
-	public static final Carving needle = new Carving();
+    public static final ICarvingRegistry chisel = new Carving();
+    public static final Carving needle = new Carving();
 
-	static {
-		CarvingUtils.chisel = chisel;
-	}
+    static {
+        CarvingUtils.chisel = chisel;
+    }
 
-	public static void construct() {
-		/* do nothing */
-	}
+    public static void construct() {
+        /* do nothing */
+    }
 
-	private Carving() {
-		/* do nothing */
-	}
+    private Carving() {
+        /* do nothing */
+    }
 
-	@Override
-	public ICarvingVariation getVariation(Block block, int metadata) {
-		ICarvingGroup g = getGroup(block, metadata);
-		if (g != null) {
-			for (ICarvingVariation v : g.getVariations()) {
-				if (v.getBlock() == block && v.getBlockMeta() == metadata) {
-					return v;
-				}
-			}
-		}
-		return null;
-	}
+    @Override
+    public ICarvingVariation getVariation(Block block, int metadata) {
+        ICarvingGroup g = getGroup(block, metadata);
+        if (g != null) {
+            for (ICarvingVariation v : g.getVariations()) {
+                if (v.getBlock() == block && v.getBlockMeta() == metadata) {
+                    return v;
+                }
+            }
+        }
+        return null;
+    }
 
-	@Override
-	public List<ICarvingVariation> getGroupVariations(Block block, int metadata) {
-		ICarvingGroup group = getGroup(block, metadata);
-		if (group == null)
-			return Collections.emptyList();
+    @Override
+    public List<ICarvingVariation> getGroupVariations(Block block, int metadata) {
+        ICarvingGroup group = getGroup(block, metadata);
+        if (group == null) return Collections.emptyList();
 
-		return group.getVariations();
-	}
+        return group.getVariations();
+    }
 
-	@Override
-	public String getOreName(Block block, int metadata) {
-		ICarvingGroup group = getGroup(block, metadata);
-		if (group == null)
-			return null;
+    @Override
+    public String getOreName(Block block, int metadata) {
+        ICarvingGroup group = getGroup(block, metadata);
+        if (group == null) return null;
 
-		return group.getOreName();
-	}
+        return group.getOreName();
+    }
 
-	@Override
-	public List<ItemStack> getItemsForChiseling(ItemStack chiseledItem) {
-		ArrayList<ItemStack> items = new ArrayList<>();
+    @Override
+    public List<ItemStack> getItemsForChiseling(ItemStack chiseledItem) {
+        ArrayList<ItemStack> items = new ArrayList<>();
 
-		ICarvingGroup group = null;
+        ICarvingGroup group = null;
 
-		int[] oreIDs = OreDictionary.getOreIDs(chiseledItem);
-		for (int i : oreIDs) {
-			group = groups.getGroupByOre(OreDictionary.getOreName(i));
-			if (group != null) {
-				break;
-			}
-		}
+        int[] oreIDs = OreDictionary.getOreIDs(chiseledItem);
+        for (int i : oreIDs) {
+            group = groups.getGroupByOre(OreDictionary.getOreName(i));
+            if (group != null) {
+                break;
+            }
+        }
 
-		if (group == null) {
-			group = getGroup(Block.getBlockFromItem(chiseledItem.getItem()), chiseledItem.getItemDamage());
-		}
+        if (group == null) {
+            group = getGroup(Block.getBlockFromItem(chiseledItem.getItem()), chiseledItem.getItemDamage());
+        }
 
-		if (group == null)
-			return items;
+        if (group == null) return items;
 
-		HashSet<String> mapping = new HashSet<>();
+        HashSet<String> mapping = new HashSet<>();
 
-		List<ICarvingVariation> variations = group.getVariations();
+        List<ICarvingVariation> variations = group.getVariations();
 
-		for (ICarvingVariation v : variations) {
-			String key = Block.getIdFromBlock(v.getBlock()) + "|" + v.getItemMeta();
-			if (mapping.add(key)) items.add(new ItemStack(v.getBlock(), 1, v.getItemMeta()));
-		}
+        for (ICarvingVariation v : variations) {
+            String key = Block.getIdFromBlock(v.getBlock()) + "|" + v.getItemMeta();
+            if (mapping.add(key)) items.add(new ItemStack(v.getBlock(), 1, v.getItemMeta()));
+        }
 
-		String oreName = group.getOreName();
-		if (oreName != null) {
-			ArrayList<ItemStack> ores = OreDictionary.getOres(oreName);
-			for (ItemStack stack : ores) {
-				String key = Item.getIdFromItem(stack.getItem()) + "|" + stack.getItemDamage();
-				if (mapping.add(key)) items.add(stack);
-			}
-		}
+        String oreName = group.getOreName();
+        if (oreName != null) {
+            ArrayList<ItemStack> ores = OreDictionary.getOres(oreName);
+            for (ItemStack stack : ores) {
+                String key = Item.getIdFromItem(stack.getItem()) + "|" + stack.getItemDamage();
+                if (mapping.add(key)) items.add(stack);
+            }
+        }
 
-		return items;
-	}
+        return items;
+    }
 
-	@Override
-	public ICarvingGroup getGroup(Block block, int metadata) {
-		int[] ids = OreDictionary.getOreIDs(new ItemStack(block, 1, metadata));
-		if (ids.length > 0) {
-			for (int id : ids) {
-				ICarvingGroup oreGroup = groups.getGroupByOre(OreDictionary.getOreName(id));
-				if (oreGroup != null) {
-					return oreGroup;
-				}
-			}
-		}
+    @Override
+    public ICarvingGroup getGroup(Block block, int metadata) {
+        int[] ids = OreDictionary.getOreIDs(new ItemStack(block, 1, metadata));
+        if (ids.length > 0) {
+            for (int id : ids) {
+                ICarvingGroup oreGroup = groups.getGroupByOre(OreDictionary.getOreName(id));
+                if (oreGroup != null) {
+                    return oreGroup;
+                }
+            }
+        }
 
-		return groups.getGroup(block, metadata);
-	}
+        return groups.getGroup(block, metadata);
+    }
 
-	@Override
-	public ICarvingGroup getGroup(String name) {
-		return groups.getGroupByName(name);
-	}
+    @Override
+    public ICarvingGroup getGroup(String name) {
+        return groups.getGroupByName(name);
+    }
 
-	@Override
-	public ICarvingGroup removeGroup(String groupName) {
-		ICarvingGroup g = groups.getGroupByName(groupName);
-		return groups.remove(g) ? g : null;
-	}
+    @Override
+    public ICarvingGroup removeGroup(String groupName) {
+        ICarvingGroup g = groups.getGroupByName(groupName);
+        return groups.remove(g) ? g : null;
+    }
 
-	@Override
-	public ICarvingVariation removeVariation(Block block, int metadata) {
-		return removeVariation(block, metadata, null);
-	}
+    @Override
+    public ICarvingVariation removeVariation(Block block, int metadata) {
+        return removeVariation(block, metadata, null);
+    }
 
-	@Override
-	public ICarvingVariation removeVariation(Block block, int metadata, String group) {
-		return groups.removeVariation(block, metadata, group);
-	}
+    @Override
+    public ICarvingVariation removeVariation(Block block, int metadata, String group) {
+        return groups.removeVariation(block, metadata, group);
+    }
 
-	@Override
-	public void addVariation(String groupName, Block block, int metadata, int order) {
-		if (block == null) {
-			throw new NullPointerException("Cannot add variation in group " + groupName + " for null block.");
-		}
+    @Override
+    public void addVariation(String groupName, Block block, int metadata, int order) {
+        if (block == null) {
+            throw new NullPointerException("Cannot add variation in group " + groupName + " for null block.");
+        }
 
-		ICarvingVariation variation = CarvingUtils.getDefaultVariationFor(block, metadata, order);
-		addVariation(groupName, variation);
-	}
+        ICarvingVariation variation = CarvingUtils.getDefaultVariationFor(block, metadata, order);
+        addVariation(groupName, variation);
+    }
 
-	@Override
-	public void addVariation(String groupName, ICarvingVariation variation) {
-		if (groupName == null) {
-			throw new NullPointerException("Cannot add variation to null group name.");
-		} else if (variation == null) {
-			throw new NullPointerException("Cannot add variation in group " + groupName + " for null variation.");
-		}
+    @Override
+    public void addVariation(String groupName, ICarvingVariation variation) {
+        if (groupName == null) {
+            throw new NullPointerException("Cannot add variation to null group name.");
+        } else if (variation == null) {
+            throw new NullPointerException("Cannot add variation in group " + groupName + " for null variation.");
+        }
 
-		ICarvingGroup group = groups.getGroupByName(groupName);
+        ICarvingGroup group = groups.getGroupByName(groupName);
 
-		if (group == null) {
-			group = CarvingUtils.getDefaultGroupFor(groupName);
-			addGroup(group);
-		}
+        if (group == null) {
+            group = CarvingUtils.getDefaultGroupFor(groupName);
+            addGroup(group);
+        }
 
-		groups.addVariation(groupName, variation);
-	}
+        groups.addVariation(groupName, variation);
+    }
 
-	@Override
-	public void addGroup(ICarvingGroup group) {
-		groups.add(group);
-	}
+    @Override
+    public void addGroup(ICarvingGroup group) {
+        groups.add(group);
+    }
 
-	@Override
-	public void registerOre(String name, String oreName) {
-		ICarvingGroup group = groups.getGroupByName(name);
-		if (group != null) {
-			group.setOreName(oreName);
-		} else {
-			throw new NullPointerException("Cannot register ore name for group " + name + ", as it does not exist.");
-		}
-	}
+    @Override
+    public void registerOre(String name, String oreName) {
+        ICarvingGroup group = groups.getGroupByName(name);
+        if (group != null) {
+            group.setOreName(oreName);
+        } else {
+            throw new NullPointerException("Cannot register ore name for group " + name + ", as it does not exist.");
+        }
+    }
 
-	@Override
-	public void setVariationSound(String name, String sound) {
-		ICarvingGroup group = groups.getGroupByName(name);
-		if (group != null) {
-			group.setSound(sound);
-		} else {
-			throw new NullPointerException("Cannot set sound for group " + name + ", as it does not exist.");
-		}
-	}
+    @Override
+    public void setVariationSound(String name, String sound) {
+        ICarvingGroup group = groups.getGroupByName(name);
+        if (group != null) {
+            group.setSound(sound);
+        } else {
+            throw new NullPointerException("Cannot set sound for group " + name + ", as it does not exist.");
+        }
+    }
 
-	@Override
-	public String getVariationSound(Block block, int metadata) {
-		return getVariationSound(Item.getItemFromBlock(block), metadata);
-	}
+    @Override
+    public String getVariationSound(Block block, int metadata) {
+        return getVariationSound(Item.getItemFromBlock(block), metadata);
+    }
 
-	@Override
-	public String getVariationSound(Item item, int metadata) {
-		ICarvingGroup group = groups.getGroup(Block.getBlockFromItem(item), metadata);
-		String sound = group == null ? null : group.getSound();
-		return sound == null ? Chisel.MOD_ID + ":chisel.fallback" : sound;
-	}
+    @Override
+    public String getVariationSound(Item item, int metadata) {
+        ICarvingGroup group = groups.getGroup(Block.getBlockFromItem(item), metadata);
+        String sound = group == null ? null : group.getSound();
+        return sound == null ? Chisel.MOD_ID + ":chisel.fallback" : sound;
+    }
 
-	@Override
-	public List<String> getSortedGroupNames() {
-		List<String> names = new ArrayList<>(groups.getNames());
-		Collections.sort(names);
-		return names;
-	}
+    @Override
+    public List<String> getSortedGroupNames() {
+        List<String> names = new ArrayList<>(groups.getNames());
+        Collections.sort(names);
+        return names;
+    }
 }

src/main/java/team/chisel/carving/GroupList.java

@@ -17,229 +17,231 @@ import com.google.common.collect.Maps;
 
 public class GroupList implements Set<ICarvingGroup> {
 
-	private class VariationWrapper {
+    private class VariationWrapper {
 
-		private ICarvingVariation v;
+        private ICarvingVariation v;
 
-		private VariationWrapper(ICarvingVariation v) {
-			this.v = v;
-		}
+        private VariationWrapper(ICarvingVariation v) {
+            this.v = v;
+        }
 
-		@Override
-		public boolean equals(Object obj) {
-			if (obj instanceof ICarvingVariation) {
-				ICarvingVariation v2 = (ICarvingVariation) obj;
-				return v.getBlock() == v2.getBlock() && (v.getBlockMeta() == v2.getBlockMeta() || v.getItemMeta() == v2.getItemMeta());
-			} else if (obj instanceof VariationWrapper) {
-				return equals(((VariationWrapper) obj).v);
-			}
-			return false;
-		}
+        @Override
+        public boolean equals(Object obj) {
+            if (obj instanceof ICarvingVariation) {
+                ICarvingVariation v2 = (ICarvingVariation) obj;
+                return v.getBlock() == v2.getBlock()
+                        && (v.getBlockMeta() == v2.getBlockMeta() || v.getItemMeta() == v2.getItemMeta());
+            } else if (obj instanceof VariationWrapper) {
+                return equals(((VariationWrapper) obj).v);
+            }
+            return false;
+        }
 
-		@Override
-		public int hashCode() {
-			return v.getBlock().hashCode();
-		}
-	}
+        @Override
+        public int hashCode() {
+            return v.getBlock().hashCode();
+        }
+    }
 
-	private class VariationKey implements ICarvingVariation {
+    private class VariationKey implements ICarvingVariation {
 
-		Pair<Block, Integer> data;
+        Pair<Block, Integer> data;
 
-		private VariationKey(Block block, int blockMeta) {
-			data = Pair.of(block, blockMeta);
-		}
+        private VariationKey(Block block, int blockMeta) {
+            data = Pair.of(block, blockMeta);
+        }
 
-		@Override
-		public Block getBlock() {
-			return data.getLeft();
-		}
+        @Override
+        public Block getBlock() {
+            return data.getLeft();
+        }
 
-		@Override
-		public int getBlockMeta() {
-			return data.getRight();
-		}
+        @Override
+        public int getBlockMeta() {
+            return data.getRight();
+        }
 
-		@Override
-		public int getItemMeta() {
-			return data.getRight();
-		}
+        @Override
+        public int getItemMeta() {
+            return data.getRight();
+        }
 
-		@Override
-		public int getOrder() {
-			return 0;
-		}
+        @Override
+        public int getOrder() {
+            return 0;
+        }
 
-		@Override
-		public String toString() {
-			return data.toString();
-		}
-	}
+        @Override
+        public String toString() {
+            return data.toString();
+        }
+    }
 
-	private HashMap<String, ICarvingGroup> groups = Maps.newHashMap();
-	private HashMap<VariationWrapper, ICarvingGroup> lookup = Maps.newHashMap();
+    private HashMap<String, ICarvingGroup> groups = Maps.newHashMap();
+    private HashMap<VariationWrapper, ICarvingGroup> lookup = Maps.newHashMap();
 
-	@Override
-	public int size() {
-		return groups.size();
-	}
+    @Override
+    public int size() {
+        return groups.size();
+    }
 
-	@Override
-	public boolean isEmpty() {
-		return groups.isEmpty();
-	}
+    @Override
+    public boolean isEmpty() {
+        return groups.isEmpty();
+    }
 
-	@Override
-	public boolean contains(Object o) {
-		if (o instanceof ICarvingGroup) {
-			return groups.containsKey(((ICarvingGroup) o).getName());
-		}
-		return false;
-	}
+    @Override
+    public boolean contains(Object o) {
+        if (o instanceof ICarvingGroup) {
+            return groups.containsKey(((ICarvingGroup) o).getName());
+        }
+        return false;
+    }
 
-	@Override
-	public Iterator<ICarvingGroup> iterator() {
-		return groups.values().iterator();
-	}
+    @Override
+    public Iterator<ICarvingGroup> iterator() {
+        return groups.values().iterator();
+    }
 
-	@Override
-	public Object[] toArray() {
-		return groups.values().toArray();
-	}
+    @Override
+    public Object[] toArray() {
+        return groups.values().toArray();
+    }
 
-	@Override
-	public <T> T[] toArray(T[] arr) {
-		return groups.values().toArray(arr);
-	}
+    @Override
+    public <T> T[] toArray(T[] arr) {
+        return groups.values().toArray(arr);
+    }
 
-	@Override
-	public boolean add(ICarvingGroup group) {
-		String key = group.getName();
-		if (groups.containsKey(key)) {
-			return false;
-		}
-		for (ICarvingVariation v : group.getVariations()) {
-			ICarvingGroup g = lookup.get(v);
-			if (g == null) {
-				lookup.put(new VariationWrapper(v), group);
-			}
-		}
-		groups.put(key, group);
-		return true;
-	}
+    @Override
+    public boolean add(ICarvingGroup group) {
+        String key = group.getName();
+        if (groups.containsKey(key)) {
+            return false;
+        }
+        for (ICarvingVariation v : group.getVariations()) {
+            ICarvingGroup g = lookup.get(v);
+            if (g == null) {
+                lookup.put(new VariationWrapper(v), group);
+            }
+        }
+        groups.put(key, group);
+        return true;
+    }
 
-	@Override
-	public boolean remove(Object o) {
-		if (o instanceof ICarvingGroup) {
-			List<VariationWrapper> toRemove = Lists.newArrayList();
-			for (VariationWrapper v : lookup.keySet()) {
-				if (lookup.get(v).getName().equals(((ICarvingGroup) o).getName())) {
-					toRemove.add(v);
-				}
-			}
-			for (VariationWrapper v : toRemove) {
-				lookup.remove(v);
-			}
-			return groups.remove(((ICarvingGroup) o).getName()) != null;
-		}
-		return false;
-	}
+    @Override
+    public boolean remove(Object o) {
+        if (o instanceof ICarvingGroup) {
+            List<VariationWrapper> toRemove = Lists.newArrayList();
+            for (VariationWrapper v : lookup.keySet()) {
+                if (lookup.get(v).getName().equals(((ICarvingGroup) o).getName())) {
+                    toRemove.add(v);
+                }
+            }
+            for (VariationWrapper v : toRemove) {
+                lookup.remove(v);
+            }
+            return groups.remove(((ICarvingGroup) o).getName()) != null;
+        }
+        return false;
+    }
 
-	@Override
-	public boolean containsAll(Collection<?> c) {
-		for (Object o : c) {
-			if (!(o instanceof ICarvingGroup)) {
-				return false;
-			}
-			if (!groups.containsKey(((ICarvingGroup) o).getName())) {
-				return false;
-			}
-		}
-		return true;
-	}
+    @Override
+    public boolean containsAll(Collection<?> c) {
+        for (Object o : c) {
+            if (!(o instanceof ICarvingGroup)) {
+                return false;
+            }
+            if (!groups.containsKey(((ICarvingGroup) o).getName())) {
+                return false;
+            }
+        }
+        return true;
+    }
 
-	@Override
-	public boolean addAll(Collection<? extends ICarvingGroup> c) {
-		boolean ret = false;
-		for (ICarvingGroup g : c) {
-			ret |= add(g);
-		}
-		return ret;
-	}
+    @Override
+    public boolean addAll(Collection<? extends ICarvingGroup> c) {
+        boolean ret = false;
+        for (ICarvingGroup g : c) {
+            ret |= add(g);
+        }
+        return ret;
+    }
 
-	@Override
-	public boolean removeAll(Collection<?> c) {
-		boolean ret = false;
-		for (Object o : c) {
-			ret |= remove(o);
-		}
-		return ret;
-	}
+    @Override
+    public boolean removeAll(Collection<?> c) {
+        boolean ret = false;
+        for (Object o : c) {
+            ret |= remove(o);
+        }
+        return ret;
+    }
 
-	@Override
-	public boolean retainAll(Collection<?> c) {
-		throw new UnsupportedOperationException(); // not using it, not gonna bother
-	}
+    @Override
+    public boolean retainAll(Collection<?> c) {
+        throw new UnsupportedOperationException(); // not using it, not gonna bother
+    }
 
-	@Override
-	public void clear() {
-		groups.clear();
-	}
+    @Override
+    public void clear() {
+        groups.clear();
+    }
 
-	public ICarvingGroup getGroup(Block block, int metadata) {
-		return lookup.get(new VariationWrapper(new VariationKey(block, metadata)));
-	}
+    public ICarvingGroup getGroup(Block block, int metadata) {
+        return lookup.get(new VariationWrapper(new VariationKey(block, metadata)));
+    }
 
-	public void addVariation(String name, ICarvingVariation variation) {
-		ICarvingGroup g = groups.get(name);
-		if (g == null) {
-			throw new NullPointerException("No group exists for name " + name);
-		}
-		g.addVariation(variation);
-		lookup.put(new VariationWrapper(variation), g);
-	}
+    public void addVariation(String name, ICarvingVariation variation) {
+        ICarvingGroup g = groups.get(name);
+        if (g == null) {
+            throw new NullPointerException("No group exists for name " + name);
+        }
+        g.addVariation(variation);
+        lookup.put(new VariationWrapper(variation), g);
+    }
 
-	public ICarvingGroup getGroupByName(String groupName) {
-		return groups.get(groupName);
-	}
+    public ICarvingGroup getGroupByName(String groupName) {
+        return groups.get(groupName);
+    }
 
-	public ICarvingGroup getGroupByOre(String oreName) {
-		for (ICarvingGroup group : groups.values()) {
-			if (oreName.equals(group.getOreName())) {
-				return group;
-			}
-		}
-		return null;
-	}
+    public ICarvingGroup getGroupByOre(String oreName) {
+        for (ICarvingGroup group : groups.values()) {
+            if (oreName.equals(group.getOreName())) {
+                return group;
+            }
+        }
+        return null;
+    }
 
-	public Collection<? extends String> getNames() {
-		return groups.keySet();
-	}
+    public Collection<? extends String> getNames() {
+        return groups.keySet();
+    }
 
-	public ICarvingVariation removeVariation(Block block, int metadata, String group) {
-		ICarvingGroup g = null;
-		if (group != null) {
-			g = groups.get(group);
-			if (g == null) {
-				throw new IllegalArgumentException("No such group " + group);
-			}
-			groups.remove(g.getName());
-		}
-		List<VariationWrapper> toRemove = Lists.newArrayList();
-		for (VariationWrapper v : lookup.keySet()) {
-			if ((g == null || lookup.get(v).getName().equals(g.getName())) && v.equals(new VariationWrapper(new VariationKey(block, metadata)))) {
-				lookup.get(v).removeVariation(v.v);
-				toRemove.add(v);
-			}
-		}
-		for (VariationWrapper v : toRemove) {
-			lookup.remove(v);
-		}
-		return toRemove.isEmpty() ? null : toRemove.get(0).v;
-	}
+    public ICarvingVariation removeVariation(Block block, int metadata, String group) {
+        ICarvingGroup g = null;
+        if (group != null) {
+            g = groups.get(group);
+            if (g == null) {
+                throw new IllegalArgumentException("No such group " + group);
+            }
+            groups.remove(g.getName());
+        }
+        List<VariationWrapper> toRemove = Lists.newArrayList();
+        for (VariationWrapper v : lookup.keySet()) {
+            if ((g == null || lookup.get(v).getName().equals(g.getName()))
+                    && v.equals(new VariationWrapper(new VariationKey(block, metadata)))) {
+                lookup.get(v).removeVariation(v.v);
+                toRemove.add(v);
+            }
+        }
+        for (VariationWrapper v : toRemove) {
+            lookup.remove(v);
+        }
+        return toRemove.isEmpty() ? null : toRemove.get(0).v;
+    }
 
-	@Override
-	public String toString() {
-		return groups.toString();
-	}
+    @Override
+    public String toString() {
+        return groups.toString();
+    }
 }

src/main/java/team/chisel/client/GeneralChiselClient.java

@@ -9,6 +9,7 @@ import net.minecraft.client.particle.EntityDiggingFX;
 import net.minecraft.client.particle.EntityLavaFX;
 import net.minecraft.item.ItemStack;
 import net.minecraft.world.World;
+
 import team.chisel.block.BlockGrimstone;
 import team.chisel.block.BlockHolystone;
 import team.chisel.block.BlockLavastone;
@@ -24,226 +25,269 @@ import team.chisel.utils.GeneralClient;
 
 public class GeneralChiselClient {
 
-	public static Random rand = new Random();
-	public static int tick = 0;
+    public static Random rand = new Random();
+    public static int tick = 0;
 
-	public static void spawnLavastoneFX(World world, BlockLavastone block, int x, int y, int z) {
-		if (Configurations.particlesTickrate != 0 && tick++ % Configurations.particlesTickrate != 0 || Minecraft.getMinecraft().gameSettings.particleSetting != 0)
-			return;
+    public static void spawnLavastoneFX(World world, BlockLavastone block, int x, int y, int z) {
+        if (Configurations.particlesTickrate != 0 && tick++ % Configurations.particlesTickrate != 0
+                || Minecraft.getMinecraft().gameSettings.particleSetting != 0)
+            return;
 
-		float f = 0.15F;
-		double x1 = x + rand.nextDouble() * (block.getBlockBoundsMaxX() - block.getBlockBoundsMinX() - f * 2.0F) + f + block.getBlockBoundsMinX();
-		double y1 = y + rand.nextDouble() * (block.getBlockBoundsMaxY() - block.getBlockBoundsMinY() - f * 2.0F) + f + block.getBlockBoundsMinY();
-		double z1 = z + rand.nextDouble() * (block.getBlockBoundsMaxZ() - block.getBlockBoundsMinZ() - f * 2.0F) + f + block.getBlockBoundsMinZ();
+        float f = 0.15F;
+        double x1 = x + rand.nextDouble() * (block.getBlockBoundsMaxX() - block.getBlockBoundsMinX() - f * 2.0F)
+                + f
+                + block.getBlockBoundsMinX();
+        double y1 = y + rand.nextDouble() * (block.getBlockBoundsMaxY() - block.getBlockBoundsMinY() - f * 2.0F)
+                + f
+                + block.getBlockBoundsMinY();
+        double z1 = z + rand.nextDouble() * (block.getBlockBoundsMaxZ() - block.getBlockBoundsMinZ() - f * 2.0F)
+                + f
+                + block.getBlockBoundsMinZ();
 
-		switch (rand.nextInt(6)) {
-		case 0:
-			y1 = y + block.getBlockBoundsMinY() - f;
-			y--;
-			break;
-		case 1:
-			y1 = y + block.getBlockBoundsMaxY() + f;
-			y++;
-			break;
-		case 2:
-			z1 = z + block.getBlockBoundsMinZ() - f;
-			z--;
-			break;
-		case 3:
-			z1 = z + block.getBlockBoundsMaxZ() + f;
-			z++;
-			break;
-		case 4:
-			x1 = x + block.getBlockBoundsMinX() - f;
-			x--;
-			break;
-		case 5:
-			x1 = x + block.getBlockBoundsMaxX() + f;
-			x++;
-			break;
-		}
+        switch (rand.nextInt(6)) {
+            case 0:
+                y1 = y + block.getBlockBoundsMinY() - f;
+                y--;
+                break;
+            case 1:
+                y1 = y + block.getBlockBoundsMaxY() + f;
+                y++;
+                break;
+            case 2:
+                z1 = z + block.getBlockBoundsMinZ() - f;
+                z--;
+                break;
+            case 3:
+                z1 = z + block.getBlockBoundsMaxZ() + f;
+                z++;
+                break;
+            case 4:
+                x1 = x + block.getBlockBoundsMinX() - f;
+                x--;
+                break;
+            case 5:
+                x1 = x + block.getBlockBoundsMaxX() + f;
+                x++;
+                break;
+        }
 
-		if (world.getBlock(x, y, z).isOpaqueCube())
-			return;
+        if (world.getBlock(x, y, z).isOpaqueCube()) return;
 
-		EntityLavaFX res = new EntityLavaFX(world, x1, y1, z1);
-		double multiplier = 0.45;
-		res.motionX = -multiplier * (x1 - x - 0.5);
-		res.motionY = multiplier * (y1 - y - 0.5);
-		res.motionZ = -multiplier * (z1 - z - 0.5);
+        EntityLavaFX res = new EntityLavaFX(world, x1, y1, z1);
+        double multiplier = 0.45;
+        res.motionX = -multiplier * (x1 - x - 0.5);
+        res.motionY = multiplier * (y1 - y - 0.5);
+        res.motionZ = -multiplier * (z1 - z - 0.5);
 
-		Minecraft.getMinecraft().effectRenderer.addEffect(res);
-	}
+        Minecraft.getMinecraft().effectRenderer.addEffect(res);
+    }
 
-	public static void spawnHolystoneFX(World world, BlockHolystone block, int x, int y, int z) {
-		if (Configurations.particlesTickrate != 0 && tick++ % Configurations.particlesTickrate != 0 || Minecraft.getMinecraft().gameSettings.particleSetting != 0)
-			return;
+    public static void spawnHolystoneFX(World world, BlockHolystone block, int x, int y, int z) {
+        if (Configurations.particlesTickrate != 0 && tick++ % Configurations.particlesTickrate != 0
+                || Minecraft.getMinecraft().gameSettings.particleSetting != 0)
+            return;
 
-		float f = 0.15F;
-		double x1 = x + rand.nextDouble() * (block.getBlockBoundsMaxX() - block.getBlockBoundsMinX() - f * 2.0F) + f + block.getBlockBoundsMinX();
-		double y1 = y + rand.nextDouble() * (block.getBlockBoundsMaxY() - block.getBlockBoundsMinY() - f * 2.0F) + f + block.getBlockBoundsMinY();
-		double z1 = z + rand.nextDouble() * (block.getBlockBoundsMaxZ() - block.getBlockBoundsMinZ() - f * 2.0F) + f + block.getBlockBoundsMinZ();
+        float f = 0.15F;
+        double x1 = x + rand.nextDouble() * (block.getBlockBoundsMaxX() - block.getBlockBoundsMinX() - f * 2.0F)
+                + f
+                + block.getBlockBoundsMinX();
+        double y1 = y + rand.nextDouble() * (block.getBlockBoundsMaxY() - block.getBlockBoundsMinY() - f * 2.0F)
+                + f
+                + block.getBlockBoundsMinY();
+        double z1 = z + rand.nextDouble() * (block.getBlockBoundsMaxZ() - block.getBlockBoundsMinZ() - f * 2.0F)
+                + f
+                + block.getBlockBoundsMinZ();
 
-		switch (rand.nextInt(6)) {
-		case 0:
-			y1 = y + block.getBlockBoundsMinY() - f;
-			y--;
-			break;
-		case 1:
-			y1 = y + block.getBlockBoundsMaxY() + f;
-			y++;
-			break;
-		case 2:
-			z1 = z + block.getBlockBoundsMinZ() - f;
-			z--;
-			break;
-		case 3:
-			z1 = z + block.getBlockBoundsMaxZ() + f;
-			z++;
-			break;
-		case 4:
-			x1 = x + block.getBlockBoundsMinX() - f;
-			x--;
-			break;
-		case 5:
-			x1 = x + block.getBlockBoundsMaxX() + f;
-			x++;
-			break;
-		}
+        switch (rand.nextInt(6)) {
+            case 0:
+                y1 = y + block.getBlockBoundsMinY() - f;
+                y--;
+                break;
+            case 1:
+                y1 = y + block.getBlockBoundsMaxY() + f;
+                y++;
+                break;
+            case 2:
+                z1 = z + block.getBlockBoundsMinZ() - f;
+                z--;
+                break;
+            case 3:
+                z1 = z + block.getBlockBoundsMaxZ() + f;
+                z++;
+                break;
+            case 4:
+                x1 = x + block.getBlockBoundsMinX() - f;
+                x--;
+                break;
+            case 5:
+                x1 = x + block.getBlockBoundsMaxX() + f;
+                x++;
+                break;
+        }
 
-		if (world.getBlock(x, y, z).isOpaqueCube())
-			return;
+        if (world.getBlock(x, y, z).isOpaqueCube()) return;
 
-		EntityHolystoneFX res = new EntityHolystoneFX(world, block, x1, y1, z1);
-		Minecraft.getMinecraft().effectRenderer.addEffect(res);
-	}
+        EntityHolystoneFX res = new EntityHolystoneFX(world, block, x1, y1, z1);
+        Minecraft.getMinecraft().effectRenderer.addEffect(res);
+    }
 
-	public static void spawnGrimstoneFX(World world, BlockGrimstone block, int x, int y, int z) {
-		if (Configurations.particlesTickrate != 0 && tick++ % Configurations.particlesTickrate != 0)
-			return;
+    public static void spawnGrimstoneFX(World world, BlockGrimstone block, int x, int y, int z) {
+        if (Configurations.particlesTickrate != 0 && tick++ % Configurations.particlesTickrate != 0) return;
 
-		float f = 0.15F;
-		double x1 = x + rand.nextDouble() * (block.getBlockBoundsMaxX() - block.getBlockBoundsMinX() - f * 2.0F) + f + block.getBlockBoundsMinX();
-		double y1 = y + rand.nextDouble() * (block.getBlockBoundsMaxY() - block.getBlockBoundsMinY() - f * 2.0F) + f + block.getBlockBoundsMinY();
-		double z1 = z + rand.nextDouble() * (block.getBlockBoundsMaxZ() - block.getBlockBoundsMinZ() - f * 2.0F) + f + block.getBlockBoundsMinZ();
+        float f = 0.15F;
+        double x1 = x + rand.nextDouble() * (block.getBlockBoundsMaxX() - block.getBlockBoundsMinX() - f * 2.0F)
+                + f
+                + block.getBlockBoundsMinX();
+        double y1 = y + rand.nextDouble() * (block.getBlockBoundsMaxY() - block.getBlockBoundsMinY() - f * 2.0F)
+                + f
+                + block.getBlockBoundsMinY();
+        double z1 = z + rand.nextDouble() * (block.getBlockBoundsMaxZ() - block.getBlockBoundsMinZ() - f * 2.0F)
+                + f
+                + block.getBlockBoundsMinZ();
 
-		switch (rand.nextInt(6)) {
-		case 0:
-			y1 = y + block.getBlockBoundsMinY() - f;
-			y--;
-			break;
-		case 1:
-			y1 = y + block.getBlockBoundsMaxY() + f;
-			y++;
-			break;
-		case 2:
-			z1 = z + block.getBlockBoundsMinZ() - f;
-			z--;
-			break;
-		case 3:
-			z1 = z + block.getBlockBoundsMaxZ() + f;
-			z++;
-			break;
-		case 4:
-			x1 = x + block.getBlockBoundsMinX() - f;
-			x--;
-			break;
-		case 5:
-			x1 = x + block.getBlockBoundsMaxX() + f;
-			x++;
-			break;
-		}
+        switch (rand.nextInt(6)) {
+            case 0:
+                y1 = y + block.getBlockBoundsMinY() - f;
+                y--;
+                break;
+            case 1:
+                y1 = y + block.getBlockBoundsMaxY() + f;
+                y++;
+                break;
+            case 2:
+                z1 = z + block.getBlockBoundsMinZ() - f;
+                z--;
+                break;
+            case 3:
+                z1 = z + block.getBlockBoundsMaxZ() + f;
+                z++;
+                break;
+            case 4:
+                x1 = x + block.getBlockBoundsMinX() - f;
+                x--;
+                break;
+            case 5:
+                x1 = x + block.getBlockBoundsMaxX() + f;
+                x++;
+                break;
+        }
 
-		if (world.getBlock(x, y, z).isOpaqueCube())
-			return;
+        if (world.getBlock(x, y, z).isOpaqueCube()) return;
 
-		EntityGrimstoneFX res = new EntityGrimstoneFX(world, block, x1, y1, z1);
-		Minecraft.getMinecraft().effectRenderer.addEffect(res);
-	}
+        EntityGrimstoneFX res = new EntityGrimstoneFX(world, block, x1, y1, z1);
+        Minecraft.getMinecraft().effectRenderer.addEffect(res);
+    }
 
-	public static void spawnSnakestoneObsidianFX(World world, BlockSnakestoneObsidian block, int x, int y, int z) {
-		if (Configurations.particlesTickrate != 0 || tick++ % Configurations.particlesTickrate != 0 || Minecraft.getMinecraft().gameSettings.particleSetting != 0) {
-			EntitySnakestoneObsidianFX res = new EntitySnakestoneObsidianFX(world, block, x, y, z);
-			Minecraft.getMinecraft().effectRenderer.addEffect(res);
-		}
-	}
+    public static void spawnSnakestoneObsidianFX(World world, BlockSnakestoneObsidian block, int x, int y, int z) {
+        if (Configurations.particlesTickrate != 0 || tick++ % Configurations.particlesTickrate != 0
+                || Minecraft.getMinecraft().gameSettings.particleSetting != 0) {
+            EntitySnakestoneObsidianFX res = new EntitySnakestoneObsidianFX(world, block, x, y, z);
+            Minecraft.getMinecraft().effectRenderer.addEffect(res);
+        }
+    }
 
-	public static void spawnBallOMossFX(World world, double x, double y, double z) {
-		if (Configurations.particlesTickrate == 0 || tick++ % Configurations.particlesTickrate == 0 || Minecraft.getMinecraft().gameSettings.particleSetting != 0) {
-			EntityBallOMossFX res = new EntityBallOMossFX(world, x, y, z);
-			Minecraft.getMinecraft().effectRenderer.addEffect(res);
-		}
-	}
+    public static void spawnBallOMossFX(World world, double x, double y, double z) {
+        if (Configurations.particlesTickrate == 0 || tick++ % Configurations.particlesTickrate == 0
+                || Minecraft.getMinecraft().gameSettings.particleSetting != 0) {
+            EntityBallOMossFX res = new EntityBallOMossFX(world, x, y, z);
+            Minecraft.getMinecraft().effectRenderer.addEffect(res);
+        }
+    }
 
-	public static EntityDiggingFX addBlockHitEffects(World world, int x, int y, int z, int side) {
-		Block block = world.getBlock(x, y, z);
-		if (block.isAir(world, x, y, z) || Minecraft.getMinecraft().gameSettings.particleSetting != 0)
-			return null;
+    public static EntityDiggingFX addBlockHitEffects(World world, int x, int y, int z, int side) {
+        Block block = world.getBlock(x, y, z);
+        if (block.isAir(world, x, y, z) || Minecraft.getMinecraft().gameSettings.particleSetting != 0) return null;
 
-		EffectRenderer renderer = Minecraft.getMinecraft().effectRenderer;
+        EffectRenderer renderer = Minecraft.getMinecraft().effectRenderer;
 
-		float f = 0.1F;
-		double d0 = x + rand.nextDouble() * (block.getBlockBoundsMaxX() - block.getBlockBoundsMinX() - f * 2.0F) + f + block.getBlockBoundsMinX();
-		double d1 = y + rand.nextDouble() * (block.getBlockBoundsMaxY() - block.getBlockBoundsMinY() - f * 2.0F) + f + block.getBlockBoundsMinY();
-		double d2 = z + rand.nextDouble() * (block.getBlockBoundsMaxZ() - block.getBlockBoundsMinZ() - f * 2.0F) + f + block.getBlockBoundsMinZ();
+        float f = 0.1F;
+        double d0 = x + rand.nextDouble() * (block.getBlockBoundsMaxX() - block.getBlockBoundsMinX() - f * 2.0F)
+                + f
+                + block.getBlockBoundsMinX();
+        double d1 = y + rand.nextDouble() * (block.getBlockBoundsMaxY() - block.getBlockBoundsMinY() - f * 2.0F)
+                + f
+                + block.getBlockBoundsMinY();
+        double d2 = z + rand.nextDouble() * (block.getBlockBoundsMaxZ() - block.getBlockBoundsMinZ() - f * 2.0F)
+                + f
+                + block.getBlockBoundsMinZ();
 
-		switch (side) {
-		case 0:
-			d1 = y + block.getBlockBoundsMinY() - f;
-			break;
-		case 1:
-			d1 = y + block.getBlockBoundsMaxY() + f;
-			break;
-		case 2:
-			d2 = z + block.getBlockBoundsMinZ() - f;
-			break;
-		case 3:
-			d2 = z + block.getBlockBoundsMaxZ() + f;
-			break;
-		case 4:
-			d0 = x + block.getBlockBoundsMinX() - f;
-			break;
-		case 5:
-			d0 = x + block.getBlockBoundsMaxX() + f;
-			break;
-		}
+        switch (side) {
+            case 0:
+                d1 = y + block.getBlockBoundsMinY() - f;
+                break;
+            case 1:
+                d1 = y + block.getBlockBoundsMaxY() + f;
+                break;
+            case 2:
+                d2 = z + block.getBlockBoundsMinZ() - f;
+                break;
+            case 3:
+                d2 = z + block.getBlockBoundsMaxZ() + f;
+                break;
+            case 4:
+                d0 = x + block.getBlockBoundsMinX() - f;
+                break;
+            case 5:
+                d0 = x + block.getBlockBoundsMaxX() + f;
+                break;
+        }
 
-		EntityDiggingFX res = new EntityDiggingFX(world, d0, d1, d2, 0.0D, 0.0D, 0.0D, block, world.getBlockMetadata(x, y, z), side);
-		res.motionX = d0 - (x + 0.5);
-		res.motionY = d1 - (y + 0.5);
-		res.motionZ = d2 - (z + 0.5);
+        EntityDiggingFX res = new EntityDiggingFX(
+                world,
+                d0,
+                d1,
+                d2,
+                0.0D,
+                0.0D,
+                0.0D,
+                block,
+                world.getBlockMetadata(x, y, z),
+                side);
+        res.motionX = d0 - (x + 0.5);
+        res.motionY = d1 - (y + 0.5);
+        res.motionZ = d2 - (z + 0.5);
 
-		renderer.addEffect(res);
+        renderer.addEffect(res);
 
-		return res;
-	}
+        return res;
+    }
 
-	public static void spawnChiselEffect(int x, int y, int z, String sound) {
-		World world = Minecraft.getMinecraft().theWorld;
-		for (int side = 0; side < 6; side++) {
-			for (int j = 0; j < 16; j++) {
-				EntityDiggingFX fx = addBlockHitEffects(Minecraft.getMinecraft().theWorld, x, y, z, side);
-				if (fx == null)
-					return;
+    public static void spawnChiselEffect(int x, int y, int z, String sound) {
+        World world = Minecraft.getMinecraft().theWorld;
+        for (int side = 0; side < 6; side++) {
+            for (int j = 0; j < 16; j++) {
+                EntityDiggingFX fx = addBlockHitEffects(Minecraft.getMinecraft().theWorld, x, y, z, side);
+                if (fx == null) return;
 
-				fx.multipleParticleScaleBy(0.25f + 0.5f * rand.nextFloat());
-				fx.multiplyVelocity(0.3f * rand.nextFloat());
-			}
-		}
+                fx.multipleParticleScaleBy(0.25f + 0.5f * rand.nextFloat());
+                fx.multiplyVelocity(0.3f * rand.nextFloat());
+            }
+        }
 
-		GeneralClient.playChiselSound(world, x, y, z, sound);
-	}
+        GeneralClient.playChiselSound(world, x, y, z, sound);
+    }
 
-	public static void spawnAutoChiselFX(TileEntityAutoChisel te, ItemStack base) {
-		if (base != null && Minecraft.getMinecraft().gameSettings.particleSetting == 0) {
-			for (int i = 0; i < 10; i++) {
-				EntityDiggingFX particle = new EntityDiggingFX(te.getWorldObj(), te.xCoord + 0.5, te.yCoord + 0.95, te.zCoord + 0.5, 0, 0, 0, Block.getBlockFromItem(base.getItem()),
-						base.getItemDamage());
-				particle.setVelocity((te.getWorldObj().rand.nextDouble() / 4) - 0.125, te.getWorldObj().rand.nextDouble() / 8, (te.getWorldObj().rand.nextDouble() / 4) - 0.125);
-				Minecraft.getMinecraft().effectRenderer.addEffect(particle);
-			}
-			String sound = Carving.chisel.getVariationSound(base.getItem(), base.getItemDamage());
-			GeneralClient.playChiselSound(te.getWorldObj(), te.xCoord, te.yCoord, te.zCoord, sound);
-		}
-	}
+    public static void spawnAutoChiselFX(TileEntityAutoChisel te, ItemStack base) {
+        if (base != null && Minecraft.getMinecraft().gameSettings.particleSetting == 0) {
+            for (int i = 0; i < 10; i++) {
+                EntityDiggingFX particle = new EntityDiggingFX(
+                        te.getWorldObj(),
+                        te.xCoord + 0.5,
+                        te.yCoord + 0.95,
+                        te.zCoord + 0.5,
+                        0,
+                        0,
+                        0,
+                        Block.getBlockFromItem(base.getItem()),
+                        base.getItemDamage());
+                particle.setVelocity(
+                        (te.getWorldObj().rand.nextDouble() / 4) - 0.125,
+                        te.getWorldObj().rand.nextDouble() / 8,
+                        (te.getWorldObj().rand.nextDouble() / 4) - 0.125);
+                Minecraft.getMinecraft().effectRenderer.addEffect(particle);
+            }
+            String sound = Carving.chisel.getVariationSound(base.getItem(), base.getItemDamage());
+            GeneralClient.playChiselSound(te.getWorldObj(), te.xCoord, te.yCoord, te.zCoord, sound);
+        }
+    }
 }

src/main/java/team/chisel/client/gui/GuiAutoChisel.java

@@ -18,66 +18,74 @@ import com.google.common.collect.Lists;
 
 public class GuiAutoChisel extends GuiContainer {
 
-	private static final ResourceLocation gui = new ResourceLocation("chisel:textures/autochisel-gui.png");
+    private static final ResourceLocation gui = new ResourceLocation("chisel:textures/autochisel-gui.png");
 
-	private TileEntityAutoChisel autochisel;
+    private TileEntityAutoChisel autochisel;
 
-	public GuiAutoChisel(InventoryPlayer inventoryPlayer, TileEntityAutoChisel tileEntityAutoChisel) {
-		super(new ContainerAutoChisel(inventoryPlayer, tileEntityAutoChisel));
-		autochisel = tileEntityAutoChisel;
-	}
+    public GuiAutoChisel(InventoryPlayer inventoryPlayer, TileEntityAutoChisel tileEntityAutoChisel) {
+        super(new ContainerAutoChisel(inventoryPlayer, tileEntityAutoChisel));
+        autochisel = tileEntityAutoChisel;
+    }
 
-	@Override
-	protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) {
-		super.drawGuiContainerForegroundLayer(mouseX, mouseY);
-	}
-	
-	@SuppressWarnings("unchecked")
-	@Override
-	public void drawScreen(int mouseX, int mouseY, float partialTick) {
-		super.drawScreen(mouseX, mouseY, partialTick);
+    @Override
+    protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) {
+        super.drawGuiContainerForegroundLayer(mouseX, mouseY);
+    }
 
-		int x = (this.width - this.xSize) / 2;
-		int y = (this.height - this.ySize) / 2;
+    @SuppressWarnings("unchecked")
+    @Override
+    public void drawScreen(int mouseX, int mouseY, float partialTick) {
+        super.drawScreen(mouseX, mouseY, partialTick);
 
-		for (Slot slot : (List<Slot>) inventorySlots.inventorySlots) {
-			if (!slot.getHasStack() && mouseInside(slot, mouseX - x, mouseY - y)) {
-				if (slot.slotNumber < autochisel.getSizeInventory()) {
-					String tt = autochisel.getSlotTooltipUnloc(slot.slotNumber);
-					if (!Strings.isNullOrEmpty(tt)) {
-						this.func_146283_a(Lists.newArrayList(tt), mouseX, mouseY);
-					}
-				}
-			}
-		}
-		RenderHelper.enableGUIStandardItemLighting();
-	}
+        int x = (this.width - this.xSize) / 2;
+        int y = (this.height - this.ySize) / 2;
 
-	private boolean mouseInside(Slot slot, int x, int y) {
-		return x >= slot.xDisplayPosition && x <= slot.xDisplayPosition + 16 && y >= slot.yDisplayPosition && y <= slot.yDisplayPosition + 16;
-	}
+        for (Slot slot : (List<Slot>) inventorySlots.inventorySlots) {
+            if (!slot.getHasStack() && mouseInside(slot, mouseX - x, mouseY - y)) {
+                if (slot.slotNumber < autochisel.getSizeInventory()) {
+                    String tt = autochisel.getSlotTooltipUnloc(slot.slotNumber);
+                    if (!Strings.isNullOrEmpty(tt)) {
+                        this.func_146283_a(Lists.newArrayList(tt), mouseX, mouseY);
+                    }
+                }
+            }
+        }
+        RenderHelper.enableGUIStandardItemLighting();
+    }
 
-	@Override
-	protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) {
-		GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-		this.mc.renderEngine.bindTexture(gui);
-		int x = (width - xSize) / 2;
-		int y = (height - ySize) / 2;
-		this.drawTexturedModalRect(x, y, 0, 0, xSize, ySize);
+    private boolean mouseInside(Slot slot, int x, int y) {
+        return x >= slot.xDisplayPosition && x <= slot.xDisplayPosition + 16
+                && y >= slot.yDisplayPosition
+                && y <= slot.yDisplayPosition + 16;
+    }
 
-		for (int i = TileEntityAutoChisel.BASE; i < TileEntityAutoChisel.CHISEL; i++) {
-			if (autochisel.getStackInSlot(i) == null) {
-				drawSlotOverlay(this, x, y, inventorySlots.getSlot(i), xSize, 0, 8);
-			}
-		}
+    @Override
+    protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) {
+        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+        this.mc.renderEngine.bindTexture(gui);
+        int x = (width - xSize) / 2;
+        int y = (height - ySize) / 2;
+        this.drawTexturedModalRect(x, y, 0, 0, xSize, ySize);
 
-		if (autochisel.getStackInSlot(TileEntityAutoChisel.CHISEL) == null) {
-			drawSlotOverlay(this, x, y, inventorySlots.getSlot(TileEntityAutoChisel.CHISEL), xSize, 24, 0);
-		}
-	}
+        for (int i = TileEntityAutoChisel.BASE; i < TileEntityAutoChisel.CHISEL; i++) {
+            if (autochisel.getStackInSlot(i) == null) {
+                drawSlotOverlay(this, x, y, inventorySlots.getSlot(i), xSize, 0, 8);
+            }
+        }
 
-	public static void drawSlotOverlay(GuiContainer gui, int x, int y, Slot slot, int u, int v, int padding) {
-		padding /= 2;
-		gui.drawTexturedModalRect(x + (slot.xDisplayPosition - padding), y + (slot.yDisplayPosition - padding), u, v, 18 + padding, 18 + padding);
-	}
+        if (autochisel.getStackInSlot(TileEntityAutoChisel.CHISEL) == null) {
+            drawSlotOverlay(this, x, y, inventorySlots.getSlot(TileEntityAutoChisel.CHISEL), xSize, 24, 0);
+        }
+    }
+
+    public static void drawSlotOverlay(GuiContainer gui, int x, int y, Slot slot, int u, int v, int padding) {
+        padding /= 2;
+        gui.drawTexturedModalRect(
+                x + (slot.xDisplayPosition - padding),
+                y + (slot.yDisplayPosition - padding),
+                u,
+                v,
+                18 + padding,
+                18 + padding);
+    }
 }

src/main/java/team/chisel/client/gui/GuiChisel.java

@@ -1,10 +1,7 @@
 package team.chisel.client.gui;
 
-import com.cricketcraft.chisel.api.IAdvancedChisel;
-import com.cricketcraft.chisel.api.IChiselItem;
-import com.cricketcraft.chisel.api.carving.IChiselMode;
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
+import static team.chisel.Chisel.MOD_ID;
+
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.client.gui.inventory.GuiContainer;
 import net.minecraft.client.resources.I18n;
@@ -13,8 +10,10 @@ import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.ResourceLocation;
+
 import org.lwjgl.input.Mouse;
 import org.lwjgl.opengl.GL11;
+
 import team.chisel.client.gui.widgets.GuiButtonChiselMode;
 import team.chisel.inventory.ContainerChisel;
 import team.chisel.inventory.InventoryChiselSelection;
@@ -24,12 +23,19 @@ import team.chisel.network.PacketHandler;
 import team.chisel.network.message.MessageChiselMode;
 import team.chisel.utils.General;
 
-import static team.chisel.Chisel.MOD_ID;
+import com.cricketcraft.chisel.api.IAdvancedChisel;
+import com.cricketcraft.chisel.api.IChiselItem;
+import com.cricketcraft.chisel.api.carving.IChiselMode;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
 
 @SideOnly(Side.CLIENT)
 public class GuiChisel extends GuiContainer {
 
-    public static final ResourceLocation TEXTURE_RESOURCE_LOCATION = new ResourceLocation(MOD_ID, "textures/chisel2GuiScroll.png");
+    public static final ResourceLocation TEXTURE_RESOURCE_LOCATION = new ResourceLocation(
+            MOD_ID,
+            "textures/chisel2GuiScroll.png");
     public static final int TEXTURE_WIDTH = 266;
     public static final int TEXTURE_HEIGHT = 250;
     public static final int GUI_WIDTH = 266;
@@ -84,8 +90,7 @@ public class GuiChisel extends GuiContainer {
     }
 
     private boolean showMode() {
-        return container.chisel != null
-                && container.chisel.getItem() instanceof IChiselItem
+        return container.chisel != null && container.chisel.getItem() instanceof IChiselItem
                 && ((IChiselItem) container.chisel.getItem()).hasModes(container.chisel);
     }
 
@@ -94,11 +99,16 @@ public class GuiChisel extends GuiContainer {
         GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
 
         final String titleText = I18n.format(container.inventory.getInventoryName() + ".title");
-        fontRendererObj.drawSplitString(titleText, 50 - fontRendererObj.getStringWidth(titleText) / 2, 60, 40, 0x404040);
+        fontRendererObj
+                .drawSplitString(titleText, 50 - fontRendererObj.getStringWidth(titleText) / 2, 60, 40, 0x404040);
 
         if (showMode()) {
             final String modeText = I18n.format(container.inventory.getInventoryName() + ".mode");
-            fontRendererObj.drawString(modeText, 12 + (GuiButtonChiselMode.BUTTON_WIDTH - fontRendererObj.getStringWidth(modeText)) / 2, 122, 0x404040);
+            fontRendererObj.drawString(
+                    modeText,
+                    12 + (GuiButtonChiselMode.BUTTON_WIDTH - fontRendererObj.getStringWidth(modeText)) / 2,
+                    122,
+                    0x404040);
         }
 
         scrollBar.draw(this);
@@ -115,7 +125,15 @@ public class GuiChisel extends GuiContainer {
 
         Slot main = (Slot) container.inventorySlots.get(InventoryChiselSelection.normalSlots);
         if (main.getStack() == null) {
-            func_146110_a(guiLeft + 8, guiTop + 8, 0, GUI_HEIGHT, CHISEL_INPUT_SIZE, CHISEL_INPUT_SIZE, TEXTURE_WIDTH, TEXTURE_HEIGHT);
+            func_146110_a(
+                    guiLeft + 8,
+                    guiTop + 8,
+                    0,
+                    GUI_HEIGHT,
+                    CHISEL_INPUT_SIZE,
+                    CHISEL_INPUT_SIZE,
+                    TEXTURE_WIDTH,
+                    TEXTURE_HEIGHT);
         }
     }
 

src/main/java/team/chisel/client/gui/GuiChiselConfig.java

@@ -1,17 +1,24 @@
 package team.chisel.client.gui;
 
-import team.chisel.Chisel;
-import team.chisel.config.Configurations;
 import net.minecraft.client.gui.GuiScreen;
 import net.minecraftforge.common.config.ConfigCategory;
 import net.minecraftforge.common.config.ConfigElement;
 import net.minecraftforge.common.config.Configuration;
+
+import team.chisel.Chisel;
+import team.chisel.config.Configurations;
 import cpw.mods.fml.client.config.GuiConfig;
 
 public class GuiChiselConfig extends GuiConfig {
 
-	public GuiChiselConfig(GuiScreen parent) {
-		super(parent, new ConfigElement<ConfigCategory>(Configurations.config.getCategory(Configuration.CATEGORY_GENERAL)).getChildElements(), Chisel.MOD_ID, false, false, GuiConfig
-				.getAbridgedConfigPath(Configurations.config.toString()));
-	}
+    public GuiChiselConfig(GuiScreen parent) {
+        super(
+                parent,
+                new ConfigElement<ConfigCategory>(Configurations.config.getCategory(Configuration.CATEGORY_GENERAL))
+                        .getChildElements(),
+                Chisel.MOD_ID,
+                false,
+                false,
+                GuiConfig.getAbridgedConfigPath(Configurations.config.toString()));
+    }
 }

src/main/java/team/chisel/client/gui/GuiFactory.java

@@ -4,27 +4,28 @@ import java.util.Set;
 
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiScreen;
+
 import cpw.mods.fml.client.IModGuiFactory;
 
 public class GuiFactory implements IModGuiFactory {
 
-	@Override
-	public void initialize(Minecraft minecraftInstance) {
+    @Override
+    public void initialize(Minecraft minecraftInstance) {
 
-	}
+    }
 
-	@Override
-	public Class<? extends GuiScreen> mainConfigGuiClass() {
-		return GuiChiselConfig.class;
-	}
+    @Override
+    public Class<? extends GuiScreen> mainConfigGuiClass() {
+        return GuiChiselConfig.class;
+    }
 
-	@Override
-	public Set<RuntimeOptionCategoryElement> runtimeGuiCategories() {
-		return null;
-	}
+    @Override
+    public Set<RuntimeOptionCategoryElement> runtimeGuiCategories() {
+        return null;
+    }
 
-	@Override
-	public RuntimeOptionGuiHandler getHandlerFor(RuntimeOptionCategoryElement element) {
-		return null;
-	}
-}
+    @Override
+    public RuntimeOptionGuiHandler getHandlerFor(RuntimeOptionCategoryElement element) {
+        return null;
+    }
+}

src/main/java/team/chisel/client/gui/GuiPresent.java

@@ -11,22 +11,22 @@ import team.chisel.inventory.ContainerPresent;
 
 public class GuiPresent extends GuiContainer {
 
-	private static final ResourceLocation gui = new ResourceLocation("chisel:textures/present-gui.png");
-	private int rows;
+    private static final ResourceLocation gui = new ResourceLocation("chisel:textures/present-gui.png");
+    private int rows;
 
-	public GuiPresent(InventoryPlayer inventoryPlayer, TileEntityPresent tileEntityPresent) {
-		super(new ContainerPresent(inventoryPlayer, tileEntityPresent));
-		rows = tileEntityPresent.getSizeInventory() / 9;
-		this.ySize = 114 + rows * 18;
-	}
+    public GuiPresent(InventoryPlayer inventoryPlayer, TileEntityPresent tileEntityPresent) {
+        super(new ContainerPresent(inventoryPlayer, tileEntityPresent));
+        rows = tileEntityPresent.getSizeInventory() / 9;
+        this.ySize = 114 + rows * 18;
+    }
 
-	@Override
-	protected void drawGuiContainerBackgroundLayer(float p_146976_1_, int p_146976_2_, int p_146976_3_) {
-		GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-		this.mc.getTextureManager().bindTexture(gui);
-		int x = (this.width - this.xSize) / 2;
-		int y = (this.height - this.ySize) / 2;
-		this.drawTexturedModalRect(x, y, 0, 0, this.xSize, this.rows * 18 + 17);
-		this.drawTexturedModalRect(x, y + this.rows * 18 + 17, 0, 126, this.xSize, 96);
-	}
+    @Override
+    protected void drawGuiContainerBackgroundLayer(float p_146976_1_, int p_146976_2_, int p_146976_3_) {
+        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+        this.mc.getTextureManager().bindTexture(gui);
+        int x = (this.width - this.xSize) / 2;
+        int y = (this.height - this.ySize) / 2;
+        this.drawTexturedModalRect(x, y, 0, 0, this.xSize, this.rows * 18 + 17);
+        this.drawTexturedModalRect(x, y + this.rows * 18 + 17, 0, 126, this.xSize, 96);
+    }
 }

src/main/java/team/chisel/client/gui/GuiScrollbar.java

@@ -1,13 +1,18 @@
 package team.chisel.client.gui;
 
 import net.minecraft.util.ResourceLocation;
+
 import org.lwjgl.opengl.GL11;
+
 import team.chisel.inventory.ContainerChisel;
 import team.chisel.network.PacketHandler;
 import team.chisel.network.message.MessageScrollUpdate;
 
 public class GuiScrollbar {
-    public static final ResourceLocation TEXTURE_RESOURCE_LOCATION = new ResourceLocation("minecraft", "textures/gui/container/creative_inventory/tabs.png");
+
+    public static final ResourceLocation TEXTURE_RESOURCE_LOCATION = new ResourceLocation(
+            "minecraft",
+            "textures/gui/container/creative_inventory/tabs.png");
 
     private int displayX = 0;
     private int displayY = 0;
@@ -21,7 +26,8 @@ public class GuiScrollbar {
     private ContainerChisel container;
 
     public void draw(GuiChisel g) {
-        // chisel2GuiScroll scroll button texture coordinates work strange (maybe because of alignment) so taking vanilla one
+        // chisel2GuiScroll scroll button texture coordinates work strange (maybe because of alignment) so taking
+        // vanilla one
         g.mc.getTextureManager().bindTexture(TEXTURE_RESOURCE_LOCATION);
         GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 

src/main/java/team/chisel/client/gui/widgets/GuiButtonChiselMode.java

@@ -1,106 +1,119 @@
 package team.chisel.client.gui.widgets;
 
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.GuiButton;
-import org.lwjgl.opengl.GL11;
-import team.chisel.client.gui.GuiChisel;
-import team.chisel.item.chisel.ChiselMode;
-
 import static team.chisel.client.gui.GuiChisel.*;
 
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiButton;
+
+import org.lwjgl.opengl.GL11;
+
+import team.chisel.client.gui.GuiChisel;
+import team.chisel.item.chisel.ChiselMode;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
 @SideOnly(Side.CLIENT)
 public class GuiButtonChiselMode extends GuiButton {
-	public static final int BUTTON_WIDTH = 48;
-	public static final int BUTTON_HEIGHT = 48;
-	private static final float BUTTON_BACKGROUND_U = 48;
-	private static final float BUTTON_BACKGROUND_V = 202;
-	private static final float MODE_VIGNETTE_U = BUTTON_BACKGROUND_U + 2 * BUTTON_WIDTH + 3;
-	private static final float MODE_VIGNETTE_V = BUTTON_BACKGROUND_V + 3;
-	private static final int MODE_VIGNETTE_WIDTH = 14;
-	private static final int MODE_VIGNETTE_ROW_WIDTH = 3 * MODE_VIGNETTE_WIDTH;
-	private static final int MODE_VIGNETTE_HEIGHT = 14;
-	private static final int MODE_VIGNETTE_COL_HEIGHT = 3 * MODE_VIGNETTE_HEIGHT;
-	private final GuiChisel guiChisel;
 
-	public GuiButtonChiselMode(int id, int x, int y, GuiChisel guiChisel) {
-		super(id, x, y, BUTTON_WIDTH, BUTTON_HEIGHT, "");
-		this.guiChisel = guiChisel;
-	}
+    public static final int BUTTON_WIDTH = 48;
+    public static final int BUTTON_HEIGHT = 48;
+    private static final float BUTTON_BACKGROUND_U = 48;
+    private static final float BUTTON_BACKGROUND_V = 202;
+    private static final float MODE_VIGNETTE_U = BUTTON_BACKGROUND_U + 2 * BUTTON_WIDTH + 3;
+    private static final float MODE_VIGNETTE_V = BUTTON_BACKGROUND_V + 3;
+    private static final int MODE_VIGNETTE_WIDTH = 14;
+    private static final int MODE_VIGNETTE_ROW_WIDTH = 3 * MODE_VIGNETTE_WIDTH;
+    private static final int MODE_VIGNETTE_HEIGHT = 14;
+    private static final int MODE_VIGNETTE_COL_HEIGHT = 3 * MODE_VIGNETTE_HEIGHT;
+    private final GuiChisel guiChisel;
 
-	/**
-	 * Draws this button to the screen.
-	 *
-	 * @param mc     The Minecraft instance
-	 * @param mouseX The horizontal location of the mouse within the GuiScreen
-	 * @param mouseY The vertical location of the mouse relative to the GuiScreen
-	 */
-	@Override
-	public void drawButton(final Minecraft mc, final int mouseX, final int mouseY) {
-		if (this.visible) {
-			mc.getTextureManager().bindTexture(TEXTURE_RESOURCE_LOCATION);
-			GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-			// Mouse Hover State
-			this.field_146123_n = mouseX >= this.xPosition && mouseY >= this.yPosition && mouseX < this.xPosition + this.width && mouseY < this.yPosition + this.height;
-			drawButtonBackgroundLayer();
-			drawButtonForegroundLayer();
-		}
-	}
+    public GuiButtonChiselMode(int id, int x, int y, GuiChisel guiChisel) {
+        super(id, x, y, BUTTON_WIDTH, BUTTON_HEIGHT, "");
+        this.guiChisel = guiChisel;
+    }
 
-	private void drawButtonBackgroundLayer() {
-		final float u = BUTTON_BACKGROUND_U + (this.field_146123_n ? BUTTON_WIDTH : 0);
-		// drawModalRectWithCustomSizedTexture: x, y, u, v, width, height, textureWidth, textureHeight
-		func_146110_a(this.xPosition, this.yPosition, u, BUTTON_BACKGROUND_V, this.width, this.height, TEXTURE_WIDTH, TEXTURE_HEIGHT);
-	}
+    /**
+     * Draws this button to the screen.
+     *
+     * @param mc     The Minecraft instance
+     * @param mouseX The horizontal location of the mouse within the GuiScreen
+     * @param mouseY The vertical location of the mouse relative to the GuiScreen
+     */
+    @Override
+    public void drawButton(final Minecraft mc, final int mouseX, final int mouseY) {
+        if (this.visible) {
+            mc.getTextureManager().bindTexture(TEXTURE_RESOURCE_LOCATION);
+            GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+            // Mouse Hover State
+            this.field_146123_n = mouseX >= this.xPosition && mouseY >= this.yPosition
+                    && mouseX < this.xPosition + this.width
+                    && mouseY < this.yPosition + this.height;
+            drawButtonBackgroundLayer();
+            drawButtonForegroundLayer();
+        }
+    }
 
-	private void drawButtonForegroundLayer() {
-		final int xBase = this.xPosition + 3;
-		final int yBase = this.yPosition + 3;
-		final float uBase = MODE_VIGNETTE_U + (this.field_146123_n ? BUTTON_WIDTH : 0);
-		final float u;
-		final float v;
-		final int w;
-		final int h;
-		final int x;
-		final int y;
-		switch ((ChiselMode) guiChisel.getCurrentMode()) {
-			case SINGLE:
-				x = xBase + MODE_VIGNETTE_WIDTH;
-				y = yBase + MODE_VIGNETTE_HEIGHT;
-				u = uBase + MODE_VIGNETTE_WIDTH;
-				v = MODE_VIGNETTE_V + MODE_VIGNETTE_HEIGHT;
-				w = MODE_VIGNETTE_WIDTH;
-				h = MODE_VIGNETTE_HEIGHT;
-				break;
-			case ROW:
-				x = xBase;
-				y = yBase + MODE_VIGNETTE_HEIGHT;
-				u = uBase;
-				v = MODE_VIGNETTE_V + MODE_VIGNETTE_HEIGHT;
-				w = MODE_VIGNETTE_ROW_WIDTH;
-				h = MODE_VIGNETTE_HEIGHT;
-				break;
-			case COLUMN:
-				x = xBase + MODE_VIGNETTE_WIDTH;
-				y = yBase;
-				u = uBase + MODE_VIGNETTE_WIDTH;
-				v = MODE_VIGNETTE_V;
-				w = MODE_VIGNETTE_WIDTH;
-				h = MODE_VIGNETTE_COL_HEIGHT;
-				break;
-			case PANEL:
-				x = xBase;
-				y = yBase;
-				u = uBase;
-				v = MODE_VIGNETTE_V;
-				w = MODE_VIGNETTE_ROW_WIDTH;
-				h = MODE_VIGNETTE_COL_HEIGHT;
-				break;
-			default:
-				return;
-		}
-		// drawModalRectWithCustomSizedTexture: x, y, u, v, width, height, textureWidth, textureHeight
-		func_146110_a(x, y, u, v, w, h, TEXTURE_WIDTH, TEXTURE_HEIGHT);
-	}
+    private void drawButtonBackgroundLayer() {
+        final float u = BUTTON_BACKGROUND_U + (this.field_146123_n ? BUTTON_WIDTH : 0);
+        // drawModalRectWithCustomSizedTexture: x, y, u, v, width, height, textureWidth, textureHeight
+        func_146110_a(
+                this.xPosition,
+                this.yPosition,
+                u,
+                BUTTON_BACKGROUND_V,
+                this.width,
+                this.height,
+                TEXTURE_WIDTH,
+                TEXTURE_HEIGHT);
+    }
+
+    private void drawButtonForegroundLayer() {
+        final int xBase = this.xPosition + 3;
+        final int yBase = this.yPosition + 3;
+        final float uBase = MODE_VIGNETTE_U + (this.field_146123_n ? BUTTON_WIDTH : 0);
+        final float u;
+        final float v;
+        final int w;
+        final int h;
+        final int x;
+        final int y;
+        switch ((ChiselMode) guiChisel.getCurrentMode()) {
+            case SINGLE:
+                x = xBase + MODE_VIGNETTE_WIDTH;
+                y = yBase + MODE_VIGNETTE_HEIGHT;
+                u = uBase + MODE_VIGNETTE_WIDTH;
+                v = MODE_VIGNETTE_V + MODE_VIGNETTE_HEIGHT;
+                w = MODE_VIGNETTE_WIDTH;
+                h = MODE_VIGNETTE_HEIGHT;
+                break;
+            case ROW:
+                x = xBase;
+                y = yBase + MODE_VIGNETTE_HEIGHT;
+                u = uBase;
+                v = MODE_VIGNETTE_V + MODE_VIGNETTE_HEIGHT;
+                w = MODE_VIGNETTE_ROW_WIDTH;
+                h = MODE_VIGNETTE_HEIGHT;
+                break;
+            case COLUMN:
+                x = xBase + MODE_VIGNETTE_WIDTH;
+                y = yBase;
+                u = uBase + MODE_VIGNETTE_WIDTH;
+                v = MODE_VIGNETTE_V;
+                w = MODE_VIGNETTE_WIDTH;
+                h = MODE_VIGNETTE_COL_HEIGHT;
+                break;
+            case PANEL:
+                x = xBase;
+                y = yBase;
+                u = uBase;
+                v = MODE_VIGNETTE_V;
+                w = MODE_VIGNETTE_ROW_WIDTH;
+                h = MODE_VIGNETTE_COL_HEIGHT;
+                break;
+            default:
+                return;
+        }
+        // drawModalRectWithCustomSizedTexture: x, y, u, v, width, height, textureWidth, textureHeight
+        func_146110_a(x, y, u, v, w, h, TEXTURE_WIDTH, TEXTURE_HEIGHT);
+    }
 }

src/main/java/team/chisel/client/render/RenderBlocksEldritch.java

@@ -7,288 +7,296 @@ import net.minecraft.util.IIcon;
 
 public class RenderBlocksEldritch extends RenderBlocks {
 
-	RenderBlocksEldritch() {
-		super();
-	}
+    RenderBlocksEldritch() {
+        super();
+    }
 
-	static double displacementMap[] = { +0.1165, -0.0352, -0.1208, +0.0906, -0.0295, +0.0302, -0.0973, +0.0548, -0.1077, +0.0662, -0.0932, -0.0925, -0.1161, +0.0073, -0.1084, +0.1136, +0.0307,
-			+0.0316, -0.1066, -0.0237, +0.0614, -0.0864, +0.0837, +0.1218, +0.0502, -0.0529, -0.0942, +0.1209, -0.0418, +0.1035, +0.0066, -0.0255, +0.0830, -0.0361, +0.0965, +0.0646, +0.1124,
-			+0.0890, -0.0037, +0.0467, +0.1025, +0.1161, +0.0014, +0.0365, +0.0755, -0.0025, +0.0739, +0.0656, +0.0571, -0.0813, -0.0062, -0.0904, -0.0005, +0.0612, -0.0227, +0.0138, -0.0899,
-			-0.0019, -0.1047, +0.1191, -0.1197, -0.1123, +0.0999, +0.0638, +0.0865, +0.0029, -0.0084, +0.1132, -0.0433, +0.0115, +0.0850, +0.0439, +0.0748, +0.0460, -0.0441, +0.0839, +0.0162,
-			-0.0229, +0.0774, -0.0647, -0.0636, -0.0709, -0.0719, -0.0194, +0.1070, -0.0466, -0.1200, -0.0996, -0.0298, -0.1035, -0.0006, +0.0530, -0.0939, -0.1210, +0.0176, +0.0924, +0.0343,
-			-0.0777, +0.1050, -0.0729, -0.0062, -0.1107, -0.0434, -0.0042, +0.0232, +0.0269, +0.0709, -0.0388, +0.0342, +0.0240, -0.0192, +0.0491, +0.0017, -0.1240, +0.0687, -0.1160, +0.1123,
-			-0.0332, -0.0260, +0.0476, -0.0049, -0.0893, -0.0243, -0.0371, -0.0230, +0.0656, +0.1080, +0.0781, -0.0648, +0.0082, -0.1086, -0.0451, -0.0594, -0.1155, -0.0623, -0.0152, +0.0131,
-			-0.0754, +0.0607, +0.0876, -0.0657, +0.0366, -0.0981, +0.1164, -0.0623, +0.0181, -0.0475, +0.0722, -0.0293, +0.0486, -0.0195, +0.1041, +0.1011, +0.0042, -0.0045, -0.1031, +0.0110,
-			+0.0058, +0.0083, -0.0782, -0.1003, -0.0082, -0.0304, -0.0971, -0.0097, -0.0208, -0.1059, -0.0239, -0.0385, +0.0505, +0.0537, -0.1098, -0.0022, -0.0165, -0.0027, -0.0208, +0.0305,
-			+0.0592, +0.0301, +0.0055, +0.1138, -0.0338, -0.0901, +0.1015, +0.0061, +0.0861, -0.1057, -0.0889, -0.0972, +0.0783, -0.1052, -0.0932, -0.1103, +0.0497, +0.1222, -0.0146, +0.0632,
-			-0.0240, -0.0193, +0.0676, -0.1128, -0.0886, +0.0926, +0.0538, -0.0175, -0.0966, -0.0369, +0.1124, -0.0820, -0.1013, -0.0836, -0.0981, -0.0502, +0.0573, +0.0616, -0.0458, +0.0294,
-			+0.0108, -0.0782, +0.0692, +0.0234, -0.0178, -0.0171, -0.0505, -0.0313, +0.0538, +0.0462, -0.0758, +0.0556, -0.0023, -0.1086, -0.0100, -0.0897, -0.0409, -0.1161, +0.0212, +0.1229,
-			-0.0945, +0.0341, +0.1238, +0.0893, -0.1189, -0.1098, -0.0125, +0.1137, -0.0202, +0.0239, -0.0408, +0.0920, +0.0777, -0.0085, -0.0572, -0.0293, -0.0131, +0.0272, +0.0991, };
+    static double displacementMap[] = { +0.1165, -0.0352, -0.1208, +0.0906, -0.0295, +0.0302, -0.0973, +0.0548, -0.1077,
+            +0.0662, -0.0932, -0.0925, -0.1161, +0.0073, -0.1084, +0.1136, +0.0307, +0.0316, -0.1066, -0.0237, +0.0614,
+            -0.0864, +0.0837, +0.1218, +0.0502, -0.0529, -0.0942, +0.1209, -0.0418, +0.1035, +0.0066, -0.0255, +0.0830,
+            -0.0361, +0.0965, +0.0646, +0.1124, +0.0890, -0.0037, +0.0467, +0.1025, +0.1161, +0.0014, +0.0365, +0.0755,
+            -0.0025, +0.0739, +0.0656, +0.0571, -0.0813, -0.0062, -0.0904, -0.0005, +0.0612, -0.0227, +0.0138, -0.0899,
+            -0.0019, -0.1047, +0.1191, -0.1197, -0.1123, +0.0999, +0.0638, +0.0865, +0.0029, -0.0084, +0.1132, -0.0433,
+            +0.0115, +0.0850, +0.0439, +0.0748, +0.0460, -0.0441, +0.0839, +0.0162, -0.0229, +0.0774, -0.0647, -0.0636,
+            -0.0709, -0.0719, -0.0194, +0.1070, -0.0466, -0.1200, -0.0996, -0.0298, -0.1035, -0.0006, +0.0530, -0.0939,
+            -0.1210, +0.0176, +0.0924, +0.0343, -0.0777, +0.1050, -0.0729, -0.0062, -0.1107, -0.0434, -0.0042, +0.0232,
+            +0.0269, +0.0709, -0.0388, +0.0342, +0.0240, -0.0192, +0.0491, +0.0017, -0.1240, +0.0687, -0.1160, +0.1123,
+            -0.0332, -0.0260, +0.0476, -0.0049, -0.0893, -0.0243, -0.0371, -0.0230, +0.0656, +0.1080, +0.0781, -0.0648,
+            +0.0082, -0.1086, -0.0451, -0.0594, -0.1155, -0.0623, -0.0152, +0.0131, -0.0754, +0.0607, +0.0876, -0.0657,
+            +0.0366, -0.0981, +0.1164, -0.0623, +0.0181, -0.0475, +0.0722, -0.0293, +0.0486, -0.0195, +0.1041, +0.1011,
+            +0.0042, -0.0045, -0.1031, +0.0110, +0.0058, +0.0083, -0.0782, -0.1003, -0.0082, -0.0304, -0.0971, -0.0097,
+            -0.0208, -0.1059, -0.0239, -0.0385, +0.0505, +0.0537, -0.1098, -0.0022, -0.0165, -0.0027, -0.0208, +0.0305,
+            +0.0592, +0.0301, +0.0055, +0.1138, -0.0338, -0.0901, +0.1015, +0.0061, +0.0861, -0.1057, -0.0889, -0.0972,
+            +0.0783, -0.1052, -0.0932, -0.1103, +0.0497, +0.1222, -0.0146, +0.0632, -0.0240, -0.0193, +0.0676, -0.1128,
+            -0.0886, +0.0926, +0.0538, -0.0175, -0.0966, -0.0369, +0.1124, -0.0820, -0.1013, -0.0836, -0.0981, -0.0502,
+            +0.0573, +0.0616, -0.0458, +0.0294, +0.0108, -0.0782, +0.0692, +0.0234, -0.0178, -0.0171, -0.0505, -0.0313,
+            +0.0538, +0.0462, -0.0758, +0.0556, -0.0023, -0.1086, -0.0100, -0.0897, -0.0409, -0.1161, +0.0212, +0.1229,
+            -0.0945, +0.0341, +0.1238, +0.0893, -0.1189, -0.1098, -0.0125, +0.1137, -0.0202, +0.0239, -0.0408, +0.0920,
+            +0.0777, -0.0085, -0.0572, -0.0293, -0.0131, +0.0272, +0.0991, };
 
-	static int dmap1 = displacementMap.length * 1 / 6;
-	static int dmap2 = displacementMap.length * 2 / 6;
-	static int dmap3 = displacementMap.length * 3 / 6;
-	static int dmap4 = displacementMap.length * 4 / 6;
-	static int dmap5 = displacementMap.length * 5 / 6;
-	static int dmap = displacementMap.length;
+    static int dmap1 = displacementMap.length * 1 / 6;
+    static int dmap2 = displacementMap.length * 2 / 6;
+    static int dmap3 = displacementMap.length * 3 / 6;
+    static int dmap4 = displacementMap.length * 4 / 6;
+    static int dmap5 = displacementMap.length * 5 / 6;
+    static int dmap = displacementMap.length;
 
-	Tessellator tessellator;
-	double[] X = new double[14];
-	double[] Y = new double[14];
-	double[] Z = new double[14];
-	double[] U = new double[14];
-	double[] V = new double[14];
-	int[] L = new int[14];
-	float[] R = new float[14];
-	float[] G = new float[14];
-	float[] B = new float[14];
+    Tessellator tessellator;
+    double[] X = new double[14];
+    double[] Y = new double[14];
+    double[] Z = new double[14];
+    double[] U = new double[14];
+    double[] V = new double[14];
+    int[] L = new int[14];
+    float[] R = new float[14];
+    float[] G = new float[14];
+    float[] B = new float[14];
 
-	@Override
-	public boolean renderStandardBlock(Block block, int x, int y, int z) {
-		int index = x + y * 34573 + z * 32465781;
-		if (index < 0)
-			index = -index;
+    @Override
+    public boolean renderStandardBlock(Block block, int x, int y, int z) {
+        int index = x + y * 34573 + z * 32465781;
+        if (index < 0) index = -index;
 
-		X[0] = x;
-		Z[0] = z;
-		Y[0] = y;
+        X[0] = x;
+        Z[0] = z;
+        Y[0] = y;
 
-		X[1] = x;
-		Z[1] = z;
-		Y[1] = y + 1;
+        X[1] = x;
+        Z[1] = z;
+        Y[1] = y + 1;
 
-		X[2] = x + 1;
-		Z[2] = z;
-		Y[2] = y + 1;
+        X[2] = x + 1;
+        Z[2] = z;
+        Y[2] = y + 1;
 
-		X[3] = x + 1;
-		Z[3] = z;
-		Y[3] = y;
+        X[3] = x + 1;
+        Z[3] = z;
+        Y[3] = y;
 
-		X[4] = x;
-		Z[4] = z + 1;
-		Y[4] = y;
+        X[4] = x;
+        Z[4] = z + 1;
+        Y[4] = y;
 
-		X[5] = x;
-		Z[5] = z + 1;
-		Y[5] = y + 1;
+        X[5] = x;
+        Z[5] = z + 1;
+        Y[5] = y + 1;
 
-		X[6] = x + 1;
-		Z[6] = z + 1;
-		Y[6] = y + 1;
+        X[6] = x + 1;
+        Z[6] = z + 1;
+        Y[6] = y + 1;
 
-		X[7] = x + 1;
-		Z[7] = z + 1;
-		Y[7] = y;
+        X[7] = x + 1;
+        Z[7] = z + 1;
+        Y[7] = y;
 
-		X[8] = x + 0.5 + displacementMap[(index + 0) % dmap];
-		Z[8] = z - displacementMap[(index + 10) % dmap];
-		Y[8] = y + 0.5 + displacementMap[(index + 20) % dmap];
+        X[8] = x + 0.5 + displacementMap[(index + 0) % dmap];
+        Z[8] = z - displacementMap[(index + 10) % dmap];
+        Y[8] = y + 0.5 + displacementMap[(index + 20) % dmap];
 
-		X[9] = x - displacementMap[(index + 0 + dmap1) % dmap];
-		Z[9] = z + 0.5 + displacementMap[(index + 10 + dmap1) % dmap];
-		Y[9] = y + 0.5 + displacementMap[(index + 20 + dmap1) % dmap];
+        X[9] = x - displacementMap[(index + 0 + dmap1) % dmap];
+        Z[9] = z + 0.5 + displacementMap[(index + 10 + dmap1) % dmap];
+        Y[9] = y + 0.5 + displacementMap[(index + 20 + dmap1) % dmap];
 
-		X[10] = x + 0.5 + displacementMap[(index + 0 + dmap2) % dmap];
-		Z[10] = z + 1 + displacementMap[(index + 10 + dmap2) % dmap];
-		Y[10] = y + 0.5 + displacementMap[(index + 20 + dmap2) % dmap];
+        X[10] = x + 0.5 + displacementMap[(index + 0 + dmap2) % dmap];
+        Z[10] = z + 1 + displacementMap[(index + 10 + dmap2) % dmap];
+        Y[10] = y + 0.5 + displacementMap[(index + 20 + dmap2) % dmap];
 
-		X[11] = x + 1 + displacementMap[(index + 0 + dmap3) % dmap];
-		Z[11] = z + 0.5 + displacementMap[(index + 10 + dmap3) % dmap];
-		Y[11] = y + 0.5 + displacementMap[(index + 20 + dmap3) % dmap];
+        X[11] = x + 1 + displacementMap[(index + 0 + dmap3) % dmap];
+        Z[11] = z + 0.5 + displacementMap[(index + 10 + dmap3) % dmap];
+        Y[11] = y + 0.5 + displacementMap[(index + 20 + dmap3) % dmap];
 
-		X[12] = x + 0.5 + displacementMap[(index + 0 + dmap4) % dmap];
-		Z[12] = z + 0.5 + displacementMap[(index + 10 + dmap4) % dmap];
-		Y[12] = y + 1;// +displacementMap[(index+20+dmap4)%dmap];
+        X[12] = x + 0.5 + displacementMap[(index + 0 + dmap4) % dmap];
+        Z[12] = z + 0.5 + displacementMap[(index + 10 + dmap4) % dmap];
+        Y[12] = y + 1;// +displacementMap[(index+20+dmap4)%dmap];
 
-		X[13] = x + 0.5 + displacementMap[(index + 0 + dmap5) % dmap];
-		Z[13] = z + 0.5 + displacementMap[(index + 10 + dmap5) % dmap];
-		Y[13] = y + 0;// +displacementMap[(index+20+dmap5)%dmap];
+        X[13] = x + 0.5 + displacementMap[(index + 0 + dmap5) % dmap];
+        Z[13] = z + 0.5 + displacementMap[(index + 10 + dmap5) % dmap];
+        Y[13] = y + 0;// +displacementMap[(index+20+dmap5)%dmap];
 
-		tessellator = Tessellator.instance;
-		tessellator.setColorOpaque_F(1.0F, 1.0F, 1.0F);
+        tessellator = Tessellator.instance;
+        tessellator.setColorOpaque_F(1.0F, 1.0F, 1.0F);
 
-		return super.renderStandardBlock(block, x, y, z);
-	}
+        return super.renderStandardBlock(block, x, y, z);
+    }
 
-	void setupSides(IIcon icon, int a, int b, int c, int d, int e, int ta, int tb, int tc, int td) {
-		L[a] = brightnessBottomLeft;
-		L[b] = brightnessBottomRight;
-		L[c] = brightnessTopRight;
-		L[d] = brightnessTopLeft;
-		L[e] = (brightnessBottomLeft + brightnessTopLeft + brightnessTopRight + brightnessBottomRight) / 4;
+    void setupSides(IIcon icon, int a, int b, int c, int d, int e, int ta, int tb, int tc, int td) {
+        L[a] = brightnessBottomLeft;
+        L[b] = brightnessBottomRight;
+        L[c] = brightnessTopRight;
+        L[d] = brightnessTopLeft;
+        L[e] = (brightnessBottomLeft + brightnessTopLeft + brightnessTopRight + brightnessBottomRight) / 4;
 
-		R[a] = colorRedBottomLeft;
-		R[b] = colorRedBottomRight;
-		R[c] = colorRedTopRight;
-		R[d] = colorRedTopLeft;
-		R[e] = (colorRedBottomLeft + colorRedTopLeft + colorRedTopRight + colorRedBottomRight) / 4;
+        R[a] = colorRedBottomLeft;
+        R[b] = colorRedBottomRight;
+        R[c] = colorRedTopRight;
+        R[d] = colorRedTopLeft;
+        R[e] = (colorRedBottomLeft + colorRedTopLeft + colorRedTopRight + colorRedBottomRight) / 4;
 
-		G[a] = colorGreenBottomLeft;
-		G[b] = colorGreenBottomRight;
-		G[c] = colorGreenTopRight;
-		G[d] = colorGreenTopLeft;
-		G[e] = (colorGreenBottomLeft + colorGreenTopLeft + colorGreenTopRight + colorGreenBottomRight) / 4;
+        G[a] = colorGreenBottomLeft;
+        G[b] = colorGreenBottomRight;
+        G[c] = colorGreenTopRight;
+        G[d] = colorGreenTopLeft;
+        G[e] = (colorGreenBottomLeft + colorGreenTopLeft + colorGreenTopRight + colorGreenBottomRight) / 4;
 
-		B[a] = colorBlueBottomLeft;
-		B[b] = colorBlueBottomRight;
-		B[c] = colorBlueTopRight;
-		B[d] = colorBlueTopLeft;
-		B[e] = (colorBlueBottomLeft + colorBlueTopLeft + colorBlueTopRight + colorBlueBottomRight) / 4;
+        B[a] = colorBlueBottomLeft;
+        B[b] = colorBlueBottomRight;
+        B[c] = colorBlueTopRight;
+        B[d] = colorBlueTopLeft;
+        B[e] = (colorBlueBottomLeft + colorBlueTopLeft + colorBlueTopRight + colorBlueBottomRight) / 4;
 
-		double u0 = icon.getMaxU();
-		double u1 = icon.getMinU();
-		double v0 = icon.getMaxV();
-		double v1 = icon.getMinV();
+        double u0 = icon.getMaxU();
+        double u1 = icon.getMinU();
+        double v0 = icon.getMaxV();
+        double v1 = icon.getMinV();
 
-		U[ta] = u0;
-		U[tb] = u0;
-		U[tc] = u1;
-		U[td] = u1;
-		U[e] = icon.getInterpolatedU(8.0D);
+        U[ta] = u0;
+        U[tb] = u0;
+        U[tc] = u1;
+        U[td] = u1;
+        U[e] = icon.getInterpolatedU(8.0D);
 
-		V[ta] = v0;
-		V[tb] = v1;
-		V[tc] = v1;
-		V[td] = v0;
-		V[e] = icon.getInterpolatedV(8.0D);
-	}
+        V[ta] = v0;
+        V[tb] = v1;
+        V[tc] = v1;
+        V[td] = v0;
+        V[e] = icon.getInterpolatedV(8.0D);
+    }
 
-	void vert(int index) {
-		if (enableAO) {
-			tessellator.setColorOpaque_F(R[index], G[index], B[index]);
-			tessellator.setBrightness(L[index]);
-		}
+    void vert(int index) {
+        if (enableAO) {
+            tessellator.setColorOpaque_F(R[index], G[index], B[index]);
+            tessellator.setBrightness(L[index]);
+        }
 
-		tessellator.addVertexWithUV(X[index], Y[index], Z[index], U[index], V[index]);
-	}
+        tessellator.addVertexWithUV(X[index], Y[index], Z[index], U[index], V[index]);
+    }
 
-	@Override
-	public void renderFaceXNeg(Block block, double x, double y, double z, IIcon icon) {
-		setupSides(icon, 1, 0, 4, 5, 9, 4, 5, 1, 0);
-		vert(1);
-		vert(0);
-		vert(9);
-		vert(9);
-		vert(0);
-		vert(4);
-		vert(9);
-		vert(9);
-		vert(4);
-		vert(5);
-		vert(9);
-		vert(9);
-		vert(5);
-		vert(1);
-		vert(9);
-		vert(9);
-	}
+    @Override
+    public void renderFaceXNeg(Block block, double x, double y, double z, IIcon icon) {
+        setupSides(icon, 1, 0, 4, 5, 9, 4, 5, 1, 0);
+        vert(1);
+        vert(0);
+        vert(9);
+        vert(9);
+        vert(0);
+        vert(4);
+        vert(9);
+        vert(9);
+        vert(4);
+        vert(5);
+        vert(9);
+        vert(9);
+        vert(5);
+        vert(1);
+        vert(9);
+        vert(9);
+    }
 
-	@Override
-	public void renderFaceXPos(Block block, double x, double y, double z, IIcon icon) {
-		setupSides(icon, 3, 2, 6, 7, 11, 3, 2, 6, 7);
-		vert(6);
-		vert(7);
-		vert(11);
-		vert(11);
-		vert(7);
-		vert(3);
-		vert(11);
-		vert(11);
-		vert(3);
-		vert(2);
-		vert(11);
-		vert(11);
-		vert(2);
-		vert(6);
-		vert(11);
-		vert(11);
+    @Override
+    public void renderFaceXPos(Block block, double x, double y, double z, IIcon icon) {
+        setupSides(icon, 3, 2, 6, 7, 11, 3, 2, 6, 7);
+        vert(6);
+        vert(7);
+        vert(11);
+        vert(11);
+        vert(7);
+        vert(3);
+        vert(11);
+        vert(11);
+        vert(3);
+        vert(2);
+        vert(11);
+        vert(11);
+        vert(2);
+        vert(6);
+        vert(11);
+        vert(11);
 
-	}
+    }
 
-	@Override
-	public void renderFaceZNeg(Block block, double x, double y, double z, IIcon icon) {
-		setupSides(icon, 2, 3, 0, 1, 8, 0, 1, 2, 3);
-		vert(0);
-		vert(1);
-		vert(8);
-		vert(8);
-		vert(1);
-		vert(2);
-		vert(8);
-		vert(8);
-		vert(2);
-		vert(3);
-		vert(8);
-		vert(8);
-		vert(3);
-		vert(0);
-		vert(8);
-		vert(8);
-	}
+    @Override
+    public void renderFaceZNeg(Block block, double x, double y, double z, IIcon icon) {
+        setupSides(icon, 2, 3, 0, 1, 8, 0, 1, 2, 3);
+        vert(0);
+        vert(1);
+        vert(8);
+        vert(8);
+        vert(1);
+        vert(2);
+        vert(8);
+        vert(8);
+        vert(2);
+        vert(3);
+        vert(8);
+        vert(8);
+        vert(3);
+        vert(0);
+        vert(8);
+        vert(8);
+    }
 
-	@Override
-	public void renderFaceZPos(Block block, double x, double y, double z, IIcon icon) {
-		setupSides(icon, 4, 7, 6, 5, 10, 7, 6, 5, 4);
-		vert(5);
-		vert(4);
-		vert(10);
-		vert(10);
-		vert(6);
-		vert(5);
-		vert(10);
-		vert(10);
-		vert(7);
-		vert(6);
-		vert(10);
-		vert(10);
-		vert(4);
-		vert(7);
-		vert(10);
-		vert(10);
-	}
+    @Override
+    public void renderFaceZPos(Block block, double x, double y, double z, IIcon icon) {
+        setupSides(icon, 4, 7, 6, 5, 10, 7, 6, 5, 4);
+        vert(5);
+        vert(4);
+        vert(10);
+        vert(10);
+        vert(6);
+        vert(5);
+        vert(10);
+        vert(10);
+        vert(7);
+        vert(6);
+        vert(10);
+        vert(10);
+        vert(4);
+        vert(7);
+        vert(10);
+        vert(10);
+    }
 
-	@Override
-	public void renderFaceYNeg(Block block, double x, double y, double z, IIcon icon) {
-		setupSides(icon, 0, 3, 7, 4, 13, 0, 3, 7, 4);
-		vert(0);
-		vert(3);
-		vert(13);
-		vert(13);
-		vert(3);
-		vert(7);
-		vert(13);
-		vert(13);
-		vert(7);
-		vert(4);
-		vert(13);
-		vert(13);
-		vert(4);
-		vert(0);
-		vert(13);
-		vert(13);
-	}
+    @Override
+    public void renderFaceYNeg(Block block, double x, double y, double z, IIcon icon) {
+        setupSides(icon, 0, 3, 7, 4, 13, 0, 3, 7, 4);
+        vert(0);
+        vert(3);
+        vert(13);
+        vert(13);
+        vert(3);
+        vert(7);
+        vert(13);
+        vert(13);
+        vert(7);
+        vert(4);
+        vert(13);
+        vert(13);
+        vert(4);
+        vert(0);
+        vert(13);
+        vert(13);
+    }
 
-	@Override
-	public void renderFaceYPos(Block block, double x, double y, double z, IIcon icon) {
-		setupSides(icon, 2, 1, 5, 6, 12, 2, 1, 5, 6);
+    @Override
+    public void renderFaceYPos(Block block, double x, double y, double z, IIcon icon) {
+        setupSides(icon, 2, 1, 5, 6, 12, 2, 1, 5, 6);
 
-		vert(2);
-		vert(1);
-		vert(12);
-		vert(12);
-		vert(1);
-		vert(5);
-		vert(12);
-		vert(12);
-		vert(5);
-		vert(6);
-		vert(12);
-		vert(12);
-		vert(6);
-		vert(2);
-		vert(12);
-		vert(12);
-	}
+        vert(2);
+        vert(1);
+        vert(12);
+        vert(12);
+        vert(1);
+        vert(5);
+        vert(12);
+        vert(12);
+        vert(5);
+        vert(6);
+        vert(12);
+        vert(12);
+        vert(6);
+        vert(2);
+        vert(12);
+        vert(12);
+    }
 
 }

src/main/java/team/chisel/client/render/RenderChiselSnowman.java

@@ -1,5 +1,8 @@
 package team.chisel.client.render;
 
+import static net.minecraftforge.client.IItemRenderer.ItemRenderType.EQUIPPED;
+import static net.minecraftforge.client.IItemRenderer.ItemRendererHelper.BLOCK_3D;
+
 import net.minecraft.block.Block;
 import net.minecraft.client.model.ModelSnowMan;
 import net.minecraft.client.renderer.RenderBlocks;
@@ -15,53 +18,52 @@ import net.minecraftforge.client.MinecraftForgeClient;
 import org.lwjgl.opengl.GL11;
 
 import team.chisel.entity.EntityChiselSnowman;
-import static net.minecraftforge.client.IItemRenderer.ItemRenderType.EQUIPPED;
-import static net.minecraftforge.client.IItemRenderer.ItemRendererHelper.BLOCK_3D;
 
 public class RenderChiselSnowman extends RenderLiving {
 
-	private static final ResourceLocation snowManTextures = new ResourceLocation("textures/entity/snowman.png");
-	private ModelSnowMan snowMan;
+    private static final ResourceLocation snowManTextures = new ResourceLocation("textures/entity/snowman.png");
+    private ModelSnowMan snowMan;
 
-	public RenderChiselSnowman() {
-		super(new ModelSnowMan(), 0.5F);
-		snowMan = (ModelSnowMan) super.mainModel;
-		setRenderPassModel(this.snowMan);
-	}
+    public RenderChiselSnowman() {
+        super(new ModelSnowMan(), 0.5F);
+        snowMan = (ModelSnowMan) super.mainModel;
+        setRenderPassModel(this.snowMan);
+    }
 
-	@Override
-	protected void renderEquippedItems(EntityLivingBase entityLivingBase, float size) {
-		this.renderEquippedItems((EntityChiselSnowman) entityLivingBase, size);
-	}
+    @Override
+    protected void renderEquippedItems(EntityLivingBase entityLivingBase, float size) {
+        this.renderEquippedItems((EntityChiselSnowman) entityLivingBase, size);
+    }
 
-	@Override
-	protected ResourceLocation getEntityTexture(Entity entity) {
-		return this.getEntityTexture((EntityChiselSnowman) entity);
-	}
+    @Override
+    protected ResourceLocation getEntityTexture(Entity entity) {
+        return this.getEntityTexture((EntityChiselSnowman) entity);
+    }
 
-	protected ResourceLocation getEntityTexture(EntityChiselSnowman snowman) {
-		return snowManTextures;
-	}
+    protected ResourceLocation getEntityTexture(EntityChiselSnowman snowman) {
+        return snowManTextures;
+    }
 
-	protected void renderEquippedItems(EntityChiselSnowman snowman, float size) {
-		super.renderEquippedItems(snowman, size);
-		ItemStack itemStack = snowman.getEquipmentInSlot(2);
+    protected void renderEquippedItems(EntityChiselSnowman snowman, float size) {
+        super.renderEquippedItems(snowman, size);
+        ItemStack itemStack = snowman.getEquipmentInSlot(2);
 
-		if (itemStack.getItem() instanceof ItemBlock) {
-			GL11.glPushMatrix();
-			this.snowMan.head.postRender(0.0625F);
+        if (itemStack.getItem() instanceof ItemBlock) {
+            GL11.glPushMatrix();
+            this.snowMan.head.postRender(0.0625F);
 
-			IItemRenderer customRenderer = MinecraftForgeClient.getItemRenderer(itemStack, EQUIPPED);
-			boolean is3D = (customRenderer != null && customRenderer.shouldUseRenderHelper(EQUIPPED, itemStack, BLOCK_3D));
+            IItemRenderer customRenderer = MinecraftForgeClient.getItemRenderer(itemStack, EQUIPPED);
+            boolean is3D = (customRenderer != null
+                    && customRenderer.shouldUseRenderHelper(EQUIPPED, itemStack, BLOCK_3D));
 
-			if (is3D || RenderBlocks.renderItemIn3d(Block.getBlockFromItem(itemStack.getItem()).getRenderType())) {
-				float f1 = 0.625F;
-				GL11.glTranslatef(0.0F, -0.34375F, 0.0F);
-				GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F);
-				GL11.glScalef(f1, -f1, f1);
-			}
-			this.renderManager.itemRenderer.renderItem(snowman, itemStack, 0);
-			GL11.glPopMatrix();
-		}
-	}
+            if (is3D || RenderBlocks.renderItemIn3d(Block.getBlockFromItem(itemStack.getItem()).getRenderType())) {
+                float f1 = 0.625F;
+                GL11.glTranslatef(0.0F, -0.34375F, 0.0F);
+                GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F);
+                GL11.glScalef(f1, -f1, f1);
+            }
+            this.renderManager.itemRenderer.renderItem(snowman, itemStack, 0);
+            GL11.glPopMatrix();
+        }
+    }
 }

src/main/java/team/chisel/client/render/RendererCTM.java

@@ -3,13 +3,12 @@ package team.chisel.client.render;
 import team.chisel.ctmlib.CTMRenderer;
 
 import com.cricketcraft.chisel.api.rendering.ClientUtils;
-
 import cpw.mods.fml.client.registry.RenderingRegistry;
 
 public class RendererCTM extends CTMRenderer {
 
-	public RendererCTM() {
-		super(RenderingRegistry.getNextAvailableRenderId());
-		ClientUtils.renderCTMId = getRenderId();
-	}
+    public RendererCTM() {
+        super(RenderingRegistry.getNextAvailableRenderId());
+        ClientUtils.renderCTMId = getRenderId();
+    }
 }

src/main/java/team/chisel/client/render/RendererCTMPane.java

@@ -16,308 +16,312 @@ import cpw.mods.fml.client.registry.RenderingRegistry;
 
 public class RendererCTMPane implements ISimpleBlockRenderingHandler {
 
-	public static int id;
+    public static int id;
 
-	public RendererCTMPane() {
-		id = RenderingRegistry.getNextAvailableRenderId();
-	}
+    public RendererCTMPane() {
+        id = RenderingRegistry.getNextAvailableRenderId();
+    }
 
-	@Override
-	public void renderInventoryBlock(Block block, int meta, int modelID, RenderBlocks renderer) {
-		GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
-		GL11.glScalef(1.25f, 1.25f, 1.25f);
-		renderer.setRenderBounds(0.0f, 0.0f, 0.5f - 0.0625f, 1.0f, 1.0f, 0.5f + 0.0625f);
-		Drawing.drawBlock(block, meta, renderer);
-	}
+    @Override
+    public void renderInventoryBlock(Block block, int meta, int modelID, RenderBlocks renderer) {
+        GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
+        GL11.glScalef(1.25f, 1.25f, 1.25f);
+        renderer.setRenderBounds(0.0f, 0.0f, 0.5f - 0.0625f, 1.0f, 1.0f, 0.5f + 0.0625f);
+        Drawing.drawBlock(block, meta, renderer);
+    }
 
-	class PaneRenderer {
+    class PaneRenderer {
 
-		Tessellator tessellator;
+        Tessellator tessellator;
 
-		double i0u0;
-		double i0uh;
-		double i0u1;
-		double i0v0;
-		double i0v1;
+        double i0u0;
+        double i0uh;
+        double i0u1;
+        double i0v0;
+        double i0v1;
 
-		double i1u0;
-		double i1u1;
-		double i1v0;
-		double i1vh;
-		double i1v1;
-		double i1v;
+        double i1u0;
+        double i1u1;
+        double i1v0;
+        double i1vh;
+        double i1v1;
+        double i1v;
 
-		double i2u0;
-		double i2u1;
-		double i2v0;
-		double i2v1;
-		double i2v;
+        double i2u0;
+        double i2u1;
+        double i2v0;
+        double i2v1;
+        double i2v;
 
-		double x0;
-		double xh;
-		double x1;
-		double xp0;
-		double xp1;
+        double x0;
+        double xh;
+        double x1;
+        double xp0;
+        double xp1;
 
-		double z0;
-		double zh;
-		double z1;
-		double zp0;
-		double zp1;
+        double z0;
+        double zh;
+        double z1;
+        double zp0;
+        double zp1;
 
-		double y0;
-		double y1;
+        double y0;
+        double y1;
 
-		void set(double x, double y, double z, IIcon icon, IIcon icon1, IIcon icon2) {
-			tessellator = Tessellator.instance;
+        void set(double x, double y, double z, IIcon icon, IIcon icon1, IIcon icon2) {
+            tessellator = Tessellator.instance;
 
-			i0u0 = icon.getMinU();
-			i0uh = icon.getInterpolatedU(8.0D);
-			i0u1 = icon.getMaxU();
-			i0v0 = icon.getMinV();
-			i0v1 = icon.getMaxV();
+            i0u0 = icon.getMinU();
+            i0uh = icon.getInterpolatedU(8.0D);
+            i0u1 = icon.getMaxU();
+            i0v0 = icon.getMinV();
+            i0v1 = icon.getMaxV();
 
-			i1u0 = icon1.getInterpolatedU(7.0D);
-			i1u1 = icon1.getInterpolatedU(9.0D);
-			i1v0 = icon1.getMinV();
-			i1vh = icon1.getInterpolatedV(8.0D);
-			i1v1 = icon1.getMaxV();
-			i1v = i1v1 - i1v0;
+            i1u0 = icon1.getInterpolatedU(7.0D);
+            i1u1 = icon1.getInterpolatedU(9.0D);
+            i1v0 = icon1.getMinV();
+            i1vh = icon1.getInterpolatedV(8.0D);
+            i1v1 = icon1.getMaxV();
+            i1v = i1v1 - i1v0;
 
-			i2u0 = icon2.getInterpolatedU(7.0D);
-			i2u1 = icon2.getInterpolatedU(9.0D);
-			i2v0 = icon2.getMinV();
-			i2v1 = icon2.getMaxV();
-			i2v = i2v1 - i2v0;
+            i2u0 = icon2.getInterpolatedU(7.0D);
+            i2u1 = icon2.getInterpolatedU(9.0D);
+            i2v0 = icon2.getMinV();
+            i2v1 = icon2.getMaxV();
+            i2v = i2v1 - i2v0;
 
-			x0 = x;
-			xh = x0 + 0.5D;
-			x1 = x + 1;
-			xp0 = x0 + 0.5D - 0.0625D;
-			xp1 = x0 + 0.5D + 0.0625D;
+            x0 = x;
+            xh = x0 + 0.5D;
+            x1 = x + 1;
+            xp0 = x0 + 0.5D - 0.0625D;
+            xp1 = x0 + 0.5D + 0.0625D;
 
-			z0 = z;
-			zh = z0 + 0.5D;
-			z1 = z + 1;
-			zp0 = z0 + 0.5D - 0.0625D;
-			zp1 = z0 + 0.5D + 0.0625D;
+            z0 = z;
+            zh = z0 + 0.5D;
+            z1 = z + 1;
+            zp0 = z0 + 0.5D - 0.0625D;
+            zp1 = z0 + 0.5D + 0.0625D;
 
-			y0 = y;
-			y1 = y + 1;
-		}
+            y0 = y;
+            y1 = y + 1;
+        }
 
-		public void renderNorthPane() {
-			tessellator.addVertexWithUV(xh, y1, z0, i0uh, i0v0);
-			tessellator.addVertexWithUV(xh, y0, z0, i0uh, i0v1);
-			tessellator.addVertexWithUV(xh, y0, zh, i0u0, i0v1);
-			tessellator.addVertexWithUV(xh, y1, zh, i0u0, i0v0);
-			tessellator.addVertexWithUV(xh, y1, zh, i0u0, i0v0);
-			tessellator.addVertexWithUV(xh, y0, zh, i0u0, i0v1);
-			tessellator.addVertexWithUV(xh, y0, z0, i0uh, i0v1);
-			tessellator.addVertexWithUV(xh, y1, z0, i0uh, i0v0);
-		}
+        public void renderNorthPane() {
+            tessellator.addVertexWithUV(xh, y1, z0, i0uh, i0v0);
+            tessellator.addVertexWithUV(xh, y0, z0, i0uh, i0v1);
+            tessellator.addVertexWithUV(xh, y0, zh, i0u0, i0v1);
+            tessellator.addVertexWithUV(xh, y1, zh, i0u0, i0v0);
+            tessellator.addVertexWithUV(xh, y1, zh, i0u0, i0v0);
+            tessellator.addVertexWithUV(xh, y0, zh, i0u0, i0v1);
+            tessellator.addVertexWithUV(xh, y0, z0, i0uh, i0v1);
+            tessellator.addVertexWithUV(xh, y1, z0, i0uh, i0v0);
+        }
 
-		public void renderSouthPane() {
-			tessellator.addVertexWithUV(xh, y1, zh, i0u1, i0v0);
-			tessellator.addVertexWithUV(xh, y0, zh, i0u1, i0v1);
-			tessellator.addVertexWithUV(xh, y0, z1, i0uh, i0v1);
-			tessellator.addVertexWithUV(xh, y1, z1, i0uh, i0v0);
-			tessellator.addVertexWithUV(xh, y1, z1, i0uh, i0v0);
-			tessellator.addVertexWithUV(xh, y0, z1, i0uh, i0v1);
-			tessellator.addVertexWithUV(xh, y0, zh, i0u1, i0v1);
-			tessellator.addVertexWithUV(xh, y1, zh, i0u1, i0v0);
-		}
+        public void renderSouthPane() {
+            tessellator.addVertexWithUV(xh, y1, zh, i0u1, i0v0);
+            tessellator.addVertexWithUV(xh, y0, zh, i0u1, i0v1);
+            tessellator.addVertexWithUV(xh, y0, z1, i0uh, i0v1);
+            tessellator.addVertexWithUV(xh, y1, z1, i0uh, i0v0);
+            tessellator.addVertexWithUV(xh, y1, z1, i0uh, i0v0);
+            tessellator.addVertexWithUV(xh, y0, z1, i0uh, i0v1);
+            tessellator.addVertexWithUV(xh, y0, zh, i0u1, i0v1);
+            tessellator.addVertexWithUV(xh, y1, zh, i0u1, i0v0);
+        }
 
-		public void renderWestPane() {
-			tessellator.addVertexWithUV(x0, y1, zh, i0uh, i0v0);
-			tessellator.addVertexWithUV(x0, y0, zh, i0uh, i0v1);
-			tessellator.addVertexWithUV(xh, y0, zh, i0u0, i0v1);
-			tessellator.addVertexWithUV(xh, y1, zh, i0u0, i0v0);
-			tessellator.addVertexWithUV(xh, y1, zh, i0u0, i0v0);
-			tessellator.addVertexWithUV(xh, y0, zh, i0u0, i0v1);
-			tessellator.addVertexWithUV(x0, y0, zh, i0uh, i0v1);
-			tessellator.addVertexWithUV(x0, y1, zh, i0uh, i0v0);
-		}
+        public void renderWestPane() {
+            tessellator.addVertexWithUV(x0, y1, zh, i0uh, i0v0);
+            tessellator.addVertexWithUV(x0, y0, zh, i0uh, i0v1);
+            tessellator.addVertexWithUV(xh, y0, zh, i0u0, i0v1);
+            tessellator.addVertexWithUV(xh, y1, zh, i0u0, i0v0);
+            tessellator.addVertexWithUV(xh, y1, zh, i0u0, i0v0);
+            tessellator.addVertexWithUV(xh, y0, zh, i0u0, i0v1);
+            tessellator.addVertexWithUV(x0, y0, zh, i0uh, i0v1);
+            tessellator.addVertexWithUV(x0, y1, zh, i0uh, i0v0);
+        }
 
-		public void renderEastPane() {
-			tessellator.addVertexWithUV(xh, y1, zh, i0u1, i0v0);
-			tessellator.addVertexWithUV(xh, y0, zh, i0u1, i0v1);
-			tessellator.addVertexWithUV(x1, y0, zh, i0uh, i0v1);
-			tessellator.addVertexWithUV(x1, y1, zh, i0uh, i0v0);
-			tessellator.addVertexWithUV(x1, y1, zh, i0uh, i0v0);
-			tessellator.addVertexWithUV(x1, y0, zh, i0uh, i0v1);
-			tessellator.addVertexWithUV(xh, y0, zh, i0u1, i0v1);
-			tessellator.addVertexWithUV(xh, y1, zh, i0u1, i0v0);
-		}
+        public void renderEastPane() {
+            tessellator.addVertexWithUV(xh, y1, zh, i0u1, i0v0);
+            tessellator.addVertexWithUV(xh, y0, zh, i0u1, i0v1);
+            tessellator.addVertexWithUV(x1, y0, zh, i0uh, i0v1);
+            tessellator.addVertexWithUV(x1, y1, zh, i0uh, i0v0);
+            tessellator.addVertexWithUV(x1, y1, zh, i0uh, i0v0);
+            tessellator.addVertexWithUV(x1, y0, zh, i0uh, i0v1);
+            tessellator.addVertexWithUV(xh, y0, zh, i0u1, i0v1);
+            tessellator.addVertexWithUV(xh, y1, zh, i0u1, i0v0);
+        }
 
-		public void renderVerticalNS(double y, double zoff0, double zoff1, double v0, double v1) {
-			tessellator.addVertexWithUV(xp0, y0 + y, z0 + zoff0, i1u0, i1v0 + i1v * v0);
-			tessellator.addVertexWithUV(xp0, y0 + y, z0 + zoff1, i1u0, i1v0 + i1v * v1);
-			tessellator.addVertexWithUV(xp1, y0 + y, z0 + zoff1, i1u1, i1v0 + i1v * v1);
-			tessellator.addVertexWithUV(xp1, y0 + y, z0 + zoff0, i1u1, i1v0 + i1v * v0);
-			tessellator.addVertexWithUV(xp0, y0 + y, z0 + zoff1, i1u0, i1v0 + i1v * v1);
-			tessellator.addVertexWithUV(xp0, y0 + y, z0 + zoff0, i1u0, i1v0 + i1v * v0);
-			tessellator.addVertexWithUV(xp1, y0 + y, z0 + zoff0, i1u1, i1v0 + i1v * v0);
-			tessellator.addVertexWithUV(xp1, y0 + y, z0 + zoff1, i1u1, i1v0 + i1v * v1);
-		}
+        public void renderVerticalNS(double y, double zoff0, double zoff1, double v0, double v1) {
+            tessellator.addVertexWithUV(xp0, y0 + y, z0 + zoff0, i1u0, i1v0 + i1v * v0);
+            tessellator.addVertexWithUV(xp0, y0 + y, z0 + zoff1, i1u0, i1v0 + i1v * v1);
+            tessellator.addVertexWithUV(xp1, y0 + y, z0 + zoff1, i1u1, i1v0 + i1v * v1);
+            tessellator.addVertexWithUV(xp1, y0 + y, z0 + zoff0, i1u1, i1v0 + i1v * v0);
+            tessellator.addVertexWithUV(xp0, y0 + y, z0 + zoff1, i1u0, i1v0 + i1v * v1);
+            tessellator.addVertexWithUV(xp0, y0 + y, z0 + zoff0, i1u0, i1v0 + i1v * v0);
+            tessellator.addVertexWithUV(xp1, y0 + y, z0 + zoff0, i1u1, i1v0 + i1v * v0);
+            tessellator.addVertexWithUV(xp1, y0 + y, z0 + zoff1, i1u1, i1v0 + i1v * v1);
+        }
 
-		public void renderVerticalWE(double y, double xoff0, double xoff1, double v0, double v1) {
-			tessellator.addVertexWithUV(x0 + xoff0, y0 + y, zp1, i1u1, i1v0 + i1v * v0);
-			tessellator.addVertexWithUV(x0 + xoff1, y0 + y, zp1, i1u1, i1v0 + i1v * v1);
-			tessellator.addVertexWithUV(x0 + xoff1, y0 + y, zp0, i1u0, i1v0 + i1v * v1);
-			tessellator.addVertexWithUV(x0 + xoff0, y0 + y, zp0, i1u0, i1v0 + i1v * v0);
-			tessellator.addVertexWithUV(x0 + xoff1, y0 + y, zp1, i1u1, i1v0 + i1v * v1);
-			tessellator.addVertexWithUV(x0 + xoff0, y0 + y, zp1, i1u1, i1v0 + i1v * v0);
-			tessellator.addVertexWithUV(x0 + xoff0, y0 + y, zp0, i1u0, i1v0 + i1v * v0);
-			tessellator.addVertexWithUV(x0 + xoff1, y0 + y, zp0, i1u0, i1v0 + i1v * v1);
-		}
+        public void renderVerticalWE(double y, double xoff0, double xoff1, double v0, double v1) {
+            tessellator.addVertexWithUV(x0 + xoff0, y0 + y, zp1, i1u1, i1v0 + i1v * v0);
+            tessellator.addVertexWithUV(x0 + xoff1, y0 + y, zp1, i1u1, i1v0 + i1v * v1);
+            tessellator.addVertexWithUV(x0 + xoff1, y0 + y, zp0, i1u0, i1v0 + i1v * v1);
+            tessellator.addVertexWithUV(x0 + xoff0, y0 + y, zp0, i1u0, i1v0 + i1v * v0);
+            tessellator.addVertexWithUV(x0 + xoff1, y0 + y, zp1, i1u1, i1v0 + i1v * v1);
+            tessellator.addVertexWithUV(x0 + xoff0, y0 + y, zp1, i1u1, i1v0 + i1v * v0);
+            tessellator.addVertexWithUV(x0 + xoff0, y0 + y, zp0, i1u0, i1v0 + i1v * v0);
+            tessellator.addVertexWithUV(x0 + xoff1, y0 + y, zp0, i1u0, i1v0 + i1v * v1);
+        }
 
-		public void renderHorizontalNS(double zoff, double v0, double v1) {
-			tessellator.addVertexWithUV(xp0, y1, z0 + zoff, i2u0, i2v0 + i2v * v1);
-			tessellator.addVertexWithUV(xp0, y0, z0 + zoff, i2u0, i2v0 + i2v * v0);
-			tessellator.addVertexWithUV(xp1, y0, z0 + zoff, i2u1, i2v0 + i2v * v0);
-			tessellator.addVertexWithUV(xp1, y1, z0 + zoff, i2u1, i2v0 + i2v * v1);
-			tessellator.addVertexWithUV(xp1, y1, z0 + zoff, i2u1, i2v0 + i2v * v1);
-			tessellator.addVertexWithUV(xp1, y0, z0 + zoff, i2u1, i2v0 + i2v * v0);
-			tessellator.addVertexWithUV(xp0, y0, z0 + zoff, i2u0, i2v0 + i2v * v0);
-			tessellator.addVertexWithUV(xp0, y1, z0 + zoff, i2u0, i2v0 + i2v * v1);
+        public void renderHorizontalNS(double zoff, double v0, double v1) {
+            tessellator.addVertexWithUV(xp0, y1, z0 + zoff, i2u0, i2v0 + i2v * v1);
+            tessellator.addVertexWithUV(xp0, y0, z0 + zoff, i2u0, i2v0 + i2v * v0);
+            tessellator.addVertexWithUV(xp1, y0, z0 + zoff, i2u1, i2v0 + i2v * v0);
+            tessellator.addVertexWithUV(xp1, y1, z0 + zoff, i2u1, i2v0 + i2v * v1);
+            tessellator.addVertexWithUV(xp1, y1, z0 + zoff, i2u1, i2v0 + i2v * v1);
+            tessellator.addVertexWithUV(xp1, y0, z0 + zoff, i2u1, i2v0 + i2v * v0);
+            tessellator.addVertexWithUV(xp0, y0, z0 + zoff, i2u0, i2v0 + i2v * v0);
+            tessellator.addVertexWithUV(xp0, y1, z0 + zoff, i2u0, i2v0 + i2v * v1);
 
-		}
+        }
 
-		public void renderHorizontalWE(double xoff, double v0, double v1) {
-			tessellator.addVertexWithUV(x0 + xoff, y1, zp0, i2u0, i2v0 + i2v * v1);
-			tessellator.addVertexWithUV(x0 + xoff, y0, zp0, i2u0, i2v0 + i2v * v0);
-			tessellator.addVertexWithUV(x0 + xoff, y0, zp1, i2u1, i2v0 + i2v * v0);
-			tessellator.addVertexWithUV(x0 + xoff, y1, zp1, i2u1, i2v0 + i2v * v1);
-			tessellator.addVertexWithUV(x0 + xoff, y1, zp1, i2u1, i2v0 + i2v * v1);
-			tessellator.addVertexWithUV(x0 + xoff, y0, zp1, i2u1, i2v0 + i2v * v0);
-			tessellator.addVertexWithUV(x0 + xoff, y0, zp0, i2u0, i2v0 + i2v * v0);
-			tessellator.addVertexWithUV(x0 + xoff, y1, zp0, i2u0, i2v0 + i2v * v1);
-		}
-	}
+        public void renderHorizontalWE(double xoff, double v0, double v1) {
+            tessellator.addVertexWithUV(x0 + xoff, y1, zp0, i2u0, i2v0 + i2v * v1);
+            tessellator.addVertexWithUV(x0 + xoff, y0, zp0, i2u0, i2v0 + i2v * v0);
+            tessellator.addVertexWithUV(x0 + xoff, y0, zp1, i2u1, i2v0 + i2v * v0);
+            tessellator.addVertexWithUV(x0 + xoff, y1, zp1, i2u1, i2v0 + i2v * v1);
+            tessellator.addVertexWithUV(x0 + xoff, y1, zp1, i2u1, i2v0 + i2v * v1);
+            tessellator.addVertexWithUV(x0 + xoff, y0, zp1, i2u1, i2v0 + i2v * v0);
+            tessellator.addVertexWithUV(x0 + xoff, y0, zp0, i2u0, i2v0 + i2v * v0);
+            tessellator.addVertexWithUV(x0 + xoff, y1, zp0, i2u0, i2v0 + i2v * v1);
+        }
+    }
 
-	PaneRenderer paneRenderer = new PaneRenderer();
+    PaneRenderer paneRenderer = new PaneRenderer();
 
-	@Override
-	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block b, int modelId, RenderBlocks renderer) {
-		BlockPane block = (BlockPane) b;
-		Tessellator tessellator = Tessellator.instance;
+    @Override
+    public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block b, int modelId,
+            RenderBlocks renderer) {
+        BlockPane block = (BlockPane) b;
+        Tessellator tessellator = Tessellator.instance;
 
-		tessellator.setBrightness(block.getMixedBrightnessForBlock(world, x, y, z));
+        tessellator.setBrightness(block.getMixedBrightnessForBlock(world, x, y, z));
 
-		float f = 1.0F;
-		int i1 = block.colorMultiplier(world, x, y, z);
-		float f1 = (i1 >> 16 & 255) / 255.0F;
-		float f2 = (i1 >> 8 & 255) / 255.0F;
-		float f3 = (i1 & 255) / 255.0F;
+        float f = 1.0F;
+        int i1 = block.colorMultiplier(world, x, y, z);
+        float f1 = (i1 >> 16 & 255) / 255.0F;
+        float f2 = (i1 >> 8 & 255) / 255.0F;
+        float f3 = (i1 & 255) / 255.0F;
 
-		if (EntityRenderer.anaglyphEnable) {
-			float f4 = (f1 * 30.0F + f2 * 59.0F + f3 * 11.0F) / 100.0F;
-			float f5 = (f1 * 30.0F + f2 * 70.0F) / 100.0F;
-			float f6 = (f1 * 30.0F + f3 * 70.0F) / 100.0F;
-			f1 = f4;
-			f2 = f5;
-			f3 = f6;
-		}
-		tessellator.setColorOpaque_F(f * f1, f * f2, f * f3);
+        if (EntityRenderer.anaglyphEnable) {
+            float f4 = (f1 * 30.0F + f2 * 59.0F + f3 * 11.0F) / 100.0F;
+            float f5 = (f1 * 30.0F + f2 * 70.0F) / 100.0F;
+            float f6 = (f1 * 30.0F + f3 * 70.0F) / 100.0F;
+            f1 = f4;
+            f2 = f5;
+            f3 = f6;
+        }
+        tessellator.setColorOpaque_F(f * f1, f * f2, f * f3);
 
-		int meta = world.getBlockMetadata(x, y, z);
-		IIcon iconPane = block.getIcon(2, meta);
-		IIcon iconTop = block.getIcon(1, meta);
-		IIcon iconSide = block.getIcon(0, meta);
-		if (iconPane == null || iconTop == null || iconSide == null)
-			return false;
+        int meta = world.getBlockMetadata(x, y, z);
+        IIcon iconPane = block.getIcon(2, meta);
+        IIcon iconTop = block.getIcon(1, meta);
+        IIcon iconSide = block.getIcon(0, meta);
+        if (iconPane == null || iconTop == null || iconSide == null) return false;
 
-		if (renderer.hasOverrideBlockTexture()) {
-			paneRenderer.set(x, y, z, renderer.overrideBlockTexture, renderer.overrideBlockTexture, renderer.overrideBlockTexture);
-		} else {
-			paneRenderer.set(x, y, z, iconPane, iconTop, iconSide);
-		}
+        if (renderer.hasOverrideBlockTexture()) {
+            paneRenderer.set(
+                    x,
+                    y,
+                    z,
+                    renderer.overrideBlockTexture,
+                    renderer.overrideBlockTexture,
+                    renderer.overrideBlockTexture);
+        } else {
+            paneRenderer.set(x, y, z, iconPane, iconTop, iconSide);
+        }
 
-		boolean connectsNorth = block.canPaneConnectToBlock(world.getBlock(x, y, z - 1));
-		boolean connectsSouth = block.canPaneConnectToBlock(world.getBlock(x, y, z + 1));
-		boolean connectsWest = block.canPaneConnectToBlock(world.getBlock(x - 1, y, z));
-		boolean connectsEast = block.canPaneConnectToBlock(world.getBlock(x + 1, y, z));
-		boolean connectsTop = block.canPaneConnectToBlock(world.getBlock(x, y + 1, z));
-		boolean connectsBottom = block.canPaneConnectToBlock(world.getBlock(x, y - 1, z));
+        boolean connectsNorth = block.canPaneConnectToBlock(world.getBlock(x, y, z - 1));
+        boolean connectsSouth = block.canPaneConnectToBlock(world.getBlock(x, y, z + 1));
+        boolean connectsWest = block.canPaneConnectToBlock(world.getBlock(x - 1, y, z));
+        boolean connectsEast = block.canPaneConnectToBlock(world.getBlock(x + 1, y, z));
+        boolean connectsTop = block.canPaneConnectToBlock(world.getBlock(x, y + 1, z));
+        boolean connectsBottom = block.canPaneConnectToBlock(world.getBlock(x, y - 1, z));
 
-		boolean connectsTopNorth = block.canPaneConnectToBlock(world.getBlock(x, y + 1, z - 1));
-		boolean connectsTopSouth = block.canPaneConnectToBlock(world.getBlock(x, y + 1, z + 1));
-		boolean connectsTopWest = block.canPaneConnectToBlock(world.getBlock(x - 1, y + 1, z));
-		boolean connectsTopEast = block.canPaneConnectToBlock(world.getBlock(x + 1, y + 1, z));
+        boolean connectsTopNorth = block.canPaneConnectToBlock(world.getBlock(x, y + 1, z - 1));
+        boolean connectsTopSouth = block.canPaneConnectToBlock(world.getBlock(x, y + 1, z + 1));
+        boolean connectsTopWest = block.canPaneConnectToBlock(world.getBlock(x - 1, y + 1, z));
+        boolean connectsTopEast = block.canPaneConnectToBlock(world.getBlock(x + 1, y + 1, z));
 
-		boolean connectsBottomNorth = block.canPaneConnectToBlock(world.getBlock(x, y - 1, z - 1));
-		boolean connectsBottomSouth = block.canPaneConnectToBlock(world.getBlock(x, y - 1, z + 1));
-		boolean connectsBottomWest = block.canPaneConnectToBlock(world.getBlock(x - 1, y - 1, z));
-		boolean connectsBottomEast = block.canPaneConnectToBlock(world.getBlock(x + 1, y - 1, z));
+        boolean connectsBottomNorth = block.canPaneConnectToBlock(world.getBlock(x, y - 1, z - 1));
+        boolean connectsBottomSouth = block.canPaneConnectToBlock(world.getBlock(x, y - 1, z + 1));
+        boolean connectsBottomWest = block.canPaneConnectToBlock(world.getBlock(x - 1, y - 1, z));
+        boolean connectsBottomEast = block.canPaneConnectToBlock(world.getBlock(x + 1, y - 1, z));
 
-		boolean isolatedTop = !connectsTopNorth && !connectsTopSouth && !connectsTopWest && !connectsTopEast;
-		boolean isolatedBottom = !connectsBottomNorth && !connectsBottomSouth && !connectsBottomWest && !connectsBottomEast;
+        boolean isolatedTop = !connectsTopNorth && !connectsTopSouth && !connectsTopWest && !connectsTopEast;
+        boolean isolatedBottom = !connectsBottomNorth && !connectsBottomSouth
+                && !connectsBottomWest
+                && !connectsBottomEast;
 
-		if (!connectsNorth && !connectsSouth && !connectsWest && !connectsEast) {
-			connectsNorth = connectsSouth = connectsWest = connectsEast = true;
-		}
+        if (!connectsNorth && !connectsSouth && !connectsWest && !connectsEast) {
+            connectsNorth = connectsSouth = connectsWest = connectsEast = true;
+        }
 
-		int connections = 0;
-		if (connectsNorth) {
-			paneRenderer.renderNorthPane();
-			if (!connectsBottom || !connectsBottomNorth && !isolatedBottom)
-				paneRenderer.renderVerticalNS(-0.0003, 0.0, 0.5, 0.5, 0.0);
-			if (!connectsTop || !connectsTopNorth && !isolatedTop)
-				paneRenderer.renderVerticalNS(+1.0003, 0.0, 0.5, 0.5, 0.0);
-			connections++;
-		}
-		if (connectsSouth) {
-			paneRenderer.renderSouthPane();
-			if (!connectsBottom || !connectsBottomSouth && !isolatedBottom)
-				paneRenderer.renderVerticalNS(-0.0004, 0.5, 1.0, 1.0, 0.5);
-			if (!connectsTop || !connectsTopSouth && !isolatedTop)
-				paneRenderer.renderVerticalNS(+1.0004, 0.5, 1.0, 1.0, 0.5);
-			connections++;
-		}
-		if (connectsWest) {
-			paneRenderer.renderWestPane();
-			if (!connectsBottom || !connectsBottomWest && !isolatedBottom)
-				paneRenderer.renderVerticalWE(-0.0001, 0.0, 0.5, 0.5, 0.0);
-			if (!connectsTop || !connectsTopWest && !isolatedTop)
-				paneRenderer.renderVerticalWE(+1.0001, 0.0, 0.5, 0.5, 0.0);
-			connections++;
-		}
-		if (connectsEast) {
-			paneRenderer.renderEastPane();
-			if (!connectsBottom || !connectsBottomEast && !isolatedBottom)
-				paneRenderer.renderVerticalWE(-0.0002, 0.5, 1.0, 1.0, 0.5);
-			if (!connectsTop || !connectsTopEast && !isolatedTop)
-				paneRenderer.renderVerticalWE(+1.0002, 0.5, 1.0, 1.0, 0.5);
-			connections++;
-		}
+        int connections = 0;
+        if (connectsNorth) {
+            paneRenderer.renderNorthPane();
+            if (!connectsBottom || !connectsBottomNorth && !isolatedBottom)
+                paneRenderer.renderVerticalNS(-0.0003, 0.0, 0.5, 0.5, 0.0);
+            if (!connectsTop || !connectsTopNorth && !isolatedTop)
+                paneRenderer.renderVerticalNS(+1.0003, 0.0, 0.5, 0.5, 0.0);
+            connections++;
+        }
+        if (connectsSouth) {
+            paneRenderer.renderSouthPane();
+            if (!connectsBottom || !connectsBottomSouth && !isolatedBottom)
+                paneRenderer.renderVerticalNS(-0.0004, 0.5, 1.0, 1.0, 0.5);
+            if (!connectsTop || !connectsTopSouth && !isolatedTop)
+                paneRenderer.renderVerticalNS(+1.0004, 0.5, 1.0, 1.0, 0.5);
+            connections++;
+        }
+        if (connectsWest) {
+            paneRenderer.renderWestPane();
+            if (!connectsBottom || !connectsBottomWest && !isolatedBottom)
+                paneRenderer.renderVerticalWE(-0.0001, 0.0, 0.5, 0.5, 0.0);
+            if (!connectsTop || !connectsTopWest && !isolatedTop)
+                paneRenderer.renderVerticalWE(+1.0001, 0.0, 0.5, 0.5, 0.0);
+            connections++;
+        }
+        if (connectsEast) {
+            paneRenderer.renderEastPane();
+            if (!connectsBottom || !connectsBottomEast && !isolatedBottom)
+                paneRenderer.renderVerticalWE(-0.0002, 0.5, 1.0, 1.0, 0.5);
+            if (!connectsTop || !connectsTopEast && !isolatedTop)
+                paneRenderer.renderVerticalWE(+1.0002, 0.5, 1.0, 1.0, 0.5);
+            connections++;
+        }
 
-		if (connections == 1) {
-			if (connectsNorth)
-				paneRenderer.renderHorizontalNS(0.5, 1.0, 0.0);
-			if (connectsSouth)
-				paneRenderer.renderHorizontalNS(0.5, 0.0, 1.0);
-			if (connectsEast)
-				paneRenderer.renderHorizontalWE(0.5, 0.0, 1.0);
-			if (connectsWest)
-				paneRenderer.renderHorizontalWE(0.5, 1.0, 0.0);
-		} else if (connections == 4) {
-			paneRenderer.renderHorizontalNS(0.0, 1.0, 0.0);
-			paneRenderer.renderHorizontalNS(1.0, 0.0, 1.0);
-			paneRenderer.renderHorizontalWE(0.0, 0.0, 1.0);
-			paneRenderer.renderHorizontalWE(1.0, 1.0, 0.0);
-		}
+        if (connections == 1) {
+            if (connectsNorth) paneRenderer.renderHorizontalNS(0.5, 1.0, 0.0);
+            if (connectsSouth) paneRenderer.renderHorizontalNS(0.5, 0.0, 1.0);
+            if (connectsEast) paneRenderer.renderHorizontalWE(0.5, 0.0, 1.0);
+            if (connectsWest) paneRenderer.renderHorizontalWE(0.5, 1.0, 0.0);
+        } else if (connections == 4) {
+            paneRenderer.renderHorizontalNS(0.0, 1.0, 0.0);
+            paneRenderer.renderHorizontalNS(1.0, 0.0, 1.0);
+            paneRenderer.renderHorizontalWE(0.0, 0.0, 1.0);
+            paneRenderer.renderHorizontalWE(1.0, 1.0, 0.0);
+        }
 
-		return true;
-	}
+        return true;
+    }
 
-	@Override
-	public boolean shouldRender3DInInventory(int renderId) {
-		return false;
-	}
+    @Override
+    public boolean shouldRender3DInInventory(int renderId) {
+        return false;
+    }
 
-	@Override
-	public int getRenderId() {
-		return id;
-	}
+    @Override
+    public int getRenderId() {
+        return id;
+    }
 }

src/main/java/team/chisel/client/render/RendererEldritch.java

@@ -13,76 +13,63 @@ import cpw.mods.fml.client.registry.RenderingRegistry;
 
 public class RendererEldritch implements ISimpleBlockRenderingHandler {
 
-	public RendererEldritch() {
-		Chisel.renderEldritchId = RenderingRegistry.getNextAvailableRenderId();
-	}
+    public RendererEldritch() {
+        Chisel.renderEldritchId = RenderingRegistry.getNextAvailableRenderId();
+    }
 
-	@Override
-	public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer) {
-		GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
-		Drawing.drawBlock(block, metadata, renderer);
-		GL11.glTranslatef(0.5F, 0.5F, 0.5F);
-	}
+    @Override
+    public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer) {
+        GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
+        Drawing.drawBlock(block, metadata, renderer);
+        GL11.glTranslatef(0.5F, 0.5F, 0.5F);
+    }
 
-	RenderBlocksEldritch renderer = new RenderBlocksEldritch();
+    RenderBlocksEldritch renderer = new RenderBlocksEldritch();
 
-	@Override
-	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks rendererOld) {
+    @Override
+    public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId,
+            RenderBlocks rendererOld) {
 
-		// tessellator.setBrightness(block.getMixedBrightnessForBlock(world, x,
-		// y, z));
-		/*
-		 * double d0 = 0.4000000059604645D; double d1 = 0.5D - d0; double d2 = 0.20000000298023224D;
-		 */
-		// renderer.renderTorchAtAngle(Block.torchWood, x - d1, y + d2, z, -d0,
-		// 0.0D, 0);
-		/*
-		 * Icon icon = block.getIcon(2, meta); double u0 = icon.getMinU(); double v0 = icon.getMaxV(); double u1 = icon.getMaxU(); double v1 = icon.getMinV(); double uu = icon.getInterpolatedU(8.0D);
-		 * double vv = icon.getInterpolatedV(8.0D);
-		 * 
-		 * 
-		 * int lyp=block.getMixedBrightnessForBlock(world, x, y+1, z); int lym=block.getMixedBrightnessForBlock(world, x, y-1, z); int lxp=block.getMixedBrightnessForBlock(world, x+1, y, z); int
-		 * lxm=block.getMixedBrightnessForBlock(world, x-1, y, z); int lzp=block.getMixedBrightnessForBlock(world, x, y, z+1); int lzm=block.getMixedBrightnessForBlock(world, x, y, z-1);
-		 * 
-		 * 
-		 * 
-		 * 
-		 * 
-		 * 
-		 * 
-		 * 
-		 * 
-		 * 
-		 * 
-		 * 
-		 * icon = block.getIcon(0, meta); u0 = icon.getMinU(); v0 = icon.getMinV(); u1 = icon.getMaxU(); v1 = icon.getMaxV(); vertex(1,u0,v0); vertex(5,u1,v0); vertex(6,u1,v1); vertex(2,u0,v1);
-		 * 
-		 * icon = block.getIcon(1, meta); u0 = icon.getMinU(); v0 = icon.getMinV(); u1 = icon.getMaxU(); v1 = icon.getMaxV(); vertex(0,u0,v0); vertex(3,u0,v1); vertex(7,u1,v1); vertex(4,u1,v0);
-		 */
+        // tessellator.setBrightness(block.getMixedBrightnessForBlock(world, x,
+        // y, z));
+        /*
+         * double d0 = 0.4000000059604645D; double d1 = 0.5D - d0; double d2 = 0.20000000298023224D;
+         */
+        // renderer.renderTorchAtAngle(Block.torchWood, x - d1, y + d2, z, -d0,
+        // 0.0D, 0);
+        /*
+         * Icon icon = block.getIcon(2, meta); double u0 = icon.getMinU(); double v0 = icon.getMaxV(); double u1 =
+         * icon.getMaxU(); double v1 = icon.getMinV(); double uu = icon.getInterpolatedU(8.0D); double vv =
+         * icon.getInterpolatedV(8.0D); int lyp=block.getMixedBrightnessForBlock(world, x, y+1, z); int
+         * lym=block.getMixedBrightnessForBlock(world, x, y-1, z); int lxp=block.getMixedBrightnessForBlock(world, x+1,
+         * y, z); int lxm=block.getMixedBrightnessForBlock(world, x-1, y, z); int
+         * lzp=block.getMixedBrightnessForBlock(world, x, y, z+1); int lzm=block.getMixedBrightnessForBlock(world, x, y,
+         * z-1); icon = block.getIcon(0, meta); u0 = icon.getMinU(); v0 = icon.getMinV(); u1 = icon.getMaxU(); v1 =
+         * icon.getMaxV(); vertex(1,u0,v0); vertex(5,u1,v0); vertex(6,u1,v1); vertex(2,u0,v1); icon = block.getIcon(1,
+         * meta); u0 = icon.getMinU(); v0 = icon.getMinV(); u1 = icon.getMaxU(); v1 = icon.getMaxV(); vertex(0,u0,v0);
+         * vertex(3,u0,v1); vertex(7,u1,v1); vertex(4,u1,v0);
+         */
 
-		renderer.blockAccess = world;
-		renderer.renderMaxX = 1.0;
-		renderer.renderMaxY = 1.0;
-		renderer.renderMaxZ = 1.0;
-		renderer.renderStandardBlock(block, x, y, z);
+        renderer.blockAccess = world;
+        renderer.renderMaxX = 1.0;
+        renderer.renderMaxY = 1.0;
+        renderer.renderMaxZ = 1.0;
+        renderer.renderStandardBlock(block, x, y, z);
 
-		return true;
-		/*
-		 * 
-		 * boolean flag = renderer.renderStandardBlock(block, x, y, z);
-		 * 
-		 * return flag;
-		 */
-	}
+        return true;
+        /*
+         * boolean flag = renderer.renderStandardBlock(block, x, y, z); return flag;
+         */
+    }
 
-	@Override
-	public boolean shouldRender3DInInventory(int renderId) {
-		return true;
-	}
+    @Override
+    public boolean shouldRender3DInInventory(int renderId) {
+        return true;
+    }
 
-	@Override
-	public int getRenderId() {
-		return Chisel.renderEldritchId;
-	}
+    @Override
+    public int getRenderId() {
+        return Chisel.renderEldritchId;
+    }
 
 }

src/main/java/team/chisel/client/render/RendererLayeredGlow.java

@@ -17,38 +17,39 @@ import cpw.mods.fml.client.registry.RenderingRegistry;
 
 public class RendererLayeredGlow implements ISimpleBlockRenderingHandler {
 
-	public RendererLayeredGlow() {
-		Chisel.renderGlowId = RenderingRegistry.getNextAvailableRenderId();
-	}
+    public RendererLayeredGlow() {
+        Chisel.renderGlowId = RenderingRegistry.getNextAvailableRenderId();
+    }
 
-	@Override
-	public void renderInventoryBlock(Block block, int metadata, int modelId, RenderBlocks renderer) {
-		GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
-		GeneralClient.setGLColorFromInt(Configurations.configColors[metadata]);
-		GL11.glDisable(GL11.GL_LIGHTING);
-		Drawing.drawBlock(block, ((BlockCarvableGlow) block).getGlowTexture(), renderer);
-		GL11.glEnable(GL11.GL_LIGHTING);
-		GL11.glColor3f(1, 1, 1);
-		Drawing.drawBlock(block, metadata, renderer);
-		GL11.glTranslatef(0.5F, 0.5F, 0.5F);
-	}
+    @Override
+    public void renderInventoryBlock(Block block, int metadata, int modelId, RenderBlocks renderer) {
+        GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
+        GeneralClient.setGLColorFromInt(Configurations.configColors[metadata]);
+        GL11.glDisable(GL11.GL_LIGHTING);
+        Drawing.drawBlock(block, ((BlockCarvableGlow) block).getGlowTexture(), renderer);
+        GL11.glEnable(GL11.GL_LIGHTING);
+        GL11.glColor3f(1, 1, 1);
+        Drawing.drawBlock(block, metadata, renderer);
+        GL11.glTranslatef(0.5F, 0.5F, 0.5F);
+    }
 
-	@Override
-	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
-		Tessellator.instance.setColorOpaque_I(Configurations.configColors[world.getBlockMetadata(x, y, z)]);
-		Tessellator.instance.setBrightness(0xF000F0);
-		Drawing.renderAllFaces(renderer, block, x, y, z, ((BlockCarvableGlow) block).getGlowTexture());
-		renderer.renderStandardBlock(block, x, y, z);
-		return true;
-	}
+    @Override
+    public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId,
+            RenderBlocks renderer) {
+        Tessellator.instance.setColorOpaque_I(Configurations.configColors[world.getBlockMetadata(x, y, z)]);
+        Tessellator.instance.setBrightness(0xF000F0);
+        Drawing.renderAllFaces(renderer, block, x, y, z, ((BlockCarvableGlow) block).getGlowTexture());
+        renderer.renderStandardBlock(block, x, y, z);
+        return true;
+    }
 
-	@Override
-	public boolean shouldRender3DInInventory(int modelId) {
-		return true;
-	}
+    @Override
+    public boolean shouldRender3DInInventory(int modelId) {
+        return true;
+    }
 
-	@Override
-	public int getRenderId() {
-		return Chisel.renderGlowId;
-	}
+    @Override
+    public int getRenderId() {
+        return Chisel.renderGlowId;
+    }
 }

src/main/java/team/chisel/client/render/RendererMultiLayer.java

@@ -1,81 +1,82 @@
 package team.chisel.client.render;
 
-import team.chisel.block.BlockMultiLayerBase;
-import team.chisel.ctmlib.Drawing;
+import static org.lwjgl.opengl.GL11.*;
+
 import net.minecraft.block.Block;
 import net.minecraft.client.renderer.RenderBlocks;
 import net.minecraft.init.Blocks;
 import net.minecraft.world.IBlockAccess;
 import net.minecraftforge.client.MinecraftForgeClient;
+
+import team.chisel.block.BlockMultiLayerBase;
+import team.chisel.ctmlib.Drawing;
 import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
 import cpw.mods.fml.client.registry.RenderingRegistry;
-import static org.lwjgl.opengl.GL11.*;
 
 public class RendererMultiLayer implements ISimpleBlockRenderingHandler {
 
-	float bot = -0.001f, top = 1.0f - bot;
-	public static int id;
+    float bot = -0.001f, top = 1.0f - bot;
+    public static int id;
 
-	public RendererMultiLayer() {
-		id = RenderingRegistry.getNextAvailableRenderId();
-	}
+    public RendererMultiLayer() {
+        id = RenderingRegistry.getNextAvailableRenderId();
+    }
 
-	@Override
-	public void renderInventoryBlock(Block blck, int meta, int modelID, RenderBlocks renderer) {
-		if (blck == null || !(blck instanceof BlockMultiLayerBase))
-			return;
+    @Override
+    public void renderInventoryBlock(Block blck, int meta, int modelID, RenderBlocks renderer) {
+        if (blck == null || !(blck instanceof BlockMultiLayerBase)) return;
 
-		BlockMultiLayerBase block = (BlockMultiLayerBase) blck;
+        BlockMultiLayerBase block = (BlockMultiLayerBase) blck;
 
-		if (block.icon != null) {
-			renderer.overrideBlockTexture = block.icon;
-			renderer.renderBlockAsItem(Blocks.stone, meta, 1.0f);
-			renderer.overrideBlockTexture = null;
-		} else if (block.base != null) {
-			renderer.renderBlockAsItem(block.base, meta, 1.0f);
-		}
+        if (block.icon != null) {
+            renderer.overrideBlockTexture = block.icon;
+            renderer.renderBlockAsItem(Blocks.stone, meta, 1.0f);
+            renderer.overrideBlockTexture = null;
+        } else if (block.base != null) {
+            renderer.renderBlockAsItem(block.base, meta, 1.0f);
+        }
 
-		glPushMatrix();
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-		renderer.setRenderBounds(bot, bot, bot, top, top, top);
-		glTranslatef(-0.5F, -0.5F, -0.5F);
-		Drawing.drawBlock(block, meta, renderer);
-		glDisable(GL_BLEND);
-		glPopMatrix();
-	}
+        glPushMatrix();
+        glEnable(GL_BLEND);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        renderer.setRenderBounds(bot, bot, bot, top, top, top);
+        glTranslatef(-0.5F, -0.5F, -0.5F);
+        Drawing.drawBlock(block, meta, renderer);
+        glDisable(GL_BLEND);
+        glPopMatrix();
+    }
 
-	@Override
-	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block blck, int modelId, RenderBlocks renderer) {
-		if (blck == null || !(blck instanceof BlockMultiLayerBase))
-			return false;
-		BlockMultiLayerBase block = (BlockMultiLayerBase) blck;
+    @Override
+    public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block blck, int modelId,
+            RenderBlocks renderer) {
+        if (blck == null || !(blck instanceof BlockMultiLayerBase)) return false;
+        BlockMultiLayerBase block = (BlockMultiLayerBase) blck;
 
-		if (MinecraftForgeClient.getRenderPass() == 0) {
-			if (block.icon != null) {
-				renderer.overrideBlockTexture = block.icon;
-				renderer.renderStandardBlock(block, x, y, z);
-				renderer.overrideBlockTexture = null;
-				return true;
-			} else if (block.base != null) {
-				renderer.renderBlockByRenderType(block.base, x, y, z);
-				return true;
-			}
-		} else {
-			renderer.setRenderBounds(0, 0, 0, 1, 1, 1);
-			return renderer.renderStandardBlock(block, x, y, z);
-		}
+        if (MinecraftForgeClient.getRenderPass() == 0) {
+            if (block.icon != null) {
+                renderer.overrideBlockTexture = block.icon;
+                renderer.renderStandardBlock(block, x, y, z);
+                renderer.overrideBlockTexture = null;
+                return true;
+            } else if (block.base != null) {
+                renderer.renderBlockByRenderType(block.base, x, y, z);
+                return true;
+            }
+        } else {
+            renderer.setRenderBounds(0, 0, 0, 1, 1, 1);
+            return renderer.renderStandardBlock(block, x, y, z);
+        }
 
-		return false;
-	}
+        return false;
+    }
 
-	@Override
-	public boolean shouldRender3DInInventory(int modelId) {
-		return true;
-	}
+    @Override
+    public boolean shouldRender3DInInventory(int modelId) {
+        return true;
+    }
 
-	@Override
-	public int getRenderId() {
-		return id;
-	}
+    @Override
+    public int getRenderId() {
+        return id;
+    }
 }

src/main/java/team/chisel/client/render/RendererRoadLine.java

@@ -1,120 +1,122 @@
 package team.chisel.client.render;
 
-import team.chisel.Chisel;
-import team.chisel.block.BlockRoadLine;
-import team.chisel.ctmlib.Drawing;
 import net.minecraft.block.Block;
 import net.minecraft.client.renderer.EntityRenderer;
 import net.minecraft.client.renderer.RenderBlocks;
 import net.minecraft.client.renderer.Tessellator;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
+
+import team.chisel.Chisel;
+import team.chisel.block.BlockRoadLine;
+import team.chisel.ctmlib.Drawing;
 import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
 import cpw.mods.fml.client.registry.RenderingRegistry;
 
 public class RendererRoadLine implements ISimpleBlockRenderingHandler {
 
-	public RendererRoadLine() {
-		Chisel.roadLineId = RenderingRegistry.getNextAvailableRenderId();
-	}
+    public RendererRoadLine() {
+        Chisel.roadLineId = RenderingRegistry.getNextAvailableRenderId();
+    }
 
-	@Override
-	public void renderInventoryBlock(Block block, int meta, int modelID, RenderBlocks renderer) {
-		renderer.setRenderBoundsFromBlock(block);
-		Drawing.drawBlock(block, meta, renderer);
-	}
+    @Override
+    public void renderInventoryBlock(Block block, int meta, int modelID, RenderBlocks renderer) {
+        renderer.setRenderBoundsFromBlock(block);
+        Drawing.drawBlock(block, meta, renderer);
+    }
 
-	public void renderTopFace(double y, IIcon icon) {
-		Tessellator tessellator = Tessellator.instance;
+    public void renderTopFace(double y, IIcon icon) {
+        Tessellator tessellator = Tessellator.instance;
 
-		tessellator.addVertexWithUV(1, y, 0, icon.getMaxU(), icon.getMinV());
-		tessellator.addVertexWithUV(0, y, 0, icon.getMinU(), icon.getMinV());
-		tessellator.addVertexWithUV(0, y, 1, icon.getMinU(), icon.getMaxV());
-		tessellator.addVertexWithUV(1, y, 1, icon.getMaxU(), icon.getMaxV());
-	}
+        tessellator.addVertexWithUV(1, y, 0, icon.getMaxU(), icon.getMinV());
+        tessellator.addVertexWithUV(0, y, 0, icon.getMinU(), icon.getMinV());
+        tessellator.addVertexWithUV(0, y, 1, icon.getMinU(), icon.getMaxV());
+        tessellator.addVertexWithUV(1, y, 1, icon.getMaxU(), icon.getMaxV());
+    }
 
-	@Override
-	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block b, int modelId, RenderBlocks renderer) {
-		int meta = world.getBlockMetadata(x, y, z);
-		BlockRoadLine block = (BlockRoadLine) b;
-		Tessellator tessellator = Tessellator.instance;
+    @Override
+    public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block b, int modelId,
+            RenderBlocks renderer) {
+        int meta = world.getBlockMetadata(x, y, z);
+        BlockRoadLine block = (BlockRoadLine) b;
+        Tessellator tessellator = Tessellator.instance;
 
-		tessellator.setBrightness(block.getMixedBrightnessForBlock(world, x, y, z));
+        tessellator.setBrightness(block.getMixedBrightnessForBlock(world, x, y, z));
 
-		float f = 1.0F;
-		int i1 = block.colorMultiplier(world, x, y, z);
-		float f1 = (i1 >> 16 & 255) / 255.0F;
-		float f2 = (i1 >> 8 & 255) / 255.0F;
-		float f3 = (i1 & 255) / 255.0F;
+        float f = 1.0F;
+        int i1 = block.colorMultiplier(world, x, y, z);
+        float f1 = (i1 >> 16 & 255) / 255.0F;
+        float f2 = (i1 >> 8 & 255) / 255.0F;
+        float f3 = (i1 & 255) / 255.0F;
 
-		if (EntityRenderer.anaglyphEnable) {
-			float f4 = (f1 * 30.0F + f2 * 59.0F + f3 * 11.0F) / 100.0F;
-			float f5 = (f1 * 30.0F + f2 * 70.0F) / 100.0F;
-			float f6 = (f1 * 30.0F + f3 * 70.0F) / 100.0F;
-			f1 = f4;
-			f2 = f5;
-			f3 = f6;
-		}
-		tessellator.setColorOpaque_F(f * f1, f * f2, f * f3);
+        if (EntityRenderer.anaglyphEnable) {
+            float f4 = (f1 * 30.0F + f2 * 59.0F + f3 * 11.0F) / 100.0F;
+            float f5 = (f1 * 30.0F + f2 * 70.0F) / 100.0F;
+            float f6 = (f1 * 30.0F + f3 * 70.0F) / 100.0F;
+            f1 = f4;
+            f2 = f5;
+            f3 = f6;
+        }
+        tessellator.setColorOpaque_F(f * f1, f * f2, f * f3);
 
-		boolean N = world.getBlock(x, y, z - 1).equals(block) && world.getBlockMetadata(x, y, z - 1) == meta;
-		boolean S = world.getBlock(x, y, z + 1).equals(block) && world.getBlockMetadata(x, y, z + 1) == meta;
-		boolean W = world.getBlock(x - 1, y, z).equals(block) && world.getBlockMetadata(x - 1, y, z) == meta;
-		boolean E = world.getBlock(x + 1, y, z).equals(block) && world.getBlockMetadata(x + 1, y, z) == meta;
+        boolean N = world.getBlock(x, y, z - 1).equals(block) && world.getBlockMetadata(x, y, z - 1) == meta;
+        boolean S = world.getBlock(x, y, z + 1).equals(block) && world.getBlockMetadata(x, y, z + 1) == meta;
+        boolean W = world.getBlock(x - 1, y, z).equals(block) && world.getBlockMetadata(x - 1, y, z) == meta;
+        boolean E = world.getBlock(x + 1, y, z).equals(block) && world.getBlockMetadata(x + 1, y, z) == meta;
 
-		if (!N && !S && !W && !E) {
-			renderer.renderStandardBlock(block, x, y, z);
-			return true;
-		}
+        if (!N && !S && !W && !E) {
+            renderer.renderStandardBlock(block, x, y, z);
+            return true;
+        }
 
-		if (N && S) {
-			renderer.uvRotateTop = 0;
-			renderer.overrideBlockTexture = block.fullLineIcon[meta];
-			renderer.renderStandardBlock(block, x, y, z);
+        if (N && S) {
+            renderer.uvRotateTop = 0;
+            renderer.overrideBlockTexture = block.fullLineIcon[meta];
+            renderer.renderStandardBlock(block, x, y, z);
 
-		} else {
-			if (N) {
-				renderer.uvRotateTop = 0;
-				renderer.overrideBlockTexture = block.halfLineIcon[meta];
-				renderer.renderStandardBlock(block, x, y, z);
-			}
-			if (S) {
-				renderer.uvRotateTop = 3;
-				renderer.overrideBlockTexture = block.halfLineIcon[meta];
-				renderer.renderStandardBlock(block, x, y, z);
-			}
+        } else {
+            if (N) {
+                renderer.uvRotateTop = 0;
+                renderer.overrideBlockTexture = block.halfLineIcon[meta];
+                renderer.renderStandardBlock(block, x, y, z);
+            }
+            if (S) {
+                renderer.uvRotateTop = 3;
+                renderer.overrideBlockTexture = block.halfLineIcon[meta];
+                renderer.renderStandardBlock(block, x, y, z);
+            }
 
-		}
+        }
 
-		if (E && W) {
-			renderer.uvRotateTop = 1;
-			renderer.overrideBlockTexture = block.fullLineIcon[meta];
-			renderer.renderStandardBlock(block, x, y, z);
-		} else {
-			if (E) {
-				renderer.uvRotateTop = 1;
-				renderer.overrideBlockTexture = block.halfLineIcon[meta];
-				renderer.renderStandardBlock(block, x, y, z);
-			}
-			if (W) {
-				renderer.uvRotateTop = 2;
-				renderer.overrideBlockTexture = block.halfLineIcon[meta];
-				renderer.renderStandardBlock(block, x, y, z);
-			}
-		}
+        if (E && W) {
+            renderer.uvRotateTop = 1;
+            renderer.overrideBlockTexture = block.fullLineIcon[meta];
+            renderer.renderStandardBlock(block, x, y, z);
+        } else {
+            if (E) {
+                renderer.uvRotateTop = 1;
+                renderer.overrideBlockTexture = block.halfLineIcon[meta];
+                renderer.renderStandardBlock(block, x, y, z);
+            }
+            if (W) {
+                renderer.uvRotateTop = 2;
+                renderer.overrideBlockTexture = block.halfLineIcon[meta];
+                renderer.renderStandardBlock(block, x, y, z);
+            }
+        }
 
-		renderer.uvRotateTop = 0;
-		renderer.overrideBlockTexture = null;
-		return true;
-	}
+        renderer.uvRotateTop = 0;
+        renderer.overrideBlockTexture = null;
+        return true;
+    }
 
-	@Override
-	public boolean shouldRender3DInInventory(int renderId) {
-		return false;
-	}
+    @Override
+    public boolean shouldRender3DInInventory(int renderId) {
+        return false;
+    }
 
-	@Override
-	public int getRenderId() {
-		return Chisel.roadLineId;
-	}
+    @Override
+    public int getRenderId() {
+        return Chisel.roadLineId;
+    }
 }

src/main/java/team/chisel/client/render/RendererSimpleLayered.java

@@ -14,36 +14,37 @@ import cpw.mods.fml.client.registry.RenderingRegistry;
 
 public class RendererSimpleLayered implements ISimpleBlockRenderingHandler {
 
-	public RendererSimpleLayered() {
-		Chisel.renderLayeredId = RenderingRegistry.getNextAvailableRenderId();
-	}
+    public RendererSimpleLayered() {
+        Chisel.renderLayeredId = RenderingRegistry.getNextAvailableRenderId();
+    }
 
-	@Override
-	public void renderInventoryBlock(Block block, int metadata, int modelId, RenderBlocks renderer) {
-		GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
-		GL11.glDisable(GL11.GL_LIGHTING);
-		Drawing.drawBlock(block, ((BlockCarvableLayered) block).getBaseTex(), renderer);
-		GL11.glEnable(GL11.GL_LIGHTING);
-		Drawing.drawBlock(block, metadata, renderer);
-		GL11.glTranslatef(0.5F, 0.5F, 0.5F);
-	}
+    @Override
+    public void renderInventoryBlock(Block block, int metadata, int modelId, RenderBlocks renderer) {
+        GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
+        GL11.glDisable(GL11.GL_LIGHTING);
+        Drawing.drawBlock(block, ((BlockCarvableLayered) block).getBaseTex(), renderer);
+        GL11.glEnable(GL11.GL_LIGHTING);
+        Drawing.drawBlock(block, metadata, renderer);
+        GL11.glTranslatef(0.5F, 0.5F, 0.5F);
+    }
 
-	@Override
-	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
-		renderer.setOverrideBlockTexture(((BlockCarvableLayered) block).getBaseTex());
-		renderer.renderStandardBlock(block, x, y, z);
-		renderer.clearOverrideBlockTexture();
-		renderer.renderStandardBlock(block, x, y, z);
-		return true;
-	}
+    @Override
+    public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId,
+            RenderBlocks renderer) {
+        renderer.setOverrideBlockTexture(((BlockCarvableLayered) block).getBaseTex());
+        renderer.renderStandardBlock(block, x, y, z);
+        renderer.clearOverrideBlockTexture();
+        renderer.renderStandardBlock(block, x, y, z);
+        return true;
+    }
 
-	@Override
-	public boolean shouldRender3DInInventory(int modelId) {
-		return true;
-	}
+    @Override
+    public boolean shouldRender3DInInventory(int modelId) {
+        return true;
+    }
 
-	@Override
-	public int getRenderId() {
-		return Chisel.renderLayeredId;
-	}
+    @Override
+    public int getRenderId() {
+        return Chisel.renderLayeredId;
+    }
 }

src/main/java/team/chisel/client/render/RendererSnakeStone.java

@@ -13,113 +13,114 @@ import cpw.mods.fml.client.registry.RenderingRegistry;
 
 public class RendererSnakeStone implements ISimpleBlockRenderingHandler {
 
-	public static int id;
+    public static int id;
 
-	public RendererSnakeStone() {
-		id = RenderingRegistry.getNextAvailableRenderId();
-	}
+    public RendererSnakeStone() {
+        id = RenderingRegistry.getNextAvailableRenderId();
+    }
 
-	@Override
-	public void renderInventoryBlock(Block block, int meta, int modelID, RenderBlocks renderer) {
-		setRenderRotate(renderer, (BlockSnakestone) block, meta);
-		GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
-		Drawing.drawBlock(block, meta, renderer);
-		GL11.glTranslatef(0.5F, 0.5F, 0.5F);
-		restoreRendererRotate(renderer);
-	}
+    @Override
+    public void renderInventoryBlock(Block block, int meta, int modelID, RenderBlocks renderer) {
+        setRenderRotate(renderer, (BlockSnakestone) block, meta);
+        GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
+        Drawing.drawBlock(block, meta, renderer);
+        GL11.glTranslatef(0.5F, 0.5F, 0.5F);
+        restoreRendererRotate(renderer);
+    }
 
-	@Override
-	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
-		int meta = world.getBlockMetadata(x, y, z);
+    @Override
+    public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId,
+            RenderBlocks renderer) {
+        int meta = world.getBlockMetadata(x, y, z);
 
-		setRenderRotate(renderer, (BlockSnakestone) block, meta);
-		boolean didRender = renderer.renderStandardBlock(block, x, y, z);
-		restoreRendererRotate(renderer);
+        setRenderRotate(renderer, (BlockSnakestone) block, meta);
+        boolean didRender = renderer.renderStandardBlock(block, x, y, z);
+        restoreRendererRotate(renderer);
 
-		return didRender;
-	}
+        return didRender;
+    }
 
-	private void restoreRendererRotate(RenderBlocks renderer) {
-		renderer.uvRotateSouth = 0;
-		renderer.uvRotateEast = 0;
-		renderer.uvRotateWest = 0;
-		renderer.uvRotateNorth = 0;
-		renderer.uvRotateTop = 0;
-		renderer.uvRotateBottom = 0;
-	}
+    private void restoreRendererRotate(RenderBlocks renderer) {
+        renderer.uvRotateSouth = 0;
+        renderer.uvRotateEast = 0;
+        renderer.uvRotateWest = 0;
+        renderer.uvRotateNorth = 0;
+        renderer.uvRotateTop = 0;
+        renderer.uvRotateBottom = 0;
+    }
 
-	private void setRenderRotate(RenderBlocks renderer, BlockSnakestone block, int meta) {
-		int type = meta & 0xC;
-		int orient = meta & 0x3;
+    private void setRenderRotate(RenderBlocks renderer, BlockSnakestone block, int meta) {
+        int type = meta & 0xC;
+        int orient = meta & 0x3;
 
-		if (type == 0) {
-			switch (orient) {
-			case 0:
-				renderer.uvRotateTop = 1;
-				renderer.uvRotateBottom = 2;
-				break;
-			case 1:
-				renderer.uvRotateTop = 1;
-				renderer.uvRotateBottom = 1;
-				break;
-			case 2:
-				renderer.uvRotateTop = 0;
-				renderer.uvRotateBottom = 3;
-				break;
-			case 3:
-				renderer.uvRotateTop = 0;
-				renderer.uvRotateBottom = 0;
-			}
+        if (type == 0) {
+            switch (orient) {
+                case 0:
+                    renderer.uvRotateTop = 1;
+                    renderer.uvRotateBottom = 2;
+                    break;
+                case 1:
+                    renderer.uvRotateTop = 1;
+                    renderer.uvRotateBottom = 1;
+                    break;
+                case 2:
+                    renderer.uvRotateTop = 0;
+                    renderer.uvRotateBottom = 3;
+                    break;
+                case 3:
+                    renderer.uvRotateTop = 0;
+                    renderer.uvRotateBottom = 0;
+            }
 
-		} else if ((type == 4) || (type == 8)) {
-			switch (orient) {
-			case 0:
-				renderer.uvRotateTop = block.flipTopTextures ? 1 : 2;
-				renderer.uvRotateBottom = 1;
-				renderer.uvRotateWest = 2;
-				break;
-			case 1:
-				renderer.uvRotateTop = 1;
-				renderer.uvRotateBottom = 1;
-				renderer.uvRotateEast = 2;
-				break;
-			case 2:
-				renderer.uvRotateTop = block.flipTopTextures ? 0 : 3;
-				renderer.uvRotateBottom = 0;
-				renderer.uvRotateSouth = 2;
-				break;
-			case 3:
-				renderer.uvRotateTop = 0;
-				renderer.uvRotateBottom = 0;
-				renderer.uvRotateNorth = 2;
-			}
+        } else if ((type == 4) || (type == 8)) {
+            switch (orient) {
+                case 0:
+                    renderer.uvRotateTop = block.flipTopTextures ? 1 : 2;
+                    renderer.uvRotateBottom = 1;
+                    renderer.uvRotateWest = 2;
+                    break;
+                case 1:
+                    renderer.uvRotateTop = 1;
+                    renderer.uvRotateBottom = 1;
+                    renderer.uvRotateEast = 2;
+                    break;
+                case 2:
+                    renderer.uvRotateTop = block.flipTopTextures ? 0 : 3;
+                    renderer.uvRotateBottom = 0;
+                    renderer.uvRotateSouth = 2;
+                    break;
+                case 3:
+                    renderer.uvRotateTop = 0;
+                    renderer.uvRotateBottom = 0;
+                    renderer.uvRotateNorth = 2;
+            }
 
-		} else if (type == 12) {
-			switch (orient) {
-			case 0:
-				renderer.uvRotateTop = 0;
-				renderer.uvRotateBottom = 0;
-				break;
-			case 1:
-				renderer.uvRotateTop = 1;
-				renderer.uvRotateBottom = 1;
-				break;
-			case 2:
-				renderer.uvRotateNorth = 2;
-				renderer.uvRotateSouth = 2;
-				renderer.uvRotateEast = 2;
-				renderer.uvRotateWest = 2;
-			}
-		}
-	}
+        } else if (type == 12) {
+            switch (orient) {
+                case 0:
+                    renderer.uvRotateTop = 0;
+                    renderer.uvRotateBottom = 0;
+                    break;
+                case 1:
+                    renderer.uvRotateTop = 1;
+                    renderer.uvRotateBottom = 1;
+                    break;
+                case 2:
+                    renderer.uvRotateNorth = 2;
+                    renderer.uvRotateSouth = 2;
+                    renderer.uvRotateEast = 2;
+                    renderer.uvRotateWest = 2;
+            }
+        }
+    }
 
-	@Override
-	public boolean shouldRender3DInInventory(int renderId) {
-		return true;
-	}
+    @Override
+    public boolean shouldRender3DInInventory(int renderId) {
+        return true;
+    }
 
-	@Override
-	public int getRenderId() {
-		return id;
-	}
-}
+    @Override
+    public int getRenderId() {
+        return id;
+    }
+}

src/main/java/team/chisel/client/render/RendererStairs.java

@@ -13,44 +13,44 @@ import cpw.mods.fml.client.registry.RenderingRegistry;
 
 public class RendererStairs implements ISimpleBlockRenderingHandler {
 
-	public static int id;
+    public static int id;
 
-	public RendererStairs() {
-		id = RenderingRegistry.getNextAvailableRenderId();
-	}
+    public RendererStairs() {
+        id = RenderingRegistry.getNextAvailableRenderId();
+    }
 
-	@Override
-	public void renderInventoryBlock(Block block, int meta, int modelID, RenderBlocks renderer) {
-		GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
-		renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 0.5F);
-		Drawing.drawBlock(block, meta, renderer);
-		renderer.setRenderBounds(0.0F, 0.0F, 0.5F, 1.0F, 0.5F, 1.0F);
-		Drawing.drawBlock(block, meta, renderer);
-	}
+    @Override
+    public void renderInventoryBlock(Block block, int meta, int modelID, RenderBlocks renderer) {
+        GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
+        renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 0.5F);
+        Drawing.drawBlock(block, meta, renderer);
+        renderer.setRenderBounds(0.0F, 0.0F, 0.5F, 1.0F, 0.5F, 1.0F);
+        Drawing.drawBlock(block, meta, renderer);
+    }
 
-	@Override
-	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block blck, int modelId, RenderBlocks renderer) {
-		if (blck == null || !(blck instanceof BlockCarvableStairs))
-			return false;
-		BlockCarvableStairs block = (BlockCarvableStairs) blck;
+    @Override
+    public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block blck, int modelId,
+            RenderBlocks renderer) {
+        if (blck == null || !(blck instanceof BlockCarvableStairs)) return false;
+        BlockCarvableStairs block = (BlockCarvableStairs) blck;
 
-		renderer.renderBlockStairs(block, x, y, z);
+        renderer.renderBlockStairs(block, x, y, z);
 
-		return true;
-	}
+        return true;
+    }
 
-	@Override
-	public boolean shouldRender3DInInventory(int renderId) {
-		return true;
-	}
+    @Override
+    public boolean shouldRender3DInInventory(int renderId) {
+        return true;
+    }
 
-	@Override
-	public int getRenderId() {
-		return id;
-	}
+    @Override
+    public int getRenderId() {
+        return id;
+    }
 
-	public int getRenderBlockPass() {
-		return 1;
-	}
+    public int getRenderBlockPass() {
+        return 1;
+    }
 
 }

src/main/java/team/chisel/client/render/SubmapManagerAntiblock.java

@@ -1,11 +1,5 @@
 package team.chisel.client.render;
 
-import org.lwjgl.opengl.GL11;
-
-import team.chisel.ctmlib.Drawing;
-import team.chisel.ctmlib.RenderBlocksCTM;
-import team.chisel.ctmlib.TextureSubmap;
-import team.chisel.init.ChiselBlocks;
 import net.minecraft.block.Block;
 import net.minecraft.client.renderer.RenderBlocks;
 import net.minecraft.client.renderer.texture.IIconRegister;
@@ -13,94 +7,104 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
 import net.minecraftforge.client.IItemRenderer;
+
+import org.lwjgl.opengl.GL11;
+
+import team.chisel.ctmlib.Drawing;
+import team.chisel.ctmlib.RenderBlocksCTM;
+import team.chisel.ctmlib.TextureSubmap;
+import team.chisel.init.ChiselBlocks;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class SubmapManagerAntiblock extends SubmapManagerBase {
-	
-	@SideOnly(Side.CLIENT)
-	public static class AntiblockItemRenderer implements IItemRenderer {
 
-		@Override
-		public boolean handleRenderType(ItemStack item, ItemRenderType type) {
-			return true;
-		}
+    @SideOnly(Side.CLIENT)
+    public static class AntiblockItemRenderer implements IItemRenderer {
 
-		@Override
-		public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) {
-			return true;
-		}
+        @Override
+        public boolean handleRenderType(ItemStack item, ItemRenderType type) {
+            return true;
+        }
 
-		@Override
-		public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
-			GL11.glDisable(GL11.GL_LIGHTING);
-			Drawing.drawBlock(ChiselBlocks.antiBlock, ChiselBlocks.antiBlock.getIcon(0, item.getItemDamage()), (RenderBlocks) data[0]);
-			GL11.glEnable(GL11.GL_LIGHTING);
-		}
-	}
+        @Override
+        public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) {
+            return true;
+        }
 
-	@SideOnly(Side.CLIENT)
-	private static class RenderBlocksCTMFullbright extends RenderBlocksCTM {
+        @Override
+        public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
+            GL11.glDisable(GL11.GL_LIGHTING);
+            Drawing.drawBlock(
+                    ChiselBlocks.antiBlock,
+                    ChiselBlocks.antiBlock.getIcon(0, item.getItemDamage()),
+                    (RenderBlocks) data[0]);
+            GL11.glEnable(GL11.GL_LIGHTING);
+        }
+    }
 
-		@Override
-		protected void fillLightmap(int bottomLeft, int bottomRight, int topRight, int topLeft) {
-			ao();
-			int maxLight = 0xF000F0;
-			super.fillLightmap(maxLight, maxLight, maxLight, maxLight);
-		}
+    @SideOnly(Side.CLIENT)
+    private static class RenderBlocksCTMFullbright extends RenderBlocksCTM {
 
-		@Override
-		protected void fillColormap(float bottomLeft, float bottomRight, float topRight, float topLeft, float[][] map) {
-			ao();
-			int color = 0xFFFFFF;
-			super.fillColormap(color, color, color, color, map);
-		}
-		
-		@Override
-		public boolean renderStandardBlock(Block block, int x, int y, int z) {
-			boolean ret = super.renderStandardBlock(block, x, y, z);
-			this.enableAO = false;
-			return ret;
-		}
-		
-		private void ao() {
-			if (this.inWorld) {
-				this.enableAO = true;
-			}
-		}
-	};
+        @Override
+        protected void fillLightmap(int bottomLeft, int bottomRight, int topRight, int topLeft) {
+            ao();
+            int maxLight = 0xF000F0;
+            super.fillLightmap(maxLight, maxLight, maxLight, maxLight);
+        }
 
-	@SideOnly(Side.CLIENT)
-	private static RenderBlocksCTMFullbright rb;
+        @Override
+        protected void fillColormap(float bottomLeft, float bottomRight, float topRight, float topLeft, float[][] map) {
+            ao();
+            int color = 0xFFFFFF;
+            super.fillColormap(color, color, color, color, map);
+        }
 
-	private String color;
-	private TextureSubmap submap, submapSmall;
+        @Override
+        public boolean renderStandardBlock(Block block, int x, int y, int z) {
+            boolean ret = super.renderStandardBlock(block, x, y, z);
+            this.enableAO = false;
+            return ret;
+        }
 
-	public SubmapManagerAntiblock(String color) {
-		this.color = color;
-	}
+        private void ao() {
+            if (this.inWorld) {
+                this.enableAO = true;
+            }
+        }
+    };
 
-	@Override
-	public IIcon getIcon(int side, int meta) {
-		return submapSmall.getBaseIcon();
-	}
+    @SideOnly(Side.CLIENT)
+    private static RenderBlocksCTMFullbright rb;
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public void registerIcons(String modName, Block block, IIconRegister register) {
-		submap = new TextureSubmap(register.registerIcon(modName + ":antiblock/" + color + "-antiBlock-ctm"), 4, 4);
-		submapSmall = new TextureSubmap(register.registerIcon(modName + ":antiblock/" + color + "-antiBlock"), 2, 2);
-	}
+    private String color;
+    private TextureSubmap submap, submapSmall;
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public RenderBlocks createRenderContext(RenderBlocks rendererOld, Block block, IBlockAccess world) {
-		if (rb == null) {
-			rb = new RenderBlocksCTMFullbright();
-		}
-		rb.setRenderBoundsFromBlock(block);
-		rb.submap = submap;
-		rb.submapSmall = submapSmall;
-		return rb;
-	}
+    public SubmapManagerAntiblock(String color) {
+        this.color = color;
+    }
+
+    @Override
+    public IIcon getIcon(int side, int meta) {
+        return submapSmall.getBaseIcon();
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(String modName, Block block, IIconRegister register) {
+        submap = new TextureSubmap(register.registerIcon(modName + ":antiblock/" + color + "-antiBlock-ctm"), 4, 4);
+        submapSmall = new TextureSubmap(register.registerIcon(modName + ":antiblock/" + color + "-antiBlock"), 2, 2);
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public RenderBlocks createRenderContext(RenderBlocks rendererOld, Block block, IBlockAccess world) {
+        if (rb == null) {
+            rb = new RenderBlocksCTMFullbright();
+        }
+        rb.setRenderBoundsFromBlock(block);
+        rb.submap = submap;
+        rb.submapSmall = submapSmall;
+        return rb;
+    }
 }

src/main/java/team/chisel/client/render/SubmapManagerBase.java

@@ -1,34 +1,33 @@
 package team.chisel.client.render;
 
-import team.chisel.ctmlib.ISubmapManager;
 import net.minecraft.block.Block;
 import net.minecraft.client.renderer.RenderBlocks;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
 import net.minecraftforge.common.util.ForgeDirection;
+
+import team.chisel.ctmlib.ISubmapManager;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public abstract class SubmapManagerBase implements ISubmapManager {
 
-	@Override
-	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
-		return getIcon(side, world.getBlockMetadata(x, y, z));
-	}
+    @Override
+    public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+        return getIcon(side, world.getBlockMetadata(x, y, z));
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public RenderBlocks createRenderContext(RenderBlocks rendererOld, Block block, IBlockAccess world) {
-		return null;
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public RenderBlocks createRenderContext(RenderBlocks rendererOld, Block block, IBlockAccess world) {
+        return null;
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public void preRenderSide(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, ForgeDirection side) {
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void preRenderSide(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, ForgeDirection side) {}
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public void postRenderSide(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, ForgeDirection side) {
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void postRenderSide(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, ForgeDirection side) {}
 }

src/main/java/team/chisel/client/render/SubmapManagerCarpetFloor.java

@@ -1,55 +1,56 @@
 package team.chisel.client.render;
 
-import team.chisel.ctmlib.RenderBlocksCTM;
-import team.chisel.ctmlib.TextureSubmap;
 import net.minecraft.block.Block;
 import net.minecraft.client.renderer.RenderBlocks;
 import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
+
+import team.chisel.ctmlib.RenderBlocksCTM;
+import team.chisel.ctmlib.TextureSubmap;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class SubmapManagerCarpetFloor extends SubmapManagerBase {
 
-	@SideOnly(Side.CLIENT)
-	private static RenderBlocksCTM rb;
+    @SideOnly(Side.CLIENT)
+    private static RenderBlocksCTM rb;
 
-	private TextureSubmap submap;
-	private TextureSubmap submapSmall;
-	private String color;
+    private TextureSubmap submap;
+    private TextureSubmap submapSmall;
+    private String color;
 
-	public SubmapManagerCarpetFloor(String color) {
-		this.color = color;
-	}
+    public SubmapManagerCarpetFloor(String color) {
+        this.color = color;
+    }
 
-	@Override
-	public IIcon getIcon(int side, int meta) {
-		return submapSmall.getBaseIcon();
-	}
+    @Override
+    public IIcon getIcon(int side, int meta) {
+        return submapSmall.getBaseIcon();
+    }
 
-	@Override
-	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
-		return getIcon(side, world.getBlockMetadata(x, y, z));
-	}
+    @Override
+    public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+        return getIcon(side, world.getBlockMetadata(x, y, z));
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public void registerIcons(String modName, Block block, IIconRegister register) {
-		String path = modName + ":carpet/" + color;
-		submap = new TextureSubmap(register.registerIcon(path + "-ctm"), 4, 4);
-		submapSmall = new TextureSubmap(register.registerIcon(path), 2, 2);
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(String modName, Block block, IIconRegister register) {
+        String path = modName + ":carpet/" + color;
+        submap = new TextureSubmap(register.registerIcon(path + "-ctm"), 4, 4);
+        submapSmall = new TextureSubmap(register.registerIcon(path), 2, 2);
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public RenderBlocks createRenderContext(RenderBlocks rendererOld, Block block, IBlockAccess world) {
-		if (rb == null) {
-			rb = new RenderBlocksCTM();
-		}
-		rb.setRenderBoundsFromBlock(block);
-		rb.submap = submap;
-		rb.submapSmall = submapSmall;
-		return rb;
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public RenderBlocks createRenderContext(RenderBlocks rendererOld, Block block, IBlockAccess world) {
+        if (rb == null) {
+            rb = new RenderBlocksCTM();
+        }
+        rb.setRenderBoundsFromBlock(block);
+        rb.submap = submap;
+        rb.submapSmall = submapSmall;
+        return rb;
+    }
 }

src/main/java/team/chisel/client/render/SubmapManagerCombinedCTM.java

@@ -22,133 +22,141 @@ import cpw.mods.fml.relauncher.SideOnly;
 
 public class SubmapManagerCombinedCTM extends SubmapManagerBase {
 
-	@SideOnly(Side.CLIENT)
-	private class RenderBlocksCombinedCTM extends RenderBlocksCTM {
+    @SideOnly(Side.CLIENT)
+    private class RenderBlocksCombinedCTM extends RenderBlocksCTM {
 
-		@Override
-		public void renderFaceXNeg(Block block, double x, double y, double z, IIcon icon) {
-			setIcons(rType, x, y, z, ForgeDirection.WEST);
-			super.renderFaceXNeg(block, x, y, z, inWorld ? submapSmall.getSubIcon(0, 0) : icon);
-		}
+        @Override
+        public void renderFaceXNeg(Block block, double x, double y, double z, IIcon icon) {
+            setIcons(rType, x, y, z, ForgeDirection.WEST);
+            super.renderFaceXNeg(block, x, y, z, inWorld ? submapSmall.getSubIcon(0, 0) : icon);
+        }
 
-		@Override
-		public void renderFaceXPos(Block block, double x, double y, double z, IIcon icon) {
-			setIcons(rType, x, y, z, ForgeDirection.EAST);
-			super.renderFaceXPos(block, x, y, z, inWorld ? submapSmall.getSubIcon(0, 0) : icon);
-		}
+        @Override
+        public void renderFaceXPos(Block block, double x, double y, double z, IIcon icon) {
+            setIcons(rType, x, y, z, ForgeDirection.EAST);
+            super.renderFaceXPos(block, x, y, z, inWorld ? submapSmall.getSubIcon(0, 0) : icon);
+        }
 
-		@Override
-		public void renderFaceYNeg(Block block, double x, double y, double z, IIcon icon) {
-			setIcons(rType, x, y, z, ForgeDirection.DOWN);
-			super.renderFaceYNeg(block, x, y, z, inWorld ? submapSmall.getSubIcon(0, 0) : icon);
-		}
+        @Override
+        public void renderFaceYNeg(Block block, double x, double y, double z, IIcon icon) {
+            setIcons(rType, x, y, z, ForgeDirection.DOWN);
+            super.renderFaceYNeg(block, x, y, z, inWorld ? submapSmall.getSubIcon(0, 0) : icon);
+        }
 
-		@Override
-		public void renderFaceYPos(Block block, double x, double y, double z, IIcon icon) {
-			setIcons(rType, x, y, z, ForgeDirection.UP);
-			super.renderFaceYPos(block, x, y, z, inWorld ? submapSmall.getSubIcon(0, 0) : icon);
-		}
+        @Override
+        public void renderFaceYPos(Block block, double x, double y, double z, IIcon icon) {
+            setIcons(rType, x, y, z, ForgeDirection.UP);
+            super.renderFaceYPos(block, x, y, z, inWorld ? submapSmall.getSubIcon(0, 0) : icon);
+        }
 
-		@Override
-		public void renderFaceZNeg(Block block, double x, double y, double z, IIcon icon) {
-			setIcons(rType, x, y, z, ForgeDirection.NORTH);
-			super.renderFaceZNeg(block, x, y, z, inWorld ? submapSmall.getSubIcon(0, 0) : icon);
-		}
+        @Override
+        public void renderFaceZNeg(Block block, double x, double y, double z, IIcon icon) {
+            setIcons(rType, x, y, z, ForgeDirection.NORTH);
+            super.renderFaceZNeg(block, x, y, z, inWorld ? submapSmall.getSubIcon(0, 0) : icon);
+        }
 
-		@Override
-		public void renderFaceZPos(Block block, double x, double y, double z, IIcon icon) {
-			setIcons(rType, x, y, z, ForgeDirection.SOUTH);
-			super.renderFaceZPos(block, x, y, z, inWorld ? submapSmall.getSubIcon(0, 0) : icon);
-		}
+        @Override
+        public void renderFaceZPos(Block block, double x, double y, double z, IIcon icon) {
+            setIcons(rType, x, y, z, ForgeDirection.SOUTH);
+            super.renderFaceZPos(block, x, y, z, inWorld ? submapSmall.getSubIcon(0, 0) : icon);
+        }
 
-		private void setIcons(TextureType type, double x, double y, double z, ForgeDirection side) {
-			int ix = MathHelper.floor_double(x);
-			int iy = MathHelper.floor_double(y);
-			int iz = MathHelper.floor_double(z);
-			if (type == TextureType.V4 || type == TextureType.V9) {
-				submap = (TextureSubmap) TextureType.getVIcon(rType, SubmapManagerCombinedCTM.this.submap, ix, iy, iz, side.ordinal());
-				submapSmall = (TextureSubmap) TextureType.getVIcon(rType, SubmapManagerCombinedCTM.this.smallSubmap, ix, iy, iz, side.ordinal());
-			} else {
-				submap = (TextureSubmap) TextureType.getRIcon(rType, SubmapManagerCombinedCTM.this.submap, ix, iy, iz, side.ordinal());
-				submapSmall = (TextureSubmap) TextureType.getRIcon(rType, SubmapManagerCombinedCTM.this.smallSubmap, ix, iy, iz, side.ordinal());
-			}
-		}
-	}
+        private void setIcons(TextureType type, double x, double y, double z, ForgeDirection side) {
+            int ix = MathHelper.floor_double(x);
+            int iy = MathHelper.floor_double(y);
+            int iz = MathHelper.floor_double(z);
+            if (type == TextureType.V4 || type == TextureType.V9) {
+                submap = (TextureSubmap) TextureType
+                        .getVIcon(rType, SubmapManagerCombinedCTM.this.submap, ix, iy, iz, side.ordinal());
+                submapSmall = (TextureSubmap) TextureType
+                        .getVIcon(rType, SubmapManagerCombinedCTM.this.smallSubmap, ix, iy, iz, side.ordinal());
+            } else {
+                submap = (TextureSubmap) TextureType
+                        .getRIcon(rType, SubmapManagerCombinedCTM.this.submap, ix, iy, iz, side.ordinal());
+                submapSmall = (TextureSubmap) TextureType
+                        .getRIcon(rType, SubmapManagerCombinedCTM.this.smallSubmap, ix, iy, iz, side.ordinal());
+            }
+        }
+    }
 
-	private class Submap extends TextureSubmap {
+    private class Submap extends TextureSubmap {
 
-		private TextureSubmap[][] submap;
+        private TextureSubmap[][] submap;
 
-		public Submap(IIcon base, int wh, TextureSubmap[][] submap) {
-			super(base, wh, wh);
-			this.submap = submap;
-		}
+        public Submap(IIcon base, int wh, TextureSubmap[][] submap) {
+            super(base, wh, wh);
+            this.submap = submap;
+        }
 
-		@Override
-		public void texturesStitched() {
-			for (int i = 0; i < icons.length; i++) {
-				for (int j = 0; j < icons[i].length; j++) {
-					icons[i][j] = submap[i][j];
-					submap[i][j].texturesStitched();
-				}
-			}
-		}
-	}
+        @Override
+        public void texturesStitched() {
+            for (int i = 0; i < icons.length; i++) {
+                for (int j = 0; j < icons[i].length; j++) {
+                    icons[i][j] = submap[i][j];
+                    submap[i][j].texturesStitched();
+                }
+            }
+        }
+    }
 
-	@SideOnly(Side.CLIENT)
-	private RenderBlocksCTM rb;
+    @SideOnly(Side.CLIENT)
+    private RenderBlocksCTM rb;
 
-	private TextureSubmap submap, smallSubmap;
-	private int size;
-	private String texturePath;
-	private int meta;
-	private IIcon defaultIcon;
-	private TextureType rType;
+    private TextureSubmap submap, smallSubmap;
+    private int size;
+    private String texturePath;
+    private int meta;
+    private IIcon defaultIcon;
+    private TextureType rType;
 
-	public SubmapManagerCombinedCTM(int meta, String texturePath, TextureType rType) {
-		assert rType == TextureType.R16 || rType == TextureType.R9 || rType == TextureType.R4 || rType == TextureType.V4 || rType == TextureType.V9 : "Not a valid random type!";
+    public SubmapManagerCombinedCTM(int meta, String texturePath, TextureType rType) {
+        assert rType == TextureType.R16 || rType == TextureType.R9
+                || rType == TextureType.R4
+                || rType == TextureType.V4
+                || rType == TextureType.V9 : "Not a valid random type!";
 
-		this.meta = meta;
-		this.texturePath = texturePath;
-		this.size = Integer.parseInt(rType.name().substring(1, rType.name().length())); // >.>
-		this.rType = rType;
-	}
+        this.meta = meta;
+        this.texturePath = texturePath;
+        this.size = Integer.parseInt(rType.name().substring(1, rType.name().length())); // >.>
+        this.rType = rType;
+    }
 
-	@Override
-	public IIcon getIcon(int side, int meta) {
-		return defaultIcon;
-	}
+    @Override
+    public IIcon getIcon(int side, int meta) {
+        return defaultIcon;
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public RenderBlocks createRenderContext(RenderBlocks rendererOld, Block block, IBlockAccess world) {
-		if (rb == null) {
-			rb = new RenderBlocksCombinedCTM();
-		}
-		rb.setRenderBoundsFromBlock(block);
-		return rb;
-	}
+    @Override
+    @SideOnly(Side.CLIENT)
+    public RenderBlocks createRenderContext(RenderBlocks rendererOld, Block block, IBlockAccess world) {
+        if (rb == null) {
+            rb = new RenderBlocksCombinedCTM();
+        }
+        rb.setRenderBoundsFromBlock(block);
+        return rb;
+    }
 
-	@SuppressWarnings("unchecked")
-	@Override
-	@SideOnly(Side.CLIENT)
-	public void registerIcons(String modName, Block block, IIconRegister register) {
-		IIcon base = register.registerIcon(modName + ":" + texturePath);
-		int wh = (int) Math.sqrt(size);
-		TextureSubmap[][] submaps = new TextureSubmap[wh][wh];
-		TextureSubmap[][] submapsSmall = new TextureSubmap[wh][wh];
-		for (int i = 0; i < size; i++) {
-			AbstractSubmapManager manager = (AbstractSubmapManager) TextureType.CTMX.createManagerFor(CarvingUtils.getDefaultVariationFor(block, meta, 0), texturePath + "-" + i);
-			manager.registerIcons(modName, block, register);
-			Object cached = manager.getCachedObject();
-			Triple<IIcon, TextureSubmap, TextureSubmap> triple = (Triple<IIcon, TextureSubmap, TextureSubmap>) cached;
-			submaps[i % wh][i / wh] = triple.getMiddle();
-			submapsSmall[i % wh][i / wh] = triple.getRight();
-			if (i == 0) {
-				defaultIcon = triple.getRight().getBaseIcon();
-			}
-		}
-		submap = new Submap(base, wh, submaps);
-		smallSubmap = new Submap(base, wh, submapsSmall);
-	}
+    @SuppressWarnings("unchecked")
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(String modName, Block block, IIconRegister register) {
+        IIcon base = register.registerIcon(modName + ":" + texturePath);
+        int wh = (int) Math.sqrt(size);
+        TextureSubmap[][] submaps = new TextureSubmap[wh][wh];
+        TextureSubmap[][] submapsSmall = new TextureSubmap[wh][wh];
+        for (int i = 0; i < size; i++) {
+            AbstractSubmapManager manager = (AbstractSubmapManager) TextureType.CTMX
+                    .createManagerFor(CarvingUtils.getDefaultVariationFor(block, meta, 0), texturePath + "-" + i);
+            manager.registerIcons(modName, block, register);
+            Object cached = manager.getCachedObject();
+            Triple<IIcon, TextureSubmap, TextureSubmap> triple = (Triple<IIcon, TextureSubmap, TextureSubmap>) cached;
+            submaps[i % wh][i / wh] = triple.getMiddle();
+            submapsSmall[i % wh][i / wh] = triple.getRight();
+            if (i == 0) {
+                defaultIcon = triple.getRight().getBaseIcon();
+            }
+        }
+        submap = new Submap(base, wh, submaps);
+        smallSubmap = new Submap(base, wh, submapsSmall);
+    }
 }

src/main/java/team/chisel/client/render/SubmapManagerFakeController.java

@@ -1,68 +1,71 @@
 package team.chisel.client.render;
 
-import team.chisel.Chisel;
-import team.chisel.ctmlib.CTM;
-import team.chisel.ctmlib.TextureSubmap;
-import team.chisel.init.ChiselBlocks;
+import static team.chisel.ctmlib.Dir.*;
+
 import net.minecraft.block.Block;
 import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
 
-import com.google.common.base.Optional;
+import team.chisel.Chisel;
+import team.chisel.ctmlib.CTM;
+import team.chisel.ctmlib.TextureSubmap;
+import team.chisel.init.ChiselBlocks;
 
-import static team.chisel.ctmlib.Dir.*;
+import com.google.common.base.Optional;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
 public class SubmapManagerFakeController extends SubmapManagerBase {
 
-	private TextureSubmap map;
-	private CTM ctm = CTM.getInstance();
-	private int meta;
-	private String texturePath;
+    private TextureSubmap map;
+    private CTM ctm = CTM.getInstance();
+    private int meta;
+    private String texturePath;
 
-	public SubmapManagerFakeController(int meta, String texture) {
-		ctm.disableObscuredFaceCheck = Optional.of(true);
-		this.meta = meta;
-		texturePath = texture;
-	}
+    public SubmapManagerFakeController(int meta, String texture) {
+        ctm.disableObscuredFaceCheck = Optional.of(true);
+        this.meta = meta;
+        texturePath = texture;
+    }
 
-	public SubmapManagerFakeController(int meta) {
-		ctm.disableObscuredFaceCheck = Optional.of(true);
-		this.meta = meta;
-	}
+    public SubmapManagerFakeController(int meta) {
+        ctm.disableObscuredFaceCheck = Optional.of(true);
+        this.meta = meta;
+    }
 
-	@Override
-	public IIcon getIcon(int side, int meta) {
-		return map.getSubIcon(0, 0);
-	}
+    @Override
+    public IIcon getIcon(int side, int meta) {
+        return map.getSubIcon(0, 0);
+    }
 
-	@Override
-	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
-		ctm.buildConnectionMap(world, x, y, z, side, ChiselBlocks.futura, meta);
+    @Override
+    public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+        ctm.buildConnectionMap(world, x, y, z, side, ChiselBlocks.futura, meta);
 
-		if (ctm.connectedAnd(TOP, TOP_RIGHT, RIGHT, BOTTOM_RIGHT, BOTTOM, BOTTOM_LEFT, LEFT, TOP_LEFT)) {
-			return map.getSubIcon(1, 1);
-		} else if (ctm.connectedAnd(TOP, BOTTOM)) {
-			return map.getSubIcon(0, 1);
-		} else if (ctm.connectedAnd(LEFT, RIGHT)) {
-			return map.getSubIcon(1, 0);
-		} else {
-			return map.getSubIcon(0, 0);
-		}
-	}
+        if (ctm.connectedAnd(TOP, TOP_RIGHT, RIGHT, BOTTOM_RIGHT, BOTTOM, BOTTOM_LEFT, LEFT, TOP_LEFT)) {
+            return map.getSubIcon(1, 1);
+        } else if (ctm.connectedAnd(TOP, BOTTOM)) {
+            return map.getSubIcon(0, 1);
+        } else if (ctm.connectedAnd(LEFT, RIGHT)) {
+            return map.getSubIcon(1, 0);
+        } else {
+            return map.getSubIcon(0, 0);
+        }
+    }
 
-	@Override
-	@SideOnly(Side.CLIENT)
-	public void registerIcons(String modName, Block block, IIconRegister register) {
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(String modName, Block block, IIconRegister register) {
 
-		if (texturePath != null) {
-			map = new TextureSubmap(register.registerIcon(modName + ":" + texturePath), 2, 2);
-		} else {
-			Chisel.logger.info("SubmapManagerFakeController was called on block " + block.getUnlocalizedName() + " without declaring texture, using a default texture instead.");
-			map = new TextureSubmap(register.registerIcon(modName + ":futura/WIP/controller"), 2, 2);
-		}
-	}
+        if (texturePath != null) {
+            map = new TextureSubmap(register.registerIcon(modName + ":" + texturePath), 2, 2);
+        } else {
+            Chisel.logger.info(
+                    "SubmapManagerFakeController was called on block " + block.getUnlocalizedName()
+                            + " without declaring texture, using a default texture instead.");
+            map = new TextureSubmap(register.registerIcon(modName + ":futura/WIP/controller"), 2, 2);
+        }
+    }
 }