Merge pull request #19 from GTNewHorizons/experimental

update

14 files changed, 1886 insertions, 912 deletions

diff --git a/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_ItemDistributor.java b/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_ItemDistributor.java
index 5fa3bc8c82..37d8585310 100644
--- a/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_ItemDistributor.java
+++ b/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_ItemDistributor.java
@@ -143,7 +143,6 @@ public class GT_MetaTileEntity_ItemDistributor extends GT_MetaTileEntity_Buffer
         }
         if (movedItems > 0 || aBaseMetaTileEntity.hasInventoryBeenModified()) {
             mSuccess = 50;
-            aBaseMetaTileEntity.decreaseStoredEnergyUnits(Math.abs(movedItems), true);
         }
         fillStacksIntoFirstSlots();
     }
diff --git a/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Regulator.java b/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Regulator.java
index b5a33bfb81..746e182066 100644
--- a/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Regulator.java
+++ b/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Regulator.java
@@ -95,7 +95,6 @@ public class GT_MetaTileEntity_Regulator
                 tCosts = GT_Utility.moveOneItemStackIntoSlot(getBaseMetaTileEntity(), getBaseMetaTileEntity().getTileEntityAtSide(getBaseMetaTileEntity().getBackFacing()), getBaseMetaTileEntity().getBackFacing(), this.mTargetSlots[i], Arrays.asList(new ItemStack[]{this.mInventory[(i + 9)]}), false, (byte) this.mInventory[(i + 9)].stackSize, (byte) this.mInventory[(i + 9)].stackSize, (byte) 64, (byte) 1) * 3;
                 if (tCosts > 0) {
                     this.mSuccess = 50;
-                    getBaseMetaTileEntity().decreaseStoredEnergyUnits(tCosts, true);
                     break;
                 }
             }
diff --git a/src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_Steel.java b/src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_Steel.java
index f697b75f0f..d7671e860c 100644
--- a/src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_Steel.java
+++ b/src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_Steel.java
@@ -8,8 +8,7 @@ import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicHull_NonElectric;
 import gregtech.api.objects.GT_RenderedTexture;
 
-public class GT_MetaTileEntity_BasicHull_Steel
-        extends GT_MetaTileEntity_BasicHull_NonElectric {
+public class GT_MetaTileEntity_BasicHull_Steel extends GT_MetaTileEntity_BasicHull_NonElectric {
     public GT_MetaTileEntity_BasicHull_Steel(int aID, String aName, String aNameRegional, int aTier, String aDescription) {
         super(aID, aName, aNameRegional, aTier, aDescription);
     }
diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Disassembler.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Disassembler.java
index ce1812a9cf..92ed054b05 100644
--- a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Disassembler.java
+++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Disassembler.java
@@ -1,15 +1,34 @@
 package gregtech.common.tileentities.machines.basic;
 
-import gregtech.api.enums.GT_Values;
+import com.google.common.collect.ArrayListMultimap;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
 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.items.GT_MetaGenerated_Tool;
 import gregtech.api.metatileentity.MetaTileEntity;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_TieredMachineBlock;
+import gregtech.api.objects.GT_ItemStack;
 import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.objects.ItemData;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
 import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.oredict.OreDictionary;
+
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 public class GT_MetaTileEntity_Disassembler
         extends GT_MetaTileEntity_BasicMachine {
@@ -29,79 +48,380 @@ public class GT_MetaTileEntity_Disassembler
         return new GT_MetaTileEntity_Disassembler(this.mName, this.mTier, this.mDescriptionArray, this.mTextures, this.mGUIName, this.mNEIName);
     }
 
+    private static final ItemStack[][] alwaysReplace = new ItemStack[][]{
+            {
+                //ItemStack to look for
+                new ItemStack(Blocks.trapped_chest, 1, OreDictionary.WILDCARD_VALUE)
+            },
+            {
+                //ItemStack to replace
+                new ItemStack(Blocks.chest)
+            }
+    };
+
+    private static final Object[][] OreDictionaryOverride = new Object[][]{
+            {
+                    //String to look for
+                    "plankWood",
+                    "stoneCobble",
+                    "gemDiamond",
+                    "logWood",
+                    "stickWood",
+                    "treeSapling"
+            },
+            {
+                    //ItemStack to replace
+                    new ItemStack(Blocks.planks),
+                    new ItemStack(Blocks.cobblestone),
+                    new ItemStack(Items.diamond),
+                    new ItemStack(Blocks.log),
+                    new ItemStack(Items.stick),
+                    new ItemStack(Blocks.sapling)
+            }
+    };
+
+    public static ArrayListMultimap<GT_ItemStack, ItemStack> getOutputHardOverrides() {
+        return outputHardOverrides;
+    }
+
+    private static final ArrayListMultimap<GT_ItemStack, ItemStack> outputHardOverrides;
+
+    static {
+        outputHardOverrides = ArrayListMultimap.create();
+        outputHardOverrides.put(new GT_ItemStack(new ItemStack(Blocks.torch,6)), new ItemStack(Items.stick));
+    }
+
     public int checkRecipe() {
-        //if ((getInputAt(0) != null) && (isOutputEmpty())) {
-        //	if(GT_Utility.areStacksEqual(getInputAt(0), new ItemStack(Items.egg))){
-        //		getInputAt(0).stackSize -= 1;
-          //      this.mEUt = (16 * (1 << this.mTier - 1) * (1 << this.mTier - 1));
-            //    this.mMaxProgresstime = 2400;
-              //  this.mMaxProgresstime = this.mMaxProgresstime >> (mTier);
-                //if (getBaseMetaTileEntity().getRandomNumber(100) < (this.mTier+1)) {
-                  //  this.mOutputItems[0] = ItemList.Circuit_Chip_Stemcell.get(1, new Object[0]);
-                    //}
-        		//return 2;
-        	//}
-            NBTTagCompound tNBT = getInputAt(0).getTagCompound();
-            if (tNBT != null) {
-                tNBT = tNBT.getCompoundTag("GT.CraftingComponents");
-                if (tNBT != null) {
-                    boolean isAnyOutput=false;
-                    calculateOverclockedNessDisassembler(16);
-                    this.mMaxProgresstime = 80;
-                    //In case recipe is too OP for that machine
-                    if (mEUt == Integer.MAX_VALUE - 1)//&& mMaxProgresstime==Integer.MAX_VALUE-1
-                        return FOUND_RECIPE_BUT_DID_NOT_MEET_REQUIREMENTS;
-                    for (int i = 0; i < this.mOutputItems.length; i++) {
-                        if (getBaseMetaTileEntity().getRandomNumber(100) < 50 + 10 * this.mTier) {
-                            this.mOutputItems[i] = GT_Utility.loadItem(tNBT, "Ingredient." + i);
-                            if (this.mOutputItems[i] != null) {
-                                this.mMaxProgresstime *= 1.7F;
-                                isAnyOutput=true;
-                            }
-                        }
-                    }
-                    if(!isAnyOutput)
-                    	return DID_NOT_FIND_RECIPE;
-                    for(int i=mTier-5;i>0;i--){
-                        this.mMaxProgresstime>>=1;
-                        if(this.mMaxProgresstime==0)
-                            this.mEUt = this.mEUt>>1;
-                    }
-                    if(this.mEUt==0)
-                        mEUt = 1;
-                    if(this.mMaxProgresstime==0)
-                        this.mMaxProgresstime = 1;
-                    getInputAt(0).stackSize -= 1;
-                    return FOUND_AND_SUCCESSFULLY_USED_RECIPE;
-                }
+        ItemStack is = getInputAt(0);
+        if (GT_Utility.isStackInvalid(is))
+            return DID_NOT_FIND_RECIPE;
+        if (is.getItem() instanceof GT_MetaGenerated_Tool)
+            return DID_NOT_FIND_RECIPE;
+        ItemStack comp = new ItemStack(GregTech_API.sBlockMachines);
+        if (is.getItem() == comp.getItem()) {
+            IMetaTileEntity iMetaTileEntity = GregTech_API.METATILEENTITIES[is.getItemDamage()];
+            if (iMetaTileEntity instanceof GT_MetaTileEntity_TieredMachineBlock &&
+                    ((GT_MetaTileEntity_TieredMachineBlock) iMetaTileEntity).mTier > this.mTier)
+                return FOUND_RECIPE_BUT_DID_NOT_MEET_REQUIREMENTS;
+        }
+        Set<GT_ItemStack> stacks = outputHardOverrides.keySet();
+        for (GT_ItemStack stack : stacks) {
+            ItemStack in = is.copy();
+            in.stackSize = 1;
+            if (stack.isStackEqual(in) && stack.mStackSize <= is.stackSize) {
+                return setOutputsAndTime(outputHardOverrides.get(stack).toArray(new ItemStack[0]), stack.mStackSize)
+                        ? FOUND_AND_SUCCESSFULLY_USED_RECIPE
+                        : DID_NOT_FIND_RECIPE;
             }
+        }
+        return process()
+                ? FOUND_AND_SUCCESSFULLY_USED_RECIPE
+                : DID_NOT_FIND_RECIPE;
+    }
+
+    private boolean process(){
+
+        GT_Recipe gt_recipe = GT_Recipe.GT_Recipe_Map.sDisassemblerRecipes.findRecipe(this.getBaseMetaTileEntity(), true, this.mEUt, null, this.getAllInputs());
+        if (gt_recipe != null) {
+            gt_recipe.isRecipeInputEqual(true, null, this.getRealInventory());
+            return setOutputsAndTime(gt_recipe.mOutputs, gt_recipe.mInputs[0].stackSize);
+        }
+
+        Collection<DissassembleReference> recipes = this.findRecipeFromMachine();
+        if (recipes.isEmpty())
+            return false;
 
-        return DID_NOT_FIND_RECIPE;
+        DissassembleReference recipe = ensureDowncasting(recipes);
+
+        for (int i = 0; i < recipe.inputs.length; i++)
+            if (GT_Utility.isStackInvalid(recipe.inputs[i]) || recipe.inputs[i].stackSize < 1)
+                recipe.inputs[i] = null;
+
+        recipe.inputs = GT_Utility.getArrayListWithoutNulls(recipe.inputs).toArray(new ItemStack[0]);
+
+        return setOutputsAndTime(recipe.inputs, recipe.stackSize);
     }
 
-    private void calculateOverclockedNessDisassembler(int aEUt) {
-        if(mTier==0){
-            mEUt=aEUt>>2;
-        }else{
-            //Long EUt calculation
-            long xEUt=aEUt;
-            //Isnt too low EUt check?
-            long tempEUt = xEUt<GT_Values.V[1] ? GT_Values.V[1] : xEUt;
+    private boolean setOutputsAndTime(ItemStack[] inputs, int stackSize){
+        if (this.getInputAt(0).stackSize >= stackSize)
+            this.getInputAt(0).stackSize -= stackSize;
+        else
+            return false;
+
+        System.arraycopy(inputs, 0, this.mOutputItems, 0, inputs.length);
+        this.calculateOverclockedNess(30,600);
+
+        return true;
+    }
+
+    private static DissassembleReference ensureDowncasting(Collection<DissassembleReference> recipes) {
+        ItemStack[] inputs = recipes.stream()
+                .findFirst()
+                .orElseThrow(NullPointerException::new)
+                .inputs;
+
+        ItemStack[] output = new ItemStack[inputs.length];
+        List<GT_Recipe> recipesColl = null;
+        if (recipes.size() > 1)
+            recipesColl = recipes.stream()
+                    .skip(1)
+                    .map(x -> x.recipe)
+                    .collect(Collectors.toList());
+
+        handleRecipeTransformation(inputs, output, recipesColl);
 
-            while (tempEUt <= GT_Values.V[mTier -1] * (long)mAmperage) {
-                tempEUt<<=2;//this actually controls overclocking
-                xEUt<<=2;//this is effect of overclocking
+        return new DissassembleReference(recipes.stream().mapToInt(x -> x.stackSize).min().orElseThrow(NumberFormatException::new), output, null);
+    }
+
+    private static void handleRecipeTransformation(ItemStack[] inputs, ItemStack[] output, List<GT_Recipe> recipesColl) {
+        for (int i = 0, inputsLength = inputs.length; i < inputsLength; i++) {
+            Set<ItemStack[]> inputsStacks = null;
+            if (recipesColl != null)
+                inputsStacks = recipesColl.stream()
+                        .map(x -> x.mInputs)
+                        .collect(Collectors.toSet());
+            ItemStack input = inputs[i];
+            ItemData data = GT_OreDictUnificator.getItemData(input);
+            if (data == null || data.mMaterial == null || data.mMaterial.mMaterial == null || data.mPrefix == null) {
+                output[i] = input;
+                continue;
             }
-            if(xEUt>Integer.MAX_VALUE-1){
-                mEUt = Integer.MAX_VALUE-1;
-            }else{
-                mEUt = (int)xEUt;
+            handleReplacement(inputsStacks, data, output, input, i);
+        }
+        addOthersAndHandleAlwaysReplace(inputs, output);
+    }
+
+    /**
+     * Public Interface for ReverseRecipes, do not call inside of this class.
+     * @param inputs
+     * @param output
+     * @param inputsStacks
+     */
+    public static void handleRecipeTransformation(ItemStack[] inputs, ItemStack[] output, Set<ItemStack[]> inputsStacks) {
+        for (int i = 0, inputsLength = inputs.length; i < inputsLength; i++) {
+            ItemStack input = inputs[i];
+            ItemData data = GT_OreDictUnificator.getItemData(input);
+            if (data == null || data.mMaterial == null || data.mMaterial.mMaterial == null || data.mPrefix == null) {
+                output[i] = input;
+                continue;
             }
+            handleReplacement(inputsStacks, data, output, input, i);
         }
+        addOthersAndHandleAlwaysReplace(inputs, output);
+    }
+
+    private static void addOthersAndHandleAlwaysReplace(ItemStack[] inputs, ItemStack[] output){
+        for (int i = 0; i < inputs.length; i++) {
+            //Adds rest of Items
+            if (output[i] == null)
+                output[i] = inputs[i];
+
+            //Math.min the recipe output if Items are the same
+            if (GT_Utility.areStacksEqual(output[i], inputs[i]))
+                output[i].stackSize = Math.min(output[i].stackSize, inputs[i].stackSize);
+
+            //Handles replacement Overrides
+            ItemStack[] itemStacks = GT_MetaTileEntity_Disassembler.alwaysReplace[0];
+            for (int j = 0; j < itemStacks.length; j++) {
+                ItemStack x = itemStacks[j];
+                if (GT_Utility.areStacksEqual(x, output[i], true)) {
+                    output[i] = GT_MetaTileEntity_Disassembler.alwaysReplace[1][j];
+                    break;
+                }
+            }
+
+            //Unification
+            output[i] = handleUnification(output[i]);
+        }
+    }
+
+    private static ItemStack handleUnification(ItemStack stack) {
+        for (int oreID : OreDictionary.getOreIDs(stack)) {
+            for (int i = 0; i < OreDictionaryOverride[0].length; i++)
+                if (OreDictionary.getOreName(oreID).equals(OreDictionaryOverride[0][i])){
+                    ItemStack ret = ((ItemStack) OreDictionaryOverride[1][i]).copy();
+                    ret.stackSize = stack.stackSize;
+                    return ret;
+                }
+        }
+        return GT_OreDictUnificator.get(stack);
+    }
+
+    private static void handleReplacement(Set<ItemStack[]> inputsStacks, ItemData data, ItemStack[] output, ItemStack input, int i){
+        AtomicReference<Materials> toRpl = new AtomicReference<>();
+        Materials first = data.mMaterial.mMaterial;
+        if (inputsStacks != null) {
+            handleInputStacks(inputsStacks, toRpl, data, first, i);
+        }
+        if (toRpl.get() == null) {
+            //Remove Magnetic and Annealed Modifiers
+            handleBetterMaterialsVersions(data, toRpl);
+        }
+        if (toRpl.get() != null) {
+            output[i] = GT_OreDictUnificator.get(data.mPrefix, toRpl.get(), input.stackSize);
+            return;
+        }
+        if (data.mPrefix == OrePrefixes.circuit) {
+            handleCircuits(first, output, input, i);
+        }
+    }
+
+    private static void handleInputStacks(Set<ItemStack[]> inputsStacks, AtomicReference<Materials> toRpl, ItemData data, Materials first, int i){
+        final int finalIndex = i;
+        inputsStacks.forEach(stackArray -> {
+            ItemData dataAgainst = GT_OreDictUnificator.getItemData(stackArray[finalIndex]);
+            if (
+                    dataAgainst == null ||
+                            dataAgainst.mMaterial == null ||
+                            dataAgainst.mMaterial.mMaterial == null ||
+                            dataAgainst.mPrefix == null ||
+                            dataAgainst.mPrefix != data.mPrefix
+            ) {
+                return;
+            }
+            handleDifferentMaterialsOnRecipes(first, dataAgainst.mMaterial.mMaterial, toRpl);
+            handleAnyMaterials(first,toRpl);
+        });
+    }
+
+    private static void handleAnyMaterials(Materials first, AtomicReference<Materials> toRpl){
+        if (first.mOreReRegistrations.stream().anyMatch(y -> y.equals(Materials.AnyIron)))
+            toRpl.set(Materials.Iron);
+        else if (first.mOreReRegistrations.stream().anyMatch(y -> y.equals(Materials.AnyCopper)))
+            toRpl.set(Materials.Copper);
+        else if (first.mOreReRegistrations.stream().anyMatch(y -> y.equals(Materials.AnyRubber)))
+            toRpl.set(Materials.Rubber);
+        else if (first.mOreReRegistrations.stream().anyMatch(y -> y.equals(Materials.AnyBronze)))
+            toRpl.set(Materials.Bronze);
+        else if (first.mOreReRegistrations.stream().anyMatch(y -> y.equals(Materials.AnySyntheticRubber)))
+            toRpl.set(Materials.Rubber);
+    }
+
+    private static void handleDifferentMaterialsOnRecipes(Materials first, Materials second, AtomicReference<Materials> toRpl){
+        if (!first.equals(second))
+            if (first.equals(Materials.Aluminium) && second.equals(Materials.Iron))
+                toRpl.set(second);
+            else if (first.equals(Materials.Steel) && second.equals(Materials.Iron))
+                toRpl.set(second);
+            else if (first.equals(Materials.WroughtIron) && second.equals(Materials.Iron))
+                toRpl.set(second);
+            else if (first.equals(Materials.Aluminium) && second.equals(Materials.WroughtIron))
+                toRpl.set(Materials.Iron);
+            else if (first.equals(Materials.Aluminium) && second.equals(Materials.Steel))
+                toRpl.set(second);
+            else if (first.equals(Materials.Polytetrafluoroethylene) && second.equals(Materials.Plastic))
+                toRpl.set(second);
+            else if (first.equals(Materials.Polybenzimidazole) && second.equals(Materials.Plastic))
+                toRpl.set(second);
+            else if (first.equals(Materials.Polystyrene) && second.equals(Materials.Plastic))
+                toRpl.set(second);
+            else if (first.equals(Materials.Silicone) && second.equals(Materials.Plastic))
+                toRpl.set(second);
+            else if (first.equals(Materials.NetherQuartz) || first.equals(Materials.CertusQuartz) && second.equals(Materials.Quartzite))
+                toRpl.set(second);
+            else if (first.equals(Materials.Plastic) && second.equals(Materials.Wood))
+                toRpl.set(second);
+            else if (first.equals(Materials.Diamond) && second.equals(Materials.Glass))
+                toRpl.set(second);
+    }
+
+    private static void handleBetterMaterialsVersions(ItemData data, AtomicReference<Materials> toRpl){
+        if (Materials.SteelMagnetic.equals(data.mMaterial.mMaterial)) {
+            toRpl.set(Materials.Steel);
+        } else if (Materials.IronMagnetic.equals(data.mMaterial.mMaterial)) {
+            toRpl.set(Materials.Iron);
+        } else if (Materials.NeodymiumMagnetic.equals(data.mMaterial.mMaterial)) {
+            toRpl.set(Materials.Neodymium);
+        } else if (Materials.SamariumMagnetic.equals(data.mMaterial.mMaterial)) {
+            toRpl.set(Materials.Samarium);
+        } else if (Materials.AnnealedCopper.equals(data.mMaterial.mMaterial)) {
+            toRpl.set(Materials.Copper);
+        }
+    }
+
+    @SuppressWarnings("deprecation")
+    private static void handleCircuits(Materials first, ItemStack[] output, ItemStack input, int i){
+        if (first.equals(Materials.Primitive))
+            output[i] = ItemList.NandChip.get(input.stackSize);
+        else if (first.equals(Materials.Basic))
+            output[i] = ItemList.Circuit_Microprocessor.get(input.stackSize);
+        else if (first.equals(Materials.Good))
+            output[i] = ItemList.Circuit_Good.get(input.stackSize);
+        else if (first.equals(Materials.Advanced))
+            output[i] = ItemList.Circuit_Advanced.get(input.stackSize);
+        else if (first.equals(Materials.Data))
+            output[i] = ItemList.Circuit_Data.get(input.stackSize);
+        else if (first.equals(Materials.Master))
+            output[i] = ItemList.Circuit_Master.get(input.stackSize);
+        else if (first.equals(Materials.Ultimate))
+            output[i] = ItemList.Circuit_Quantummainframe.get(input.stackSize);
+        else if (first.equals(Materials.Superconductor))
+            output[i] = ItemList.Circuit_Crystalmainframe.get(input.stackSize);
+        else if (first.equals(Materials.Infinite))
+            output[i] = ItemList.Circuit_Wetwaremainframe.get(input.stackSize);
+        else if (first.equals(Materials.Bio))
+            output[i] = ItemList.Circuit_Biomainframe.get(input.stackSize);
+    }
+
+    static class DissassembleReference {
+        final int stackSize;
+        ItemStack[] inputs;
+        final GT_Recipe recipe;
+
+        public DissassembleReference(int stackSize, ItemStack[] inputs, GT_Recipe recipe) {
+            this.stackSize = stackSize;
+            this.inputs = inputs;
+            this.recipe = recipe;
+        }
+    }
+
+    private Collection<DissassembleReference> findRecipeFromMachine() {
+        ItemStack is = getInputAt(0);
+        if (GT_Utility.isStackInvalid(is))
+            return Collections.emptySet();
+
+        AtomicInteger stacksize = new AtomicInteger();
+        //Check Recipe Maps for creation of Item
+        List<DissassembleReference> possibleRecipes = GT_Recipe.GT_Recipe_Map.sAssemblerRecipes.mRecipeList.stream()
+                .filter(x -> Arrays.stream(x.mOutputs)
+                        .anyMatch(y ->
+                        {
+                            ItemStack out = is.copy();
+                            out.stackSize = y.stackSize;
+                            boolean isDone = GT_Utility.areStacksEqual(y, out, true) && y.stackSize <= is.stackSize;
+                            if (isDone)
+                                stacksize.set(y.stackSize);
+                            return isDone;
+                        })
+                            )
+                .map(x -> new DissassembleReference(stacksize.get(), x.mInputs, x))
+                .collect(Collectors.toList());
+
+        //Is there only one way to create it?
+        if (possibleRecipes.size() == 1)
+            return possibleRecipes;
+
+        //There are Multiple Ways -> Get recipe with cheapest inputs
+        //More Inputs should mean cheaper Materials
+        return possibleRecipes
+                .stream()
+                .sorted(Comparator.comparingDouble(x ->
+                        {
+                            double fluidInputValueRaw = Arrays.stream(x.recipe.mFluidInputs).flatMapToInt(f -> IntStream.of(f.amount)).sum();
+                            fluidInputValueRaw = fluidInputValueRaw > 0 ? fluidInputValueRaw : 144D;
+                            double inputValue = Arrays.stream(x.inputs).flatMapToInt(f -> IntStream.of(f.stackSize)).sum() +
+                                    (fluidInputValueRaw / 144D);
+                            double fluidOutputValueRaw = Arrays.stream(x.recipe.mFluidOutputs).flatMapToInt(f -> IntStream.of(f.amount)).sum();
+                            fluidOutputValueRaw = fluidOutputValueRaw > 0 ? fluidOutputValueRaw : 144D;
+                            double outputValue = Arrays.stream(x.recipe.mOutputs).flatMapToInt(f -> IntStream.of(f.stackSize)).sum() +
+                                    (fluidOutputValueRaw / 144D);
+                            return inputValue / outputValue;
+                        }
+                )).collect(Collectors.toList());
     }
 
     public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
         return //(aIndex == 4 && GT_Utility.areStacksEqual(aStack, new ItemStack(Items.egg))) ||
                 (super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack)) && (aStack.getTagCompound() != null) && (aStack.getTagCompound().getCompoundTag("GT.CraftingComponents") != null);
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Pump.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Pump.java
index 0e8fe9e5b2..0eb4092e26 100644
--- a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Pump.java
+++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Pump.java
@@ -29,7 +29,6 @@ import net.minecraftforge.fluids.IFluidHandler;
 
 import java.util.*;
 
-import static gregtech.api.enums.GT_Values.D1;
 import static gregtech.api.enums.GT_Values.V;
 import static gregtech.api.enums.GT_Values.debugBlockPump;
 
@@ -54,13 +53,16 @@ public class GT_MetaTileEntity_Pump extends GT_MetaTileEntity_Hatch {
     public Block mSecondaryPumpedBlock = null;
 
     private int radiusConfig; //Pump configured radius
+    private boolean mRetractDone = false;
 
     public GT_MetaTileEntity_Pump(int aID, String aName, String aNameRegional, int aTier) {
         super(aID, aName, aNameRegional, aTier, 3,
                 new String[]{"The best way to empty Oceans! Outputs on top",
                         getEuUsagePerTier(aTier) + " EU/operation, " + GT_Utility.safeInt(160 / 20 / (long)Math.pow(2, aTier) ) + " sec per bucket, no stuttering",
                         "Maximum pumping area: " + (getMaxDistanceForTier( aTier) * 2 + 1) + "x" + (getMaxDistanceForTier( aTier) * 2 + 1),
-                        "Use Screwdriver to regulate pumping area"});
+                        "Use Screwdriver to regulate pumping area",
+                        "Disable itself upon hitting rocks",
+                        "Disable the bottom pump to retract the pipe!"});
         radiusConfig = getMaxDistanceForTier(mTier);
     }
 
@@ -205,86 +207,124 @@ public class GT_MetaTileEntity_Pump extends GT_MetaTileEntity_Hatch {
             }
             if (this.mPumpCountBelow <= 0) {
                 // Only the bottom most pump does anything
-                if ((getBaseMetaTileEntity().isAllowedToWork()) && (getBaseMetaTileEntity().isUniversalEnergyStored(this.getEuUsagePerAction()))
-                        && ((this.mFluid == null) || (this.mFluid.amount + 1000 <= getCapacity()))) {
-                    boolean tMovedOneDown = false;
-                    if ((this.mPumpList.isEmpty()) && (getBaseMetaTileEntity().getTimer() % 100L == 0L)) {
-                        if (!this.wasPumping){
-                            tMovedOneDown = moveOneDown();
-                            if (debugBlockPump) {
-                                GT_Log.out.println("PUMP: Moved down");
+                if (getBaseMetaTileEntity().isAllowedToWork()) {
+                    mRetractDone = false;
+                    if ((getBaseMetaTileEntity().isUniversalEnergyStored(this.getEuUsagePerAction())) && ((this.mFluid == null) || (this.mFluid.amount + 1000 <= getCapacity()))) {
+                        boolean tMovedOneDown = false;
+                        if ((this.mPumpList.isEmpty()) && (getBaseMetaTileEntity().getTimer() % 100L == 0L)) {
+                            if (!this.wasPumping) {
+                                tMovedOneDown = moveOneDown();
+                                if (!tMovedOneDown) {
+                                    getBaseMetaTileEntity().disableWorking();
+                                    if (debugBlockPump) {
+                                        GT_Log.out.println("PUMP: Can't move. Retracting in next few ticks");
+                                    }
+                                } else if (debugBlockPump) {
+                                    GT_Log.out.println("PUMP: Moved down");
+                                }
+                            } else if (debugBlockPump) {
+                                GT_Log.out.println("PUMP: Was pumping, didn't move down");
                             }
-                        } else if (debugBlockPump) {
-                            GT_Log.out.println("PUMP: Was pumping, didn't move down");
                         }
-                    }
-                    int x = getBaseMetaTileEntity().getXCoord(), z = getBaseMetaTileEntity().getZCoord();
+                        int x = getBaseMetaTileEntity().getXCoord(), z = getBaseMetaTileEntity().getZCoord();
 
-                    if (!this.hasValidFluid()) {
-                        // We don't have a valid block, let's try to find one
-                        int y = getYOfPumpHead();
-
-                        if (debugBlockPump && this.mPrimaryPumpedBlock != null) {
-                            GT_Log.out.println("PUMP: Had an invalid pump block. Trying to find a fluid at Y: " + y + 
-                                    " Previous blocks 1: " + this.mPrimaryPumpedBlock + " 2: " + this.mSecondaryPumpedBlock);
-                        }
-                        // First look down
-                        checkForFluidToPump(x,     y - 1, z    );
-
-                        // Then look all around
-                        checkForFluidToPump(x,     y,     z + 1);
-                        checkForFluidToPump(x,     y,     z - 1);
-                        checkForFluidToPump(x + 1, y,     z    );
-                        checkForFluidToPump(x - 1, y,     z    );
-                        this.clearQueue(false);
-
-                        if(this.hasValidFluid()) {
-                            // Don't move down and rebuild the queue if we now have a valid fluid
-                            this.wasPumping = true;
-                        }
+                        if (!this.hasValidFluid()) {
+                            // We don't have a valid block, let's try to find one
+                            int y = getYOfPumpHead();
 
-                    } else if (getYOfPumpHead() < getBaseMetaTileEntity().getYCoord()) {
-                        // We didn't just look for a block, and the pump head is below the pump
-                        if ((tMovedOneDown) || this.wasPumping ||
-                                ((this.mPumpList.isEmpty()) && (getBaseMetaTileEntity().getTimer() % 200L == 100L)) ||
-                                (getBaseMetaTileEntity().getTimer() % 72000L == 100L)) 
-                        {
-                            // Rebuild the list to pump if any of the following conditions are true:
-                            //  1) We just moved down
-                            //  2) We were previously pumping (and possibly just reloaded)
-                            //  3) We have an empty queue and enough time has passed
-                            //  4) A long while has has passed
-                            if (debugBlockPump) {
-                                GT_Log.out.println("PUMP: Rebuilding pump list - Size " +
-                                        this.mPumpList.size() + " WasPumping: " + this.wasPumping + " Timer " + getBaseMetaTileEntity().getTimer());
+                            if (debugBlockPump && this.mPrimaryPumpedBlock != null) {
+                                GT_Log.out.println("PUMP: Had an invalid pump block. Trying to find a fluid at Y