Merge pull request #1 from alkcorp/DevTop

Dev top

6 files changed, 565 insertions, 108 deletions

diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java b/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java
index 588c04d7e5..3fc6d9d667 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java
@@ -228,6 +228,9 @@ public enum GregtechItemList implements GregtechItemContainer {
 	//Fish Pond
 	Industrial_FishingPond,
 	Casing_FishPond,  
+	
+	//Algae
+	AlgaeFarm_Controller,
 
 
 	//GT4 autoCrafter
@@ -343,6 +346,9 @@ public enum GregtechItemList implements GregtechItemContainer {
 	//XL Turbine Rotor Hatch
 	Hatch_Turbine_Rotor,
 	
+	//Standard Turbine Rotor Hatch
+	Hatch_Input_TurbineHousing,
+	
 	//Control Core
 	Hatch_Control_Core,
 
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/gui/CONTAINER_MultiMachine.java b/src/Java/gtPlusPlus/xmod/gregtech/api/gui/CONTAINER_MultiMachine.java
index d3e22875ae..88b9661c95 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/api/gui/CONTAINER_MultiMachine.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/api/gui/CONTAINER_MultiMachine.java
@@ -101,32 +101,32 @@ public class CONTAINER_MultiMachine extends GT_ContainerMetaTile_Machine {
 			//crafters = ReflectionUtils.getField(getClass(), "crafters");
 		}
 		if (timer != null && crafters != null && mControllerSet) {
-			Logger.INFO("Trying to update clientside GUI data");
+			//Logger.INFO("Trying to update clientside GUI data");
 			try {
-				Logger.INFO("0");		
+				//Logger.INFO("0");		
 				int aTimer = (int) ReflectionUtils.getFieldValue(timer, this);				
 				
 				//List crafters1List = (List) crafters1;
 				List<ICrafting> crafters2 = new ArrayList<ICrafting>();
-				Logger.INFO("1");		
+				//Logger.INFO("1");		
 				for (Object o : crafters) {
 					if (o instanceof ICrafting) {
 						crafters2.add((ICrafting) o);
 					}
 				}
-				Logger.INFO("2");		
+				//Logger.INFO("2");		
 				if (!crafters2.isEmpty()) {
-					Logger.INFO("3");		
+					//Logger.INFO("3");		
 					handleInitialFieldSetting();
 
 					try {
-						Logger.INFO("4");		
+						//Logger.INFO("4");		
 						for (final ICrafting var3 : crafters2) {
 							handleCraftingEvent(aTimer, var3);
 						}
-						Logger.INFO("5");		
+						//Logger.INFO("5");		
 						handleInternalFieldSetting();
-						Logger.INFO("6");		
+						//Logger.INFO("6");		
 					} catch (Throwable t) {
 
 					}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/gui/hatches/CONTAINER_1by1_Turbine.java b/src/Java/gtPlusPlus/xmod/gregtech/api/gui/hatches/CONTAINER_1by1_Turbine.java
index d4d2fcacd7..e6203823b6 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/api/gui/hatches/CONTAINER_1by1_Turbine.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/api/gui/hatches/CONTAINER_1by1_Turbine.java
@@ -36,11 +36,11 @@ public class CONTAINER_1by1_Turbine extends GT_Container_1by1 {
     	}
     	@Override
     	public boolean isItemValid(final ItemStack itemstack) {
-    		/*if (itemstack.getItem() instanceof GT_MetaGenerated_Tool) {
+    		if (itemstack.getItem() instanceof GT_MetaGenerated_Tool) {
     			if (itemstack.getItemDamage() >= 170 && itemstack.getItemDamage() <= 176) {
     				return true;
     			}    			
-    		}*/
+    		}
     		return false;
     	}
     	@Override
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_TurbineProvider.java b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_TurbineProvider.java
new file mode 100644
index 0000000000..d9e2692b09
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_TurbineProvider.java
@@ -0,0 +1,212 @@
+package gtPlusPlus.xmod.gregtech.api.metatileentity.implementations;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.items.GT_MetaGenerated_Tool;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBus;
+import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeTurbine;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.minecraft.PlayerUtils;
+import gtPlusPlus.core.util.sys.KeyboardUtils;
+import gtPlusPlus.xmod.gregtech.api.gui.hatches.CONTAINER_1by1_Turbine;
+import gtPlusPlus.xmod.gregtech.api.gui.hatches.GUI_1by1_Turbine;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import net.minecraft.world.chunk.Chunk;
+
+public class GT_MetaTileEntity_Hatch_TurbineProvider extends GT_MetaTileEntity_Hatch_InputBus {
+
+	public GT_MetaTileEntity_Hatch_TurbineProvider(int aID, String aName, String aNameRegional, int aTier) {
+		super(aID, aName, aNameRegional, aTier);
+	}
+	
+	public GT_MetaTileEntity_Hatch_TurbineProvider(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
+		super(aName, aTier, aDescription, aTextures);
+	}
+	
+	public GT_MetaTileEntity_Hatch_TurbineProvider(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+		super(aName, aTier, aDescription, aTextures);
+	}
+
+	public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new GT_MetaTileEntity_Hatch_TurbineProvider(this.mName, this.mTier, this.mDescriptionArray, this.mTextures);
+	}
+	
+	public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+		return new CONTAINER_1by1_Turbine(aPlayerInventory, aBaseMetaTileEntity);
+	}
+
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+		return new GUI_1by1_Turbine(aPlayerInventory, aBaseMetaTileEntity, "Turbine Housing");		
+	}
+	
+	@Override
+	public String[] getDescription() {					
+		return new String[]{				
+				"An automation port for Large Turbines", "Will attempt once per 1200 ticks to fill the turbine slot of it's parent turbine", "You may adjust this with a screwdriver", "Hold shift to adjust in finer amounts", "Hold control to adjust direction", "Left Click with Screwdriver to reset", "This module assumes the entire turbine is in the same Chunk"};
+	}
+	
+	
+	private GT_MetaTileEntity_LargeTurbine mParent = null;
+
+	public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTimer) {
+		super.onPostTick(aBaseMetaTileEntity, aTimer);
+		if (aTimer % mRefreshTime == 0 && this.getBaseMetaTileEntity().isServerSide()) {
+			tryRefillTurbine();
+		}
+	}
+
+	private final void tryFindParentTurbine() {
+		Logger.INFO("This turbine housing has no parent, searching world.");
+		IGregTechTileEntity T = this.getBaseMetaTileEntity();
+		World W = T.getWorld();
+		Chunk C = W.getChunkFromBlockCoords(T.getXCoord(), T.getZCoord());
+		for (Object o : C.chunkTileEntityMap.values()) {			
+			if (o instanceof IGregTechTileEntity) {
+				IGregTechTileEntity G = (IGregTechTileEntity) o;
+				final IMetaTileEntity aMetaTileEntity = G.getMetaTileEntity();
+				if (aMetaTileEntity == null) {
+					continue;
+				}		
+				if (aMetaTileEntity instanceof GT_MetaTileEntity_LargeTurbine) {
+					GT_MetaTileEntity_LargeTurbine aTurb = (GT_MetaTileEntity_LargeTurbine) aMetaTileEntity;
+					for (GT_MetaTileEntity_Hatch_InputBus ee : aTurb.mInputBusses) {
+						if (ee.equals(this)) {
+							mParent = aTurb;
+							Logger.INFO("Found a Parent to attach to this housing.");
+							return;
+						}
+					}
+				}
+			}			
+		}		
+	}
+	
+	private final void tryRefillTurbine() {
+		if (mParent == null) {
+			tryFindParentTurbine();			
+		}
+		if (mParent != null && mParent.mInventory[1] == null) {
+			for (ItemStack aStack : this.mInventory) {					
+				if (isItemStackTurbine(aStack)) {
+					setGUIItemStack(aStack);	
+				}
+			}	
+		}
+	}
+	
+	protected boolean setGUIItemStack(ItemStack aNewGuiSlotContents) {
+		boolean result = false;
+		if (mParent.mInventory[1] == null) {
+			mParent.mInventory[1] = aNewGuiSlotContents != null ? aNewGuiSlotContents.copy() : null;
+			mParent.depleteInput(aNewGuiSlotContents);
+			mParent.updateSlots();
+			this.updateSlots();
+			result = true;
+		}	
+		return result;
+	}
+
+	public boolean isItemStackTurbine(ItemStack aStack) {
+		if (aStack.getItem() instanceof GT_MetaGenerated_Tool) {
+			if (aStack.getItemDamage() >= 170 && aStack.getItemDamage() <= 176) {
+				return true;						
+			}    			
+		}
+		return false;
+	}
+
+	public boolean isItemStackScrewdriver(ItemStack aStack) {
+		if (aStack.getItem() instanceof GT_MetaGenerated_Tool) {
+			if (aStack.getItemDamage() == 22 || aStack.getItemDamage() == 150) {
+				return true;						
+			}    			
+		}
+		return false;
+	}
+	
+	
+	@Override
+	public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+		return false;
+	}
+
+	@Override
+	public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+		return isItemStackTurbine(aStack);
+	}
+	
+	private int mRefreshTime = 1200;
+	private boolean mDescending = true;
+
+	@Override
+	public void saveNBTData(NBTTagCompound aNBT) {
+		super.saveNBTData(aNBT);
+		aNBT.setInteger("mRefreshTime", mRefreshTime);
+		aNBT.setBoolean("mDescending", mDescending);
+	}
+
+	@Override
+	public void loadNBTData(NBTTagCompound aNBT) {
+		super.loadNBTData(aNBT);
+		mRefreshTime = aNBT.getInteger("mRefreshTime");
+		mDescending = aNBT.getBoolean("mDescending");
+	}
+
+	@Override
+	public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+		if (aPlayer != null) {
+			if (KeyboardUtils.isCtrlKeyDown()) {
+				mDescending = Utils.invertBoolean(mDescending);
+				PlayerUtils.messagePlayer(aPlayer, "Direction: "+(mDescending ? "DOWN" : "UP"));
+			}
+			else {
+				int aAmount = 0;
+				if (KeyboardUtils.isShiftKeyDown()) {
+					aAmount = 10;
+				}
+				else {
+					aAmount = 100;
+				}
+				if (mDescending) {
+					mRefreshTime -= aAmount;
+					if (mRefreshTime < 0) {
+						mRefreshTime = 1200;
+					}
+				}
+				else {
+					mRefreshTime += aAmount;
+					if (mRefreshTime > 1200) {
+						mRefreshTime = 0;
+					}					
+				}
+				PlayerUtils.messagePlayer(aPlayer, "Set check time to be every "+mRefreshTime+" ticks.");
+			}			
+		}		
+	}
+
+	@Override
+	public void onLeftclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+		boolean aDidScrewdriver = false;
+		if (aPlayer != null) {
+			if (aPlayer.getHeldItem() != null) {
+				if (isItemStackScrewdriver(aPlayer.getHeldItem())) {
+					aDidScrewdriver = true;
+					mRefreshTime = 1200;
+					PlayerUtils.messagePlayer(aPlayer, "Reset check time to "+mRefreshTime+" ticks.");
+				}
+			}
+		}
+		if (!aDidScrewdriver) {
+			super.onLeftclick(aBaseMetaTileEntity, aPlayer);
+		}
+	}
+	
+
+}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_SuperBus_Output.java b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_SuperBus_Output.java
index 3afa3312b1..cca5a39de3 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_SuperBus_Output.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_SuperBus_Output.java
@@ -58,7 +58,7 @@ public class GT_MetaTileEntity_SuperBus_Output extends GT_MetaTileEntity_Hatch_O
 		if (aBaseMetaTileEntity.isServerSide() && aBaseMetaTileEntity.hasInventoryBeenModified()) {
 			this.fillStacksIntoFirstSlots();
 		}
-
+        super.onPostTick(aBaseMetaTileEntity, aTimer);
 	}
 
 	public void updateSlots() {
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMeta_MultiBlockBase.java b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMeta_MultiBlockBase.java
index 68b81182fc..3c3345d130 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMeta_MultiBlockBase.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMeta_MultiBlockBase.java
@@ -42,6 +42,11 @@ import gtPlusPlus.GTplusplus;
 import gtPlusPlus.GTplusplus.INIT_PHASE;
 import gtPlusPlus.api.objects.Logger;
 import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.api.objects.data.ConcurrentHashSet;
+import gtPlusPlus.api.objects.data.ConcurrentSet;
+import gtPlusPlus.api.objects.data.FlexiblePair;
+import gtPlusPlus.api.objects.data.Pair;
+import gtPlusPlus.api.objects.data.Triplet;
 import gtPlusPlus.api.objects.minecraft.BlockPos;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.lib.LoadedMods;
@@ -49,6 +54,7 @@ import gtPlusPlus.core.recipe.common.CI;
 import gtPlusPlus.core.util.math.MathUtils;
 import gtPlusPlus.core.util.minecraft.ItemUtils;
 import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import gtPlusPlus.preloader.asm.AsmConfig;
 import gtPlusPlus.xmod.gregtech.api.gui.CONTAINER_MultiMachine;
 import gtPlusPlus.xmod.gregtech.api.gui.CONTAINER_MultiMachine_NoPlayerInventory;
 import gtPlusPlus.xmod.gregtech.api.gui.GUI_MultiMachine;
@@ -59,6 +65,7 @@ import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEn
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBattery;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_OutputBattery;
 import gtPlusPlus.xmod.gregtech.api.objects.MultiblockRequirements;
+
 import net.minecraft.block.Block;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.InventoryPlayer;
@@ -92,12 +99,12 @@ GT_MetaTileEntity_MultiBlockBase {
 		else {
 			aLogger = ReflectionUtils.getMethod(Logger.class, "MACHINE_INFO", String.class);				
 		}
-		
+
 		try {
 			calculatePollutionReduction = GT_MetaTileEntity_Hatch_Muffler.class.getDeclaredMethod("calculatePollutionReduction", int.class);
 		} catch (NoSuchMethodException | SecurityException e) {}
-		
-		
+
+
 		//gregtech.api.util.GT_Recipe.GT_Recipe_Map.findRecipe(IHasWorldObjectAndCoords, GT_Recipe, boolean, long, FluidStack[], ItemStack, ItemStack...)
 
 	}
@@ -135,7 +142,7 @@ GT_MetaTileEntity_MultiBlockBase {
 	}
 
 	public abstract boolean hasSlotInGUI();
-	
+
 	public long getTotalRuntimeInTicks() {
 		return this.mTotalRunTime;
 	}
@@ -276,7 +283,7 @@ GT_MetaTileEntity_MultiBlockBase {
 
 
 	}
-	
+
 	public int getPollutionReductionForAllMufflers() {
 		int mPollutionReduction=0;
 		for (GT_MetaTileEntity_Hatch_Muffler tHatch : mMufflerHatches) {
@@ -286,7 +293,7 @@ GT_MetaTileEntity_MultiBlockBase {
 		}
 		return mPollutionReduction;
 	}
-	
+
 	public long getStoredEnergyInAllEnergyHatches() {
 		long storedEnergy=0;
 		for(GT_MetaTileEntity_Hatch_Energy tHatch : mEnergyHatches) {
@@ -296,7 +303,7 @@ GT_MetaTileEntity_MultiBlockBase {
 		}
 		return storedEnergy;
 	}
-	
+
 	public long getMaxEnergyStorageOfAllEnergyHatches() {
 		long maxEnergy=0;
 		for(GT_MetaTileEntity_Hatch_Energy tHatch : mEnergyHatches) {
@@ -408,7 +415,7 @@ GT_MetaTileEntity_MultiBlockBase {
 		String[] aToolTip = new String[(a2 + a3)];
 		aToolTip = ArrayUtils.addAll(aToolTip, x);
 		aToolTip = ArrayUtils.addAll(aToolTip, z);
-		
+
 		if (aCachedToolTip == null || aCachedToolTip.length <= 0) {
 			aCachedToolTip = aToolTip;			
 		}		
@@ -465,66 +472,300 @@ GT_MetaTileEntity_MultiBlockBase {
 	public String getSound() { return ""; }
 
 	public boolean canBufferOutputs(final GT_Recipe aRecipe, int aParallelRecipes) {
-		if (aRecipe.mOutputs.length > 16) {
-			// Gendustry custom comb with a billion centrifuge outputs? Do it anyway.
-			return true;
-		}
 
-		// Count slots available in output buses
-		ArrayList<ItemStack> tBusStacks = new ArrayList<>();
+		Logger.INFO("Determining if we have space to buffer outputs. Parallel: "+aParallelRecipes);
 
-		int tEmptySlots = 0;
-		for (final GT_MetaTileEntity_Hatch_OutputBus tBus : this.mOutputBusses) {
-			if (!isValidMetaTileEntity(tBus)) {
-				continue;
+		// Null recipe or a recipe with lots of outputs? 
+		// E.G. Gendustry custom comb with a billion centrifuge outputs? 
+		// Do it anyway.
+		if (aRecipe == null || aRecipe.mOutputs.length > 16) {
+			return aRecipe == null ? false : true;
+		}		
+
+		// Do we even need to check for item outputs?
+		boolean aDoesOutputItems = aRecipe.mOutputs.length > 0;
+		// Do we even need to check for fluid outputs?
+		boolean aDoesOutputFluids = aRecipe.mFluidOutputs.length > 0;
+
+
+
+		/* ========================================
+		 * Item Management
+		 * ========================================
+		 */
+
+		if (aDoesOutputItems) {
+			Logger.INFO("We have items to output.");
+
+			// How many slots are free across all the output buses?
+			int aInputBusSlotsFree = 0;		
+
+			/*
+			 * Create Variables for Item Output 
+			 */
+
+			AutoMap<FlexiblePair<ItemStack, Integer>> aItemMap = new AutoMap<FlexiblePair<ItemStack, Integer>>();
+			AutoMap<ItemStack> aOutputs = new AutoMap<ItemStack>(aRecipe.mOutputs);
+
+			for (final GT_MetaTileEntity_Hatch_OutputBus tBus : this.mOutputBusses) {
+				if (!isValidMetaTileEntity(tBus)) {
+					continue;
+				}
+				final IInventory tBusInv = tBus.getBaseMetaTileEntity();
+				for (int i = 0; i < tBusInv.getSizeInventory(); i++) {
+					if (tBus.getStackInSlot(i) == null) {
+						aInputBusSlotsFree++;
+					}
+					else {
+						ItemStack aT = tBus.getStackInSlot(i);
+						int aSize = aT.stackSize;
+						aT = aT.copy();
+						aT.stackSize = 0;
+						aItemMap.put(new FlexiblePair<ItemStack, Integer>(aT, aSize));
+					}
+				}		
 			}
-			final IInventory tBusInv = tBus.getBaseMetaTileEntity();
-			for (int i = 0; i < tBusInv.getSizeInventory(); i++) {
-				if (tBus.getStackInSlot(i) == null) {
-					tEmptySlots++;
+
+			// Count the slots we need, later we can check if any are able to merge with existing stacks
+			int aRecipeSlotsRequired = 0;		
+
+			// A map to hold the items we will be 'inputting' into the output buses. These itemstacks are actually the recipe outputs.
+			ConcurrentSet<FlexiblePair<ItemStack, Integer>> aInputMap = new ConcurrentHashSet<FlexiblePair<ItemStack, Integer>>();
+
+			// Iterate over the outputs, calculating require stack spacing they will require.
+			for (int i=0;i<aOutputs.size();i++) {
+				ItemStack aY = aOutputs.get(i);
+				if (aY == null) {
+					continue;
 				}
 				else {
-					tBusStacks.add(tBus.getStackInSlot(i));
-				}
+					int aStackSize = aY.stackSize * aParallelRecipes;
+					if (aStackSize > 64) {
+						int aSlotsNeedsForThisStack = (int) Math.ceil((double) ((float) aStackSize / 64f)); 
+						// Should round up and add as many stacks as required nicely.
+						aRecipeSlotsRequired += aSlotsNeedsForThisStack;					
+						for (int o=0;o<aRecipeSlotsRequired;o++) {
+							int aStackToRemove = (aStackSize -= 64) > 64 ? 64 : aStackSize;		
+							aY = aY.copy();
+							aY.stackSize = 0;
+							aInputMap.add(new FlexiblePair<ItemStack, Integer>(aY, aStackToRemove));
+						}					
+					}
+					else {
+						// Only requires one slot
+						aRecipeSlotsRequired++;
+						aY = aY.copy();
+						aY.stackSize = 0;
+						aInputMap.add(new FlexiblePair<ItemStack, Integer>(aY, aStackSize));
+					}	
+				}			
+			}
+
+			// We have items to add to the output buses. See if any are not full stacks and see if we can make them full.
+			if (aInputMap.size() > 0) {
+				// Iterate over the current stored items in the Output busses, if any match and are not full, we can try account for merging.
+				busItems: for (FlexiblePair<ItemStack, Integer> y : aItemMap) {
+					// Iterate over the 'inputs', we can safely remove these as we go.
+					outputItems: for (FlexiblePair<ItemStack, Integer> u : aInputMap) {
+						// Create local vars for readability.
+						ItemStack aOutputBusStack = y.getKey();
+						ItemStack aOutputStack = u.getKey();
+						// Stacks match, including NBT.
+						if (GT_Utility.areStacksEqual(aOutputBusStack, aOutputStack, false)) {							
+							// Stack Matches, but it's full, continue.
+							if (aOutputBusStack.stackSize >= 64) {
+								// This stack is full, no point checking it.
+								continue busItems;
+							}
+							else {
+								// We can merge these two stacks without any hassle.
+								if ((aOutputBusStack.stackSize + aOutputStack.stackSize) <= 64) {							
+									// Update the stack size in the bus storage map.
+									y.setValue(aOutputBusStack.stackSize + aOutputStack.stackSize);							
+									// Remove the 'input' stack from the recipe outputs, so we don't try count it again.
+									aInputMap.remove(u);
+									continue outputItems;
+								}
+								// Stack merging is too much, so we fill this stack, leave the remainder.
+								else {
+									int aRemainder = (aOutputBusStack.stackSize + aOutputStack.stackSize) - 64;									
+									// Update the stack size in the bus storage map.
+									y.setValue(64);									
+									// Create a new object to iterate over later, with the remainder data;
+									FlexiblePair<ItemStack, Integer> t = new FlexiblePair<ItemStack, Integer>(u.getKey(), aRemainder);									
+									// Remove the 'input' stack from the recipe outputs, so we don't try count it again.
+									aInputMap.remove(u);
+									// Add the remainder stack.
+									aInputMap.add(t);
+									continue outputItems;									
+								}
+							}							
+						}
+						else {
+							continue outputItems;
+						}
+					}
+				}		
 			}
+
+			// We have stacks that did not merge, do we have space for them?
+			if (aInputMap.size() > 0) {			
+				if (aInputMap.size() > aInputBusSlotsFree) {
+					// We do not have enough free slots in total to accommodate the remaining managed stacks.
+					Logger.INFO("Failed to find enough space for all item outputs. Free: "+aInputBusSlotsFree+", Required: "+aInputMap.size());
+					return false;
+				}			
+			}			
+
+			/*
+			 * End Item Management
+			 */
+
 		}
 
-		int slotsNeeded = aRecipe.mOutputs.length;
-		for (final ItemStack tRecipeOutput: aRecipe.mOutputs) {
-			if (tRecipeOutput == null) continue;
-			int amount = tRecipeOutput.stackSize * aParallelRecipes;
-			for (final ItemStack tBusStack : tBusStacks) {
-				if (GT_Utility.areStacksEqual(tBusStack, tRecipeOutput)) {
-					if (tBusStack.stackSize + amount <= tBusStack.getMaxStackSize()) {
-						slotsNeeded--;
-						break;
-					}
+
+
+
+
+		/* ========================================
+		 * Fluid Management
+		 * ========================================
+		 */
+
+
+
+		if (aDoesOutputFluids) {
+			Logger.INFO("We have Fluids to output.");
+			// How many slots are free across all the output buses?
+			int aFluidHatches = 0;
+			int aEmptyFluidHatches = 0;
+			int aFullFluidHatches = 0;
+			// Create Map for Fluid Output 
+			ConcurrentHashSet<Triplet<GT_MetaTileEntity_Hatch_Output, FluidStack, Integer>> aOutputHatches = new ConcurrentHashSet<Triplet<GT_MetaTileEntity_Hatch_Output, FluidStack, Integer>>();
+			for (final GT_MetaTileEntity_Hatch_Output tBus : this.mOutputHatches) {
+				if (!isValidMetaTileEntity(tBus)) {
+					continue;
+				}
+				aFluidHatches++;			
+				// Map the Hatch with the space left for easy checking later.
+				if (tBus.getFluid() == null) {
+					aOutputHatches.add(new Triplet<GT_MetaTileEntity_Hatch_Output, FluidStack, Integer>(tBus, null, tBus.getCapacity()));
+				}
+				else {				
+					int aSpaceLeft = tBus.getCapacity() - tBus.getFluidAmount();				
+					aOutputHatches.add(new Triplet<GT_MetaTileEntity_Hatch_Output, FluidStack, Integer>(tBus, tBus.getFluid(), aSpaceLeft));				
 				}
 			}
-		}
-		// Enough open slots?
-		if (tEmptySlots < slotsNeeded) return false;
-
-		// For each output fluid, make sure an output hatch can accept it.
-		for (FluidStack tRecipeFluid: aRecipe.mFluidOutputs) {
-			if (tRecipeFluid == null) continue;
-			boolean tCanBufferFluid = false;
-			int tRecipeAmount = tRecipeFluid.amount;
-			for (final GT_MetaTileEntity_Hatch_Output tHatch : this.mOutputHatches) {
-				FluidStack tHatchFluid = tHatch.getFluid();
-				if (tHatchFluid == null) {
-					if(tHatch.getCapacity() > tRecipeAmount) {
-						tCanBufferFluid = true;
-						break;
-					}
+			// Create a map of all the fluids we would like to output, we can iterate over this and see how many we can merge into existing hatch stacks.
+			ConcurrentHashSet<FluidStack> aOutputFluids = new ConcurrentHashSet<FluidStack>();
+			// Ugly ass boxing
+			aOutputFluids.addAll(new AutoMap<FluidStack>(aRecipe.mFluidOutputs));
+			// Iterate the Hatches, updating their 'stored' data.
+			aHatchIterator: for (Triplet<GT_MetaTileEntity_Hatch_Output, FluidStack, Integer> aHatchData : aOutputHatches) {
+				// The Hatch Itself
+				GT_MetaTileEntity_Hatch_Output aHatch = aHatchData.getValue_1();
+				// Fluid in the Hatch
+				FluidStack aHatchStack = aHatchData.getValue_2();
+				// Space left in Hatch
+				int aSpaceLeftInHatch = aHatch.getCapacity() - aHatch.getFluidAmount();				
+				// Hatch is full,
+				if (aSpaceLeftInHatch <= 0) {
+					aFullFluidHatches++;
+					aOutputHatches.remove(aHatchData);
+					continue aHatchIterator;
 				}
-				else if (tHatchFluid.isFluidEqual(tRecipeFluid) && tHatch.getCapacity() - tHatchFluid.amount > tRecipeAmount) {
-					tCanBufferFluid = true;
-					break;
+				// Hatch has space
+				else {					
+					// Check if any fluids match
+					aFluidMatch: for (FluidStack aOutputStack : aOutputFluids) {
+						if (GT_Utility.areFluidsEqual(aHatchStack, aOutputStack)) {
+							int aFluidToPutIntoHatch = aOutputStack.amount;
+							// Not Enough space to insert all of the fluid.
+							// We fill this hatch and add a smaller Fluidstack back to the iterator.
+							if (aSpaceLeftInHatch < aFluidToPutIntoHatch) {								
+								// Copy existing Hatch Stack
+								FluidStack aNewHatchStack = aHatchStack.copy();
+								aNewHatchStack.amount = 0;
+								// Copy existing Hatch Stack again
+								FluidStack aNewOutputStack = aHatchStack.copy();
+								aNewOutputStack.amount = 0;								
+								// How much fluid do we have left after we fill the hatch?
+								int aFluidLeftAfterInsert = aFluidToPutIntoHatch - aSpaceLeftInHatch;								
+								// Set new stacks to appropriate values
+								aNewHatchStack.amount = aHatch.getCapacity();
+								aNewOutputStack.amount = aFluidLeftAfterInsert;								
+								// Remove fluid from output list, merge success
+								aOutputFluids.remove(aOutputStack);								
+								// Remove hatch from hatch list, data is now invalid.
+								aOutputHatches.remove(aHatchData);								
+								// Add remaining Fluid to Output list
+								aOutputFluids.add(aNewOutputStack);								
+								// Re-add hatch to hatch list, with new data.
+								Triplet<GT_MetaTileEntity_Hatch_Output, FluidStack, Integer> aNewHatchData = new Triplet<GT_MetaTileEntity_Hatch_Output, FluidStack, Integer>(aHatch, aNewHatchStack, aNewHatchStack.amount);
+								aOutputHatches.add(aNewHatchData);								
+								continue aHatchIterator;								
+							}
+							// We can fill this hatch perfectly (rare case), may as well add it directly to the full list.
+							else if (aSpaceLeftInHatch == aFluidToPutIntoHatch) {
+								// Copy Old Stack
+								FluidStack aNewHatchStack = aHatchStack.copy();
+								// Add in amount from output stack
+								aNewHatchStack.amount += aOutputStack.amount;
+								// Remove fluid from output list, merge success
+								aOutputFluids.remove(aOutputStack);
+								// Remove hatch from hatch list, data is now invalid.
+								aOutputHatches.remove(aHatchData);
+								// Re-add hatch to hatch list, with new data.
+								Triplet<GT_MetaTileEntity_Hatch_Output, FluidStack, Integer> aNewHatchData = new Triplet<GT_MetaTileEntity_Hatch_Output, FluidStack, Integer>(aHatch, aNewHatchStack, aNewHatchStack.amount);
+								aOutputHatches.add(aNewHatchData);
+								continue aHatchIterator;
+							}
+							// We have more space than we need to merge, so we remove the stack from the output list and update the hatch list.
+							else {		
+								// Copy Old Stack
+								FluidStack aNewHatchStack = aHatchStack.copy();
+								// Add in amount from output stack
+								aNewHatchStack.amount += aOutputStack.amount;
+								// Remove fluid from output list, merge success
+								aOutputFluids.remove(aOutputStack);
+								// Remove hatch from hatch list, data is now invalid.
+								aOutputHatches.remove(aHatchData);
+								// Re-add hatch to hatch list, with new data.
+								Triplet<GT_MetaTileEntity_Hatch_Output, FluidStack, Integer> aNewHatchData = new Triplet<GT_MetaTileEntity_Hatch_Output, FluidStack, Integer>(aHatch, aNewHatchStack, aNewHatchStack.amount);
+								aOutputHatches.add(aNewHatchData);
+								// Check next fluid
+								continue aFluidMatch;
+							}
+
+						}
+						else {
+							continue aFluidMatch;
+						}
+					}					
+				}
+			}
+
+			for (Triplet<GT_MetaTileEntity_Hatch_Output, FluidStack, Integer> aFreeHatchCheck : aOutputHatches) {
+				// Free Hatch
+				if (aFreeHatchCheck.getValue_2() == null || aFreeHatchCheck.getValue_3() == 0 || aFreeHatchCheck.getValue_1().getFluid() == null) {
+					aEmptyFluidHatches++;
+				}
+			}
+
+			// We have Fluid Stacks we did not merge. Do we have space?
+			if (aOutputFluids.size() > 0) {
+				// Not enough space to add fluids.
+				if (aOutputFluids.size() < aEmptyFluidHatches) {
+					Logger.INFO("Failed to find enough space for all fluid outputs.");
+					return false;
 				}
 			}
-			if (!tCanBufferFluid) return false;
+
+			/*
+			 * End Fluid Management
+			 */			
 		}
+
 		return true;
 	}
 
@@ -534,20 +775,17 @@ GT_MetaTileEntity_MultiBlockBase {
 	public static Method aLogger = null;
 
 	public void log(String s) {
-
-		boolean isDebugLogging = CORE.DEBUG;
-		boolean reset = false;
-
-		if (reset) {
-			if (isDebugLogging) {
+		boolean reset = true;
+		if (reset || aLogger == null) {
+			if (!AsmConfig.disableAllLogging) {
 				aLogger = ReflectionUtils.getMethod(
 						Logger.class, "INFO", String.class
-				);
+						);
 			}
 			else {
 				aLogger = ReflectionUtils.getMethod(
 						Logger.class, "MACHINE_INFO", String.class
-				);
+						);
 			}
 		}
 		try {
@@ -555,6 +793,7 @@ GT_MetaTileEntity_MultiBlockBase {
 		}
 		catch (IllegalAccessException | IllegalArgumentException
 				| InvocationTargetException e) {
+			e.printStackTrace();
 		}
 
 	}
@@ -739,8 +978,7 @@ GT_MetaTileEntity_MultiBlockBase {
 			ItemStack[] aItemInputs, FluidStack[] aFluidInputs,
 			int aMaxParallelRecipes, int aEUPercent,
 			int aSpeedBonusPercent, int aOutputChanceRoll, GT_Recipe aRecipe) {
-		// Based on the Processing Array. A bit overkill, but very flexible.	
-
+		// Based on the Processing Array. A bit overkill, but very flexible.		
 
 		// Reset outputs and progress stats
 		this.mEUt = 0;
@@ -800,6 +1038,7 @@ GT_MetaTileEntity_MultiBlockBase {
 		// -- Try not to fail after this point - inputs have already been consumed! --
 
 
+
 		// Convert speed bonus to duration multiplier
 		// e.g. 100% speed bonus = 200% speed = 100%/200% = 50% recipe duration.
 		aSpeedBonusPercent = Math.max(-99, aSpeedBonusPercent);
@@ -1315,7 +1554,7 @@ GT_MetaTileEntity_MultiBlockBase {
 		boolean result = false;
 		if (this.mInventory[1] == null) {
 			this.mInventory[1] = aNewGuiSlotContents != null ? aNewGuiSlotContents.copy() : null;
-			aNewGuiSlotContents = null;
+			this.depleteInput(aNewGuiSlotContents);
 			this.updateSlots();
 			result = true;
 		}	
@@ -1383,36 +1622,36 @@ GT_MetaTileEntity_MultiBlockBase {
 	public boolean causeMaintenanceIssue() {
 		boolean b = false;
 		switch (this.getBaseMetaTileEntity().getRandomNumber(6)) {
-		case 0 : {
-			this.mWrench = false;
-			b = true;
-			break;
-		}
-		case 1 : {
-			this.mScrewdriver = false;
-			b = true;
-			break;
-		}
-		case 2 : {
-			this.mSoftHammer = false;
-			b = true;
-			break;
-		}
-		case 3 : {
-			this.mHardHammer = false;
-			b = true;
-			break;
-		}
-		case 4 : {
-			this.mSolderingTool = false;
-			b = true;
-			break;
-		}
-		case 5 : {
-			this.mCrowbar = false;
-			b = true;
-			break;
-		}
+			case 0 : {
+				this.mWrench = false;
+				b = true;
+				break;
+			}
+			case 1 : {
+				this.mScrewdriver = false;
+				b = true;
+				break;
+			}
+			case 2 : {
+				this.mSoftHammer = false;
+				b = true;
+				break;
+			}
+			case 3 : {
+				this.mHardHammer = false;
+				b = true;
+				break;
+			}
+			case 4 : {
+				this.mSolderingTool = false;
+				b = true;
+				break;
+			}
+			case 5 : {
+				this.mCrowbar = false;
+				b = true;
+				break;
+			}
 		}
 		return b;
 	}
@@ -1849,7 +2088,7 @@ GT_MetaTileEntity_MultiBlockBase {
 
 	@SuppressWarnings("rawtypes")
 	public boolean isThisHatchMultiDynamo(Object aMetaTileEntity){
-		Class mDynamoClass;
+		Class<?> mDynamoClass;
 		mDynamoClass = ReflectionUtils.getClass("com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DynamoMulti");
 		if (mDynamoClass != null){
 			if (mDynamoClass.isInstance(aMetaTileEntity)){
@@ -1894,7 +2133,7 @@ GT_MetaTileEntity_MultiBlockBase {
 			try {
 				return (int) calculatePollutionReduction.invoke(i, g);
 			} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
-				
+
 			}
 		}
 		return 0;