Added Logger to check free Meta IDs in dev.

Freed up some indexes in TAE.
Finished work on Chisel single blocks.
Finished work on Chisel multiblock.
Finished work on Rock Breaker multiblock.

9 files changed, 704 insertions, 77 deletions

diff --git a/src/main/java/gtPlusPlus/GTplusplus.java b/src/main/java/gtPlusPlus/GTplusplus.java
index 9787a38504..1513a0999c 100644
--- a/src/main/java/gtPlusPlus/GTplusplus.java
+++ b/src/main/java/gtPlusPlus/GTplusplus.java
@@ -228,6 +228,22 @@ public class GTplusplus implements ActionListener {
 		Logger.INFO(
 				"Finally, we are finished. Have some cripsy bacon as a reward."
 		);
+		
+		// Log free GT++ Meta IDs
+		if (CORE.DEVENV) {
+			// 750	-  999  are reserved for Alkalus.
+			for (int i=750; i<1000;i++) {
+				if (gregtech.api.GregTech_API.METATILEENTITIES[i] == null) {
+					Logger.INFO("MetaID "+i+" is free.");
+				}
+			}
+			// 30000 - 31999 are reserved for Alkalus.
+			for (int i=30000; i<32000;i++) {
+				if (gregtech.api.GregTech_API.METATILEENTITIES[i] == null) {
+					Logger.INFO("MetaID "+i+" is free.");
+				}
+			}
+		}
 	}
 
 	@EventHandler
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java b/src/main/java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java
index 71d6ae1d68..d3caf99af6 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java
@@ -415,6 +415,7 @@ public enum GregtechItemList implements GregtechItemContainer {
 	
 	// Industrial Chisel
 	Controller_IndustrialAutoChisel,
+	Casing_IndustrialAutoChisel,
 
 	// Custom Machine Casings
 	Casing_Machine_Custom_1,
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/blocks/GregtechMetaCasingBlocks3.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/blocks/GregtechMetaCasingBlocks3.java
index 8cd6dd0ca8..76bd57b3fa 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/blocks/GregtechMetaCasingBlocks3.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/blocks/GregtechMetaCasingBlocks3.java
@@ -46,6 +46,10 @@ extends GregtechMetaCasingBlocksAbstract {
 	public GregtechMetaCasingBlocks3() {
 		super(GregtechMetaCasingItemBlocks3.class, "gtplusplus.blockcasings.3", GT_Material_Casings.INSTANCE);
 		for (byte i = 0; i < 16; i = (byte) (i + 1)) {
+			// Free up Redox casing in TAE
+			if (i >= 4 && i <= 8) {
+				continue;
+			}
 			TAE.registerTexture(2, i, new GT_CopiedBlockTexture(this, 6, i));
 		}
 		GT_LanguageManager.addStringLocalization(this.getUnlocalizedName() + ".0.name", "Aquatic Casing");
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/blocks/GregtechMetaCasingBlocks5.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/blocks/GregtechMetaCasingBlocks5.java
index 61c71ba552..4f84a3daca 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/blocks/GregtechMetaCasingBlocks5.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/blocks/GregtechMetaCasingBlocks5.java
@@ -31,7 +31,8 @@ extends GregtechMetaCasingBlocksAbstract {
 		TAE.registerTexture(0, 3, new GT_CopiedBlockTexture(this, 6, 3));
 		GT_LanguageManager.addStringLocalization(this.getUnlocalizedName() + ".4.name", "Sparge Tower Exterior Casing"); // Sparge Tower Casing
 		TAE.registerTexture(0, 4, new GT_CopiedBlockTexture(this, 6, 4));
-		GT_LanguageManager.addStringLocalization(this.getUnlocalizedName() + ".5.name", ""); // Unused
+		GT_LanguageManager.addStringLocalization(this.getUnlocalizedName() + ".5.name", "Sturdy Printer Casing"); // Unused
+		TAE.registerTexture(1, 10, new GT_CopiedBlockTexture(this, 6, 5));
 		GT_LanguageManager.addStringLocalization(this.getUnlocalizedName() + ".6.name", ""); // Unused
 		GT_LanguageManager.addStringLocalization(this.getUnlocalizedName() + ".7.name", ""); // Unused
 		GT_LanguageManager.addStringLocalization(this.getUnlocalizedName() + ".8.name", ""); // Unused
@@ -48,6 +49,7 @@ extends GregtechMetaCasingBlocksAbstract {
 		GregtechItemList.Casing_IsaMill_Gearbox.set(new ItemStack(this, 1, 2));
 		GregtechItemList.Casing_ElementalDuplicator.set(new ItemStack(this, 1, 3));
 		GregtechItemList.Casing_Sparge_Tower_Exterior.set(new ItemStack(this, 1, 4));
+		GregtechItemList.Casing_IndustrialAutoChisel.set(new ItemStack(this, 1, 5));
 	}
 	
 	@Override
@@ -69,6 +71,8 @@ extends GregtechMetaCasingBlocksAbstract {
 					return TexturesGtBlock.TEXTURE_TECH_PANEL_D.getIcon();
 				case 4:
 					return TexturesGtBlock.Casing_Machine_Metal_Sheet_H.getIcon();
+				case 5:
+					return TexturesGtBlock.Casing_Machine_Metal_Sheet_I.getIcon();
 			}
 		}
 		return Textures.BlockIcons.RENDERING_ERROR.getIcon();		
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntity_AutoChisel.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntity_AutoChisel.java
index 39545daec1..ea99f8d52a 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntity_AutoChisel.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntity_AutoChisel.java
@@ -1,5 +1,129 @@
 package gtPlusPlus.xmod.gregtech.common.tileentities.machines.basic;
 
-public class GregtechMetaTileEntity_AutoChisel {
+import java.util.List;
 
-}
+import gregtech.api.enums.Textures.BlockIcons;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Recipe;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
+import net.minecraft.item.ItemStack;
+import team.chisel.carving.Carving;
+
+public class GregtechMetaTileEntity_AutoChisel extends GT_MetaTileEntity_BasicMachine {
+
+	public GregtechMetaTileEntity_AutoChisel(int aID, String aName, String aNameRegional, int aTier) {
+		super(aID, aName, aNameRegional, aTier, 1, "Chisels things, Gregtech style", 1, 1, "Compressor.png", "", 
+				new ITexture[]{
+						new GT_RenderedTexture(BlockIcons.OVERLAY_SIDE_MASSFAB_ACTIVE),
+						new GT_RenderedTexture(BlockIcons.OVERLAY_SIDE_MASSFAB),
+						new GT_RenderedTexture(BlockIcons.OVERLAY_FRONT_MULTI_SMELTER_ACTIVE),
+						new GT_RenderedTexture(BlockIcons.OVERLAY_FRONT_MULTI_SMELTER),
+						new GT_RenderedTexture(TexturesGtBlock.Overlay_MatterFab_Active),
+						new GT_RenderedTexture(TexturesGtBlock.Overlay_MatterFab),
+						new GT_RenderedTexture(BlockIcons.OVERLAY_BOTTOM_MASSFAB_ACTIVE),
+						new GT_RenderedTexture(BlockIcons.OVERLAY_BOTTOM_MASSFAB)
+		});
+	}
+
+	public GregtechMetaTileEntity_AutoChisel(String aName, int aTier, String aDescription, ITexture[][][] aTextures, String aGUIName, String aNEIName) {
+		super(aName, aTier, 1, aDescription, aTextures, 1, 1, aGUIName, aNEIName);
+	}
+
+	@Override
+	public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new GregtechMetaTileEntity_AutoChisel(this.mName, this.mTier, this.mDescription, this.mTextures, this.mGUIName, this.mNEIName);
+	}
+
+	@Override
+	public String[] getDescription() {
+		String[] A = new String[]{
+				this.mDescription,
+				"What you want to chisel goes in slot 1",
+				"What you want to get goes in the special slot (bottom right)",
+				"If special slot is empty, first chisel result is used"
+		};		
+		return A;
+	}
+	
+    @Override
+    public GT_Recipe.GT_Recipe_Map getRecipeList() {
+        return null;
+    }
+
+    @Override
+    protected boolean allowPutStackValidated(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+        return super.allowPutStackValidated(aBaseMetaTileEntity, aIndex, aSide, aStack) && hasChiselResults(aStack);
+    }
+    
+	// lets make sure the user isn't trying to make something from a block that doesn't have this as a valid target
+	private static boolean canBeMadeFrom(ItemStack from, ItemStack to) {
+		List<ItemStack> results = getItemsForChiseling(from);
+		for (ItemStack s : results) {
+			if (s.getItem() == to.getItem() && s.getItemDamage() == to.getItemDamage()) {
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	// lets make sure the user isn't trying to make something from a block that doesn't have this as a valid target
+	private static boolean hasChiselResults(ItemStack from) {
+		List<ItemStack> results = getItemsForChiseling(from);		
+		return results.size() > 0;
+	}
+	
+	private static List<ItemStack> getItemsForChiseling(ItemStack aStack){
+		return Carving.chisel.getItemsForChiseling(aStack);
+	}
+	
+    @Override
+    public int checkRecipe() {
+    	ItemStack tOutput = null;
+    	ItemStack aInput = getInputAt(0);
+    	ItemStack aTarget = getSpecialSlot();
+    	if (aInput != null && hasChiselResults(aInput) && aInput.stackSize > 0) {
+    		Logger.INFO("Has Valid Input.");
+    		if (aTarget != null && canBeMadeFrom(aInput, aTarget)) {
+    			tOutput = aTarget;
+        		Logger.INFO("Has Valid Target.");
+    		}
+    		else {
+    			tOutput = getItemsForChiseling(aInput).get(0);
+        		Logger.INFO("Using target(0)");
+    		}
+    		if (tOutput != null) {
+        		Logger.INFO("Has Valid Output. "+tOutput.getDisplayName());
+    			// We can chisel this
+    			if (canOutput(tOutput)) {
+    	    		Logger.INFO("Can Output");
+        			getInputAt(0).stackSize -= 1;
+    	    		Logger.INFO("Consuming 1 input");
+        			calculateOverclockedNess(16, 20);
+    	    		Logger.INFO("Did Overclock");
+        			//In case recipe is too OP for that machine
+        			if (mMaxProgresstime == Integer.MAX_VALUE - 1 && mEUt == Integer.MAX_VALUE - 1) {
+        	    		Logger.INFO("Brrrrr");
+        				return FOUND_RECIPE_BUT_DID_NOT_MEET_REQUIREMENTS;
+        			}
+    	    		Logger.INFO("Setting Output");
+        			this.mOutputItems[0] = tOutput;
+            		Logger.INFO("Recipe good.");
+        			return FOUND_AND_SUCCESSFULLY_USED_RECIPE;	
+        		}
+    			else {
+    	    		Logger.INFO("Cannot Output");
+    	            mOutputBlocked++;
+    	            return FOUND_RECIPE_BUT_DID_NOT_MEET_REQUIREMENTS;
+    	        }
+    		}
+    	}
+		Logger.INFO("Recipe bad.");
+    	return DID_NOT_FIND_RECIPE;
+    }
+	
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialChisel.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialChisel.java
index 871b863b22..51775791f4 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialChisel.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialChisel.java
@@ -1,5 +1,438 @@
 package gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.processing;
 
-public class GregtechMetaTileEntity_IndustrialChisel {
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.onElementPass;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
+import static gtPlusPlus.core.util.data.ArrayUtils.removeNulls;
 
-}
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.commons.lang3.ArrayUtils;
+
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBus;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Maintenance;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Muffler;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_OutputBus;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GTPP_Recipe;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.block.ModBlocks;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+import team.chisel.carving.Carving;
+
+public class GregtechMetaTileEntity_IndustrialChisel extends GregtechMeta_MultiBlockBase<GregtechMetaTileEntity_IndustrialChisel> {
+
+	private int mCasing;
+	private IStructureDefinition<GregtechMetaTileEntity_IndustrialChisel> STRUCTURE_DEFINITION = null;
+
+	public GregtechMetaTileEntity_IndustrialChisel(int aID, String aName, String aNameRegional) {
+		super(aID, aName, aNameRegional);
+	}
+
+	public GregtechMetaTileEntity_IndustrialChisel(String aName) {
+		super(aName);
+	}
+
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new GregtechMetaTileEntity_IndustrialChisel(this.mName);
+	}
+
+	@Override
+	public String getMachineType() {
+		return "Chisel";
+	}
+
+	@Override
+	protected GT_Multiblock_Tooltip_Builder createTooltip() {
+		GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+		tt.addMachineType(getMachineType())
+				.addInfo("Factory Grade Auto Chisel")
+				.addInfo("Target block goes in GUI slot")
+				.addInfo("If no target provided, firdt chisel result is used")
+				.addInfo("Speed: 200% | Eu Usage: 75% | Parallel: Tier x 16")
+				.addPollutionAmount(getPollutionPerSecond(null))
+				.addSeparator()
+				.beginStructureBlock(3, 3, 3, true)
+				.addController("Front center")
+				.addCasingInfo("Sturdy Printer Casing", 10)
+				.addInputBus("Any casing", 1)
+				.addOutputBus("Any casing", 1)
+				.addEnergyHatch("Any casing", 1)
+				.addMaintenanceHatch("Any casing", 1)
+				.addMufflerHatch("Any casing", 1)
+				.toolTipFinisher(CORE.GT_Tooltip_Builder);
+		return tt;
+	}
+
+	@Override
+	public IStructureDefinition<GregtechMetaTileEntity_IndustrialChisel> getStructureDefinition() {
+		if (STRUCTURE_DEFINITION == null) {
+			STRUCTURE_DEFINITION = StructureDefinition.<GregtechMetaTileEntity_IndustrialChisel>builder()
+					.addShape(mName, transpose(new String[][]{
+							{"CCC", "CCC", "CCC"},
+							{"C~C", "C-C", "CCC"},
+							{"CCC", "CCC", "CCC"},
+					}))
+					.addElement(
+							'C',
+							ofChain(
+									ofHatchAdder(
+											GregtechMetaTileEntity_IndustrialChisel::addAdvChiselList, 90, 1
+									),
+									onElementPass(
+											x -> ++x.mCasing,
+											ofBlock(
+													ModBlocks.blockCasings5Misc, 5
+											)
+									)
+							)
+					)
+					.build();
+		}
+		return STRUCTURE_DEFINITION;
+	}
+
+	public final boolean addAdvChiselList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+		if (aTileEntity == null) {
+			return false;
+		} else {
+			IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+			if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_InputBus){
+				return addToMachineList(aTileEntity, aBaseCasingIndex);
+			} else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_OutputBus) {
+				return addToMachineList(aTileEntity, aBaseCasingIndex);
+			} else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Maintenance){
+				return addToMachineList(aTileEntity, aBaseCasingIndex);
+			} else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Energy){
+				return addToMachineList(aTileEntity, aBaseCasingIndex);
+			} else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Muffler) {
+				return addToMachineList(aTileEntity, aBaseCasingIndex);
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public void construct(ItemStack stackSize, boolean hintsOnly) {
+		buildPiece(mName, stackSize, hintsOnly, 1, 1, 0);
+	}
+
+	@Override
+	public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+		mCasing = 0;
+		return checkPiece(mName, 1, 1, 0) && mCasing >= 10 && checkHatch();
+	}
+
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+		if (aSide == aFacing) {
+			return new ITexture[]{Textures.BlockIcons.getCasingTextureForId(90), new GT_RenderedTexture(aActive ? TexturesGtBlock.Overlay_Machine_Controller_Advanced_Active : TexturesGtBlock.Overlay_Machine_Controller_Advanced)};
+		}
+		return new ITexture[]{Textures.BlockIcons.getCasingTextureForId(90)};
+	}
+
+	@Override
+	public boolean hasSlotInGUI() {
+		return true;
+	}
+
+	@Override
+	public String getCustomGUIResourceName() {
+		return "ImplosionCompressor";
+	}
+
+	@Override
+	public boolean requiresVanillaGtGUI() {
+		return true;
+	}
+
+	public GT_Recipe.GT_Recipe_Map getRecipeMap() {
+		return null;
+	}
+
+	public boolean isCorrectMachinePart(ItemStack aStack) {
+		return true;
+	}
+	
+	// lets make sure the user isn't trying to make something from a block that doesn't have this as a valid target
+	private static boolean canBeMadeFrom(ItemStack from, ItemStack to) {
+		List<ItemStack> results = getItemsForChiseling(from);
+		for (ItemStack s : results) {
+			if (s.getItem() == to.getItem() && s.getItemDamage() == to.getItemDamage()) {
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	// lets make sure the user isn't trying to make something from a block that doesn't have this as a valid target
+	private static boolean hasChiselResults(ItemStack from) {
+		List<ItemStack> results = getItemsForChiseling(from);		
+		return results.size() > 0;
+	}
+	
+	private static List<ItemStack> getItemsForChiseling(ItemStack aStack){
+		return Carving.chisel.getItemsForChiseling(aStack);
+	}
+	
+	private GTPP_Recipe generateChiselRecipe(ItemStack aInput, ItemStack aTarget) {
+		if (aInput != null && hasChiselResults(aInput) && aInput.stackSize > 0) {
+			ItemStack tOutput = null;
+			if (aTarget != null && canBeMadeFrom(aInput, aTarget)) {
+				tOutput = aTarget;
+			}
+			else {
+				tOutput = getItemsForChiseling(aInput).get(0);
+			}
+			if (tOutput != null) {
+				// We can chisel this
+				log("Generated Chisel recipe good.");
+				GTPP_Recipe aRecipe = new GTPP_Recipe(
+						false,
+						new ItemStack[] {ItemUtils.getSimpleStack(aInput, 1)},
+						new ItemStack[] {ItemUtils.getSimpleStack(tOutput, 1)},
+						null, 
+						new int[] {10000}, 
+						new FluidStack[] {}, 
+						new FluidStack[] {},
+						20,
+						16,
+						0);
+				return aRecipe;
+			}
+		}
+		Logger.INFO("Recipe bad.");
+		return null;
+	}
+
+	public boolean checkRecipe(final ItemStack aStack) {
+		ArrayList<ItemStack> aItems = this.getStoredInputs();
+		if (!aItems.isEmpty()) {		
+
+			GT_Recipe tRecipe = generateChiselRecipe(aItems.get(0), this.getGUIItemStack());
+			
+			if (tRecipe == null) {
+				log("BAD RETURN - 0");
+				return false;	
+			}
+
+			// Based on the Processing Array. A bit overkill, but very flexible.	
+			ItemStack[] aItemInputs = aItems.toArray(new ItemStack[aItems.size()]);	
+			FluidStack[] aFluidInputs = new FluidStack[] {};	
+
+			// Reset outputs and progress stats
+			this.mEUt = 0;
+			this.mMaxProgresstime = 0;
+			this.mOutputItems = new ItemStack[]{};
+			this.mOutputFluids = new FluidStack[]{};
+
+			long tVoltage = getMaxInputVoltage();
+			byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage));
+			long tEnergy = getMaxInputEnergy();
+			log("Running checkRecipeGeneric(0)");	
+
+			log("Running checkRecipeGeneric(1)");
+			// Remember last recipe - an optimization for findRecipe()
+			this.mLastRecipe = tRecipe;
+
+			int aMaxParallelRecipes = getMaxParallelRecipes();
+			int aEUPercent = getEuDiscountForParallelism();
+			int aSpeedBonusPercent = 200;
+
+			aMaxParallelRecipes = this.canBufferOutputs(tRecipe, aMaxParallelRecipes);
+			if (aMaxParallelRecipes == 0) {
+				log("BAD RETURN - 2");
+				return false;
+			}
+
+			// EU discount
+			float tRecipeEUt = (tRecipe.mEUt * aEUPercent) / 100.0f;
+			float tTotalEUt = 0.0f;
+
+			int parallelRecipes = 0;
+
+			log("parallelRecipes: "+parallelRecipes);
+			log("aMaxParallelRecipes: "+aMaxParallelRecipes);
+			log("tTotalEUt: "+tTotalEUt);
+			log("tVoltage: "+tVoltage);
+			log("tRecipeEUt: "+tRecipeEUt);
+			// Count recipes to do in parallel, consuming input items and fluids and considering input voltage limits
+			for (; parallelRecipes < aMaxParallelRecipes && tTotalEUt < (tEnergy - tRecipeEUt); parallelRecipes++) {
+				if (!tRecipe.isRecipeInputEqual(true, aFluidInputs, aItemInputs)) {
+					log("Broke at "+parallelRecipes+".");
+					break;
+				}
+				log("Bumped EU from "+tTotalEUt+" to "+(tTotalEUt+tRecipeEUt)+".");
+				tTotalEUt += tRecipeEUt;
+			}
+
+			if (parallelRecipes == 0) {
+				log("BAD RETURN - 3");
+				return false;
+			}
+
+			// -- Try not to fail after this point - inputs have already been consumed! --
+			log("parallelRecipes: "+parallelRecipes);
+			log("aMaxParallelRecipes: "+aMaxParallelRecipes);
+			log("tTotalEUt: "+tTotalEUt);
+			log("tVoltage: "+tVoltage);
+			log("tRecipeEUt: "+tRecipeEUt);
+
+
+			// Convert speed bonus to duration multiplier
+			// e.g. 100% speed bonus = 200% speed = 100%/200% = 50% recipe duration.
+			aSpeedBonusPercent = Math.max(-99, aSpeedBonusPercent);
+			float tTimeFactor = 100.0f / (100.0f + aSpeedBonusPercent);
+			this.mMaxProgresstime = (int)(tRecipe.mDuration * tTimeFactor);
+
+			this.mEUt = (int)Math.ceil(tTotalEUt);
+
+			this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
+			this.mEfficiencyIncrease = 10000;		
+
+			// Overclock
+			if (this.mEUt <= 16) {
+				this.mEUt = (this.mEUt * (1 << tTier - 1) * (1 << tTier - 1));
+				this.mMaxProgresstime = (this.mMaxProgresstime / (1 << tTier - 1));
+			} else {
+				while (this.mEUt <= gregtech.api.enums.GT_Values.V[(tTier - 1)]) {
+					this.mEUt *= 4;
+					this.mMaxProgresstime /= 2;
+				}
+			}
+
+			if (this.mEUt > 0) {
+				this.mEUt = (-this.mEUt);
+			}
+
+			this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime);
+
+			// Collect fluid outputs
+			FluidStack[] tOutputFluids = new FluidStack[tRecipe.mFluidOutputs.length];
+			for (int h = 0; h < tRecipe.mFluidOutputs.length; h++) {
+				if (tRecipe.getFluidOutput(h) != null) {
+					tOutputFluids[h] = tRecipe.getFluidOutput(h).copy();
+					tOutputFluids[h].amount *= parallelRecipes;
+				}
+			}
+
+			// Collect output item types
+			ItemStack[] tOutputItems = new ItemStack[tRecipe.mOutputs.length];
+			for (int h = 0; h < tRecipe.mOutputs.length; h++) {
+				if (tRecipe.getOutput(h) != null) {
+					tOutputItems[h] = tRecipe.getOutput(h).copy();
+					tOutputItems[h].stackSize = 0;
+				}
+			}
+
+			// Set output item stack sizes (taking output chance into account)
+			for (int f = 0; f < tOutputItems.length; f++) {
+				if (tRecipe.mOutputs[f] != null && tOutputItems[f] != null) {
+					for (int g = 0; g < parallelRecipes; g++) {
+						if (getBaseMetaTileEntity().getRandomNumber(10000) <= tRecipe.getOutputChance(f))
+							tOutputItems[f].stackSize += tRecipe.mOutputs[f].stackSize;
+					}
+				}
+			}
+
+			tOutputItems = removeNulls(tOutputItems);
+
+			// Sanitize item stack size, splitting any stacks greater than max stack size
+			List<ItemStack> splitStacks = new ArrayList<ItemStack>();
+			for (ItemStack tItem : tOutputItems) {
+				while (tItem.getMaxStackSize() < tItem.stackSize) {
+					ItemStack tmp = tItem.copy();
+					tmp.stackSize = tmp.getMaxStackSize();
+					tItem.stackSize = tItem.stackSize - tItem.getMaxStackSize();
+					splitStacks.add(tmp);
+				}
+			}
+
+			if (splitStacks.size() > 0) {
+				ItemStack[] tmp = new ItemStack[splitStacks.size()];
+				tmp = splitStacks.toArray(tmp);
+				tOutputItems = ArrayUtils.addAll(tOutputItems, tmp);
+			}
+
+			// Strip empty stacks
+			List<ItemStack> tSList = new ArrayList<ItemStack>();
+			for (ItemStack tS : tOutputItems) {
+				if (tS.stackSize > 0) tSList.add(tS);
+			}
+			tOutputItems = tSList.toArray(new ItemStack[tSList.size()]);
+
+			// Commit outputs
+			this.mOutputItems = tOutputItems;
+			this.mOutputFluids = tOutputFluids;
+			updateSlots();
+
+			// Play sounds (GT++ addition - GT multiblocks play no sounds)
+			startProcess();
+
+			log("GOOD RETURN - 1");
+			return true;
+		}
+
+		return false;
+	}	
+
+	@Override
+	public int getMaxParallelRecipes() {
+		return (16 * GT_Utility.getTier(this.getMaxInputVoltage()));
+	}
+
+	@Override
+	public int getEuDiscountForParallelism() {
+		return 75;
+	}	
+	
+	private static String sChiselSound = null;
+	
+	private static final String getChiselSound() {
+		if (sChiselSound == null) {
+			sChiselSound = Carving.chisel.getVariationSound(Blocks.stone, 0);
+		}
+		return sChiselSound;
+	}
+
+	@Override
+	public String getSound() {
+		return getChiselSound(); 
+	}
+
+	public int getMaxEfficiency(ItemStack aStack) {
+		return 10000;
+	}
+
+	public int getPollutionPerSecond(ItemStack aStack) {
+		return CORE.ConfigSwitches.pollutionPerSecondMultiAdvImplosion;
+	}
+
+	public int getDamageToComponent(ItemStack aStack) {
+		return 0;
+	}
+
+	public boolean explodesOnComponentBreak(ItemStack aStack) {
+		return false;
+	}
+
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntity_IndustrialRockBreaker.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntity_IndustrialRockBreaker.java
index e681069078..885aa05716 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntity_IndustrialRockBreaker.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntity_IndustrialRockBreaker.java
@@ -4,10 +4,13 @@ import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.onElementPass;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static gregtech.api.enums.GT_Values.E;
+import static gregtech.api.enums.GT_Values.RES_PATH_GUI;
 import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
 import static gtPlusPlus.core.util.data.ArrayUtils.removeNulls;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 
 import org.apache.commons.lang3.ArrayUtils;
@@ -35,10 +38,12 @@ import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
 import gregtech.api.util.GT_OreDictUnificator;
 import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
+import gregtech.api.util.GT_Recipe.GT_Recipe_Map_Microwave;
 import gregtech.api.util.GT_Utility;
 import gtPlusPlus.core.block.ModBlocks;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.core.util.minecraft.FluidUtils;
 import gtPlusPlus.core.util.minecraft.ItemUtils;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
 import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
@@ -50,7 +55,6 @@ import net.minecraftforge.fluids.FluidStack;
 
 public class GregtechMetaTileEntity_IndustrialRockBreaker extends GregtechMeta_MultiBlockBase<GregtechMetaTileEntity_IndustrialRockBreaker> {
 
-	private static Item circuit;
 	private int mCasing;
 	private IStructureDefinition<GregtechMetaTileEntity_IndustrialRockBreaker> STRUCTURE_DEFINITION = null;
 
@@ -88,7 +92,7 @@ public class GregtechMetaTileEntity_IndustrialRockBreaker extends GregtechMeta_M
 		.addSeparator()
 		.beginStructureBlock(3, 4, 3, true)
 		.addController("Bottom Center")
-		.addCasingInfo("Thermal Processing Casing", 10)
+		.addCasingInfo("Thermal Processing Casing", 9)
 		.addCasingInfo("Thermal Containment Casing", 16)
 		.addInputBus("Any Casing", 1)
 		.addInputHatch("Any Casing", 1)
@@ -143,7 +147,11 @@ public class GregtechMetaTileEntity_IndustrialRockBreaker extends GregtechMeta_M
 	@Override
 	public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
 		mCasing = 0;
-		return checkPiece(mName, 1, 3, 0) && mCasing >= 10 && mEnergyHatches.size() == 1 && checkHatch();
+		boolean aCheckPiece = checkPiece(mName, 1, 3, 0);
+		boolean aCasingCount = mCasing >= 9;
+		boolean aCheckHatch = checkHatch();
+		log(""+aCheckPiece+", "+aCasingCount+", "+aCheckHatch);
+		return aCheckPiece && aCasingCount && aCheckHatch;
 	}
 
 	public final boolean addRockBreakerList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
@@ -196,10 +204,31 @@ public class GregtechMetaTileEntity_IndustrialRockBreaker extends GregtechMeta_M
 	public String getCustomGUIResourceName() {
 		return "ElectricBlastFurnace";
 	}	
+	
+	private static final GT_Recipe_Map sFakeRecipeMap = new GT_Recipe_Map(new HashSet<>(0), "gt.recipe.fakerockbreaker", "Rock Breaker", "smelting", RES_PATH_GUI + "basicmachines/E_Furnace", 1, 1, 0, 0, 1, E, 1, E, true, false);
 
+	private static void generateRecipeMap() {
+		if (sRecipe_Cobblestone == null || sRecipe_SmoothStone == null || sRecipe_Redstone == null) {
+			generateRecipes();			
+		}
+		FluidStack[] aInputFluids = new FluidStack[] {FluidUtils.getWater(1000), FluidUtils.getLava(1000)};
+		GT_Recipe aTemp = sRecipe_Cobblestone.copy();
+		aTemp.mFluidInputs = aInputFluids;
+		sFakeRecipeMap.add(aTemp);
+		aTemp = sRecipe_SmoothStone.copy();
+		aTemp.mFluidInputs = aInputFluids;
+		sFakeRecipeMap.add(aTemp);
+		aTemp = sRecipe_Redstone.copy();
+		aTemp.mFluidInputs = aInputFluids;
+		sFakeRecipeMap.add(aTemp);		
+	}
+	
 	@Override
 	public GT_Recipe.GT_Recipe_Map getRecipeMap() {
-		return GT_Recipe_Map.sRockBreakerFakeRecipes;
+		if (sFakeRecipeMap.mRecipeList.isEmpty()) {
+			generateRecipeMap();
+		}
+		return sFakeRecipeMap;
 	}
 
 	@Override
@@ -212,58 +241,52 @@ public class GregtechMetaTileEntity_IndustrialRockBreaker extends GregtechMeta_M
 	private static GT_Recipe sRecipe_Redstone;
 
 	private static final void generateRecipes() {
-		if (sRecipe_Cobblestone == null) {
-			sRecipe_Cobblestone = new GTPP_Recipe(
-					false,
-					new ItemStack[] {
-							CI.getNumberedCircuit(1)
-					},
-					new ItemStack[] {
-							ItemUtils.getSimpleStack(Blocks.cobblestone)
-					},
-					null, 
-					new int[] {10000}, 
-					null, 
-					null, 
-					16, 
-					32, 
-					0);
-		}
-		if (sRecipe_SmoothStone == null) {
-			sRecipe_SmoothStone = new GTPP_Recipe(
-					false,
-					new ItemStack[] {
-							CI.getNumberedCircuit(2)
-					},
-					new ItemStack[] {
-							ItemUtils.getSimpleStack(Blocks.stone)
-					},
-					null, 
-					new int[] {10000}, 
-					null, 
-					null, 
-					16, 
-					32, 
-					0);
-		}
-		if (sRecipe_Redstone == null) {
-			sRecipe_Redstone = new GTPP_Recipe(
-					false,
-					new ItemStack[] {
-							CI.getNumberedCircuit(3),
-							GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Redstone, 1L)
-					},
-					new ItemStack[] {
-							ItemUtils.getSimpleStack(Blocks.obsidian)
-					},
-					null, 
-					new int[] {10000}, 
-					null, 
-					null, 
-					128, 
-					32, 
-					0);
-		}
+		sRecipe_Cobblestone = new GTPP_Recipe(
+				false,
+				new ItemStack[] {
+						CI.getNumberedCircuit(1)
+				},
+				new ItemStack[] {
+						ItemUtils.getSimpleStack(Blocks.cobblestone)
+				},
+				null, 
+				new int[] {10000}, 
+				null, 
+				null, 
+				16, 
+				32, 
+				0);
+		sRecipe_SmoothStone = new GTPP_Recipe(
+				false,
+				new ItemStack[] {
+						CI.getNumberedCircuit(2)
+				},
+				new ItemStack[] {
+						ItemUtils.getSimpleStack(Blocks.stone)
+				},
+				null, 
+				new int[] {10000}, 
+				null, 
+				null, 
+				16, 
+				32, 
+				0);
+		sRecipe_Redstone = new GTPP_Recipe(
+				false,
+				new ItemStack[] {
+						CI.getNumberedCircuit(3),
+						GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Redstone, 1L)
+				},
+				new ItemStack[] {
+						ItemUtils.getSimpleStack(Blocks.obsidian)
+				},
+				null, 
+				new int[] {10000}, 
+				null, 
+				null, 
+				128, 
+				32, 
+				0);
 	}
 
 	@Override
@@ -301,7 +324,9 @@ public class GregtechMetaTileEntity_IndustrialRockBreaker extends GregtechMeta_M
 				return false;				
 			}
 
-			generateRecipes();
+			if (sRecipe_Cobblestone == null || sRecipe_SmoothStone == null || sRecipe_Redstone == null) {
+				generateRecipes();			
+			}
 			
 			int aCircuit = aGuiCircuit.getItemDamage();
 
@@ -327,7 +352,7 @@ public class GregtechMetaTileEntity_IndustrialRockBreaker extends GregtechMeta_M
 
 			// Based on the Processing Array. A bit overkill, but very flexible.	
 			ItemStack[] aItemInputs = aItems.toArray(new ItemStack[aItems.size()]);
-			FluidStack[] aFluidInputs = aFluids.toArray(new FluidStack[aFluids.size()]);	
+			FluidStack[] aFluidInputs = new FluidStack[] {};	
 
 			// Reset outputs and progress stats
 			this.mEUt = 0;
@@ -365,16 +390,25 @@ public class GregtechMetaTileEntity_IndustrialRockBreaker extends GregtechMeta_M
 			log("tTotalEUt: "+tTotalEUt);
 			log("tVoltage: "+tVoltage);
 			log("tRecipeEUt: "+tRecipeEUt);
-			// Count recipes to do in parallel, consuming input items and fluids and considering input voltage limits
-			for (; parallelRecipes < aMaxParallelRecipes && tTotalEUt < (tEnergy - tRecipeEUt); parallelRecipes++) {
-				if (!tRecipe.isRecipeInputEqual(true, aFluidInputs, aItemInputs)) {
-					log("Broke at "+parallelRecipes+".");
-					break;
+			
+			if (aItems.size() > 0 && aCircuit == 3) {
+				// Count recipes to do in parallel, consuming input items and fluids and considering input voltage limits
+				for (; parallelRecipes < aMaxParallelRecipes && tTotalEUt < (tEnergy - tRecipeEUt); parallelRecipes++) {
+					if (!tRecipe.isRecipeInputEqual(true, aFluidInputs, aItemInputs)) {
+						break;
+					}
+					log("Bumped EU from "+tTotalEUt+" to "+(tTotalEUt+tRecipeEUt)+".");
+					tTotalEUt += tRecipeEUt;
+				}
+			}
+			else if (aCircuit >= 1 && aCircuit <= 2) {
+				for (; parallelRecipes < aMaxParallelRecipes && tTotalEUt < (tEnergy - tRecipeEUt); parallelRecipes++) {
+					log("Bumped EU from "+tTotalEUt+" to "+(tTotalEUt+tRecipeEUt)+".");
+					tTotalEUt += tRecipeEUt;
 				}
-				log("Bumped EU from "+tTotalEUt+" to "+(tTotalEUt+tRecipeEUt)+".");
-				tTotalEUt += tRecipeEUt;
 			}
 
+			log("Broke at "+parallelRecipes+".");
 			if (parallelRecipes == 0) {
 				log("BAD RETURN - 3");
 				return false;
@@ -488,7 +522,7 @@ public class GregtechMetaTileEntity_IndustrialRockBreaker extends GregtechMeta_M
 
 	@Override
 	public int getEuDiscountForParallelism() {
-		return 80;
+		return 75;
 	}
 
 	@Override
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechIndustrialChisel.java b/src/main/java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechIndustrialChisel.java
index aa28faa6f9..2027e6b190 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechIndustrialChisel.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechIndustrialChisel.java
@@ -1,14 +1,25 @@
 package gtPlusPlus.xmod.gregtech.registration.gregtech;
 
 import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList;
-import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.production.GregtechMetaTileEntity_IndustrialRockBreaker;
+import gtPlusPlus.xmod.gregtech.common.tileentities.machines.basic.GregtechMetaTileEntity_AutoChisel;
+import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.processing.GregtechMetaTileEntity_IndustrialChisel;
 
 public class GregtechIndustrialChisel {
 
-	public static void run() {
-		// Industrial Maceration Stack Multiblock
-		/*GregtechItemList.Controller_IndustrialRockBreaker.set(new GregtechMetaTileEntity_IndustrialRockBreaker(32005,
-				"industrialrockcrusher.controller.tier.single", "Boldarnator").getStackForm(1L));*/
+	public static void run() {		
+		GregtechItemList.GT_Chisel_LV.set(new GregtechMetaTileEntity_AutoChisel(31066,
+				"chisel.tier.01", "Basic Auto-Chisel", 1).getStackForm(1L));
+		GregtechItemList.GT_Chisel_MV.set(new GregtechMetaTileEntity_AutoChisel(31067,
+				"chisel.tier.02", "Advanced Auto-Chisel", 2).getStackForm(1L));
+		GregtechItemList.GT_Chisel_HV.set(new GregtechMetaTileEntity_AutoChisel(31068,
+				"chisel.tier.03", "Precision Auto-Chisel", 3).getStackForm(1L));
+		
+		GregtechItemList.Controller_IndustrialAutoChisel.set(
+				new GregtechMetaTileEntity_IndustrialChisel(31069,
+						"multimachine.adv.chisel",
+						"Industrial 3D Copying Machine").getStackForm(1L));
+
+		
 	}
 	
 }
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechIndustrialRockBreaker.java b/src/main/java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechIndustrialRockBreaker.java
index 45b923083e..562693ee3e 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechIndustrialRockBreaker.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechIndustrialRockBreaker.java
@@ -6,7 +6,7 @@ import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.production.Gr
 public class GregtechIndustrialRockBreaker {
 
 	public static void run() {
-		GregtechItemList.Controller_IndustrialRockBreaker.set(new GregtechMetaTileEntity_IndustrialRockBreaker(32005,
+		GregtechItemList.Controller_IndustrialRockBreaker.set(new GregtechMetaTileEntity_IndustrialRockBreaker(31065,
 				"industrialrockcrusher.controller.tier.single", "Boldarnator").getStackForm(1L));
 	}