Add a recipe check to MuTEs (#1727)

* working recipes!

* clean up and save items which need to be outputted

* reviews

4 files changed, 161 insertions, 11 deletions

diff --git a/src/main/java/gregtech/api/enums/GT_Values.java b/src/main/java/gregtech/api/enums/GT_Values.java
index 688ffad28e..14cca69f05 100644
--- a/src/main/java/gregtech/api/enums/GT_Values.java
+++ b/src/main/java/gregtech/api/enums/GT_Values.java
@@ -232,6 +232,7 @@ public class GT_Values {
                 // Machines
                 ACTIVE = "gt.active", // Boolean
                 FLUID_OUT = "gt.fluidout", // Output Fluid
+                ITEM_OUT = "gt,itemout", // Output Item
                 PARALLEL = "gt.parallel", // Number
                 TANK_CAPACITY = "gt.tankcap", // Number
                 TANK_IN = "gt.tank.in.", // FluidStack
diff --git a/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlockController.java b/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlockController.java
index 579d0b1759..8eefc28a71 100644
--- a/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlockController.java
+++ b/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlockController.java
@@ -13,6 +13,7 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
 
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
@@ -84,6 +85,7 @@ public abstract class MultiBlockController<T extends MultiBlockController<T>> ex
         implements IAlignment, IConstructable, IMultiBlockController, IDescribable, IMachineProgress,
         IMultiBlockFluidHandler, IMultiBlockInventory, IMTE_AddToolTips {
 
+    private static final int TICKS_BETWEEN_RECIPE_CHECKS = 100;
     private static final Map<Integer, GT_Multiblock_Tooltip_Builder> tooltip = new ConcurrentHashMap<>();
     private final List<AdvancedCasing> mUpgradeCasings = new ArrayList<AdvancedCasing>();
     protected BuildState buildState = new BuildState();
@@ -93,11 +95,14 @@ public abstract class MultiBlockController<T extends MultiBlockController<T>> ex
     protected Map<String, IItemHandlerModifiable> multiBlockInputInventory = new LinkedHashMap<>();
     protected Map<String, IItemHandlerModifiable> multiBlockOutputInventory = new LinkedHashMap<>();
 
-    private int mMaxProgressTime = 0, mProgressTime = 0;
+    protected int mMaxProgressTime = 0;
+    private int mProgressTime = 0;
     private boolean mStructureOkay = false, mStructureChanged = false;
-    private boolean mWorks = true, mWorkUpdate = false, mWasShutdown = false, mActive = false;
+    private boolean mWorks = true, mWorkUpdate = false, mWasShutdown = false, mActive = false, mSeparateInputs = true;
     private ExtendedFacing mExtendedFacing = ExtendedFacing.DEFAULT;
     private IAlignmentLimits mLimits = getInitialAlignmentLimits();
+    private ItemStack[] mItemsToOutput;
+    private String mInventory;
 
     // A list of sides
     // Each side has a list of parts that have a cover that need to be ticked
@@ -154,6 +159,7 @@ public abstract class MultiBlockController<T extends MultiBlockController<T>> ex
         aNBT.setByte(NBT.FLIP, (byte) mExtendedFacing.getFlip().getIndex());
 
         saveUpgradeInventoriesToNBT(aNBT);
+        saveItemsToOutput(aNBT);
     }
 
     private void saveUpgradeInventoriesToNBT(NBTTagCompound aNBT) {
@@ -183,6 +189,20 @@ public abstract class MultiBlockController<T extends MultiBlockController<T>> ex
         aNBT.setTag(NBT.UPGRADE_INVENTORIES_OUTPUT, tListOutputInvs);
     }
 
+    private void saveItemsToOutput(NBTTagCompound aNBT) {
+        final NBTTagList tList = new NBTTagList();
+        for (int tSlot = 0; tSlot < mItemsToOutput.length; tSlot++) {
+            final ItemStack tStack = mItemsToOutput[tSlot];
+            if (tStack != null) {
+                final NBTTagCompound tag = new NBTTagCompound();
+                tag.setByte("s", (byte) tSlot);
+                tStack.writeToNBT(tag);
+                tList.appendTag(tag);
+            }
+        }
+        aNBT.setTag(NBT.ITEM_OUT, tList);
+    }
+
     @Override
     public void readMultiTileNBT(NBTTagCompound aNBT) {
         super.readMultiTileNBT(aNBT);
@@ -199,6 +219,7 @@ public abstract class MultiBlockController<T extends MultiBlockController<T>> ex
                 Flip.byIndex(aNBT.getByte(NBT.FLIP)));
 
         loadUpgradeInventoriesFromNBT(aNBT);
+        loadItemsToOutput(aNBT);
     }
 
     private void loadUpgradeInventoriesFromNBT(NBTTagCompound aNBT) {
@@ -226,6 +247,16 @@ public abstract class MultiBlockController<T extends MultiBlockController<T>> ex
         }
     }
 
+    private void loadItemsToOutput(NBTTagCompound aNBT) {
+        final NBTTagList tList = aNBT.getTagList(NBT.ITEM_OUT, 10);
+        mItemsToOutput = new ItemStack[tList.tagCount()];
+        for (int i = 0; i < tList.tagCount(); i++) {
+            final NBTTagCompound tNBT = tList.getCompoundTagAt(i);
+            final int tSlot = tNBT.getByte("s");
+            if (tSlot >= 0 && tSlot < mItemsToOutput.length) mItemsToOutput[tSlot] = GT_Utility.loadItem(tNBT);
+        }
+    }
+
     @Override
     public void addToolTips(List<String> aList, ItemStack aStack, boolean aF3_H) {
         aList.addAll(Arrays.asList(getDescription()));
@@ -435,9 +466,40 @@ public abstract class MultiBlockController<T extends MultiBlockController<T>> ex
                 // Recheck the structure every 30 seconds or so
                 if (!checkStructure(false)) checkStructure(true);
             }
+            if (mStructureOkay) {
+                runMachine(aTick);
+            } else {
+                stopMachine();
+            }
+        }
+    }
+
+    protected void runMachine(long aTick) {
+        if (mMaxProgressTime > 0) {
+            markDirty();
+            if (mMaxProgressTime > 0 && ++mProgressTime >= mMaxProgressTime) {
+                mProgressTime = 0;
+                mMaxProgressTime = 0;
+                outputItems();
+                if (isAllowedToWork()) {
+                    checkRecipe();
+                }
+            }
+        } else {
+            if (aTick % TICKS_BETWEEN_RECIPE_CHECKS == 0 || hasWorkJustBeenEnabled() || hasInventoryBeenModified()) {
+                if (isAllowedToWork()) {
+                    if (checkRecipe()) {
+                        markDirty();
+                    }
+                }
+            }
         }
     }
 
+    protected boolean checkRecipe() {
+        return checkRecipe(null);
+    }
+
     protected void clearSpecialLists() {
         mUpgradeCasings.clear();
     }
@@ -538,6 +600,14 @@ public abstract class MultiBlockController<T extends MultiBlockController<T>> ex
         mActive = aActive;
     }
 
+    public boolean isSeparateInputs() {
+        return mSeparateInputs;
+    }
+
+    public void setSeparateInputs(boolean aSeparateInputs) {
+        mSeparateInputs = aSeparateInputs;
+    }
+
     @Override
     public boolean wasShutdown() {
         return mWasShutdown;
@@ -1165,7 +1235,44 @@ public abstract class MultiBlockController<T extends MultiBlockController<T>> ex
         return isItemValidForSlot(aSlot, aStack);
     }
 
-    /**
+    /*
+     * Helper Methods For Recipe checking
+     */
+
+    protected ItemStack[] getAllItemInputs() {
+        return getInventoriesForInput().getStacks().toArray(new ItemStack[0]);
+    }
+
+    protected Iterable<Pair<ItemStack[], String>> getItemInputsForEachInventory() {
+        return multiBlockInputInventory.entrySet().stream()
+                .map((entry) -> Pair.of(entry.getValue().getStacks().toArray(new ItemStack[0]), entry.getKey()))
+                .collect(Collectors.toList());
+    }
+
+    protected void setItemOutputs(ItemStack[] aItemOutputs, String aInventory) {
+        mItemsToOutput = aItemOutputs;
+        mInventory = aInventory;
+    }
+
+    private void outputItems() {
+        int index = 0;
+        if (mItemsToOutput == null) {
+            return;
+        }
+        if (mInventory != null) {
+            for (ItemStack tItem : mItemsToOutput) {
+                multiBlockOutputInventory.getOrDefault(mInventory, getInventoriesForOutput())
+                        .insertItem(index++, tItem.copy(), false);
+            }
+        } else {
+            for (ItemStack tItem : mItemsToOutput) {
+                getInventoriesForOutput().insertItem(index++, tItem.copy(), false);
+            }
+        }
+        mItemsToOutput = null;
+    }
+
+    /*
      * GUI Work - Multiblock GUI related methods
      */
     @Override
diff --git a/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlock_Stackable.java b/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlock_Stackable.java
index 9dfd4c0cc6..f40a993738 100644
--- a/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlock_Stackable.java
+++ b/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlock_Stackable.java
@@ -105,9 +105,4 @@ public abstract class MultiBlock_Stackable<T extends MultiBlock_Stackable<T>> ex
         buildState.addOffset(getAfterLastStackOffset());
         return checkPiece(STACKABLE_TOP, buildState.stopBuilding());
     }
-
-    @Override
-    public boolean checkRecipe(ItemStack aStack) {
-        return false;
-    }
 }
diff --git a/src/main/java/gregtech/common/tileentities/machines/multiblock/MultiBlock_Macerator.java b/src/main/java/gregtech/common/tileentities/machines/multiblock/MultiBlock_Macerator.java
index fa0a6298f6..d4810aa195 100644
--- a/src/main/java/gregtech/common/tileentities/machines/multiblock/MultiBlock_Macerator.java
+++ b/src/main/java/gregtech/common/tileentities/machines/multiblock/MultiBlock_Macerator.java
@@ -3,8 +3,10 @@ package gregtech.common.tileentities.machines.multiblock;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
 import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASINGS;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_ELECTRIC_BLAST_FURNACE;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_ELECTRIC_BLAST_FURNACE_ACTIVE;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_ELECTRIC_BLAST_FURNACE_ACTIVE_GLOW;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_ELECTRIC_BLAST_FURNACE_GLOW;
 import static gregtech.api.multitileentity.multiblock.base.MultiBlockPart.ENERGY_IN;
 import static gregtech.api.multitileentity.multiblock.base.MultiBlockPart.FLUID_IN;
 import static gregtech.api.multitileentity.multiblock.base.MultiBlockPart.FLUID_OUT;
@@ -13,15 +15,21 @@ import static gregtech.api.multitileentity.multiblock.base.MultiBlockPart.ITEM_O
 import static gregtech.api.multitileentity.multiblock.base.MultiBlockPart.NOTHING;
 
 import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+
+import org.apache.commons.lang3.tuple.Pair;
 
 import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
 import com.gtnewhorizon.structurelib.structure.StructureDefinition;
 import com.gtnewhorizon.structurelib.util.Vec3Impl;
 
+import gregtech.api.enums.TierEU;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.multitileentity.multiblock.base.MultiBlock_Stackable;
 import gregtech.api.render.TextureFactory;
 import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
 
 public class MultiBlock_Macerator extends MultiBlock_Stackable<MultiBlock_Macerator> {
 
@@ -135,12 +143,51 @@ public class MultiBlock_Macerator extends MultiBlock_Stackable<MultiBlock_Macera
                     // Base Texture
                     MACHINE_CASINGS[1][0],
                     // Active
-                    TextureFactory.builder().addIcon(OVERLAY_FRONT_ELECTRIC_BLAST_FURNACE_ACTIVE).extFacing().build(),
+                    isActive()
+                            ? TextureFactory.builder().addIcon(OVERLAY_FRONT_ELECTRIC_BLAST_FURNACE_ACTIVE).extFacing()
+                                    .build()
+                            : TextureFactory.builder().addIcon(OVERLAY_FRONT_ELECTRIC_BLAST_FURNACE).extFacing()
+                                    .build(),
                     // Active Glow
-                    TextureFactory.builder().addIcon(OVERLAY_FRONT_ELECTRIC_BLAST_FURNACE_ACTIVE_GLOW).extFacing()
-                            .glow().build() };
+                    isActive()
+                            ? TextureFactory.builder().addIcon(OVERLAY_FRONT_ELECTRIC_BLAST_FURNACE_ACTIVE_GLOW)
+                                    .extFacing().glow().build()
+                            : TextureFactory.builder().addIcon(OVERLAY_FRONT_ELECTRIC_BLAST_FURNACE_GLOW).extFacing()
+                                    .glow().build() };
         }
         // Base Texture
         return new ITexture[] { MACHINE_CASINGS[1][0] };
     }
+
+    @Override
+    public boolean checkRecipe(ItemStack aStack) {
+        if (isSeparateInputs()) {
+            for (Pair<ItemStack[], String> tItemInputs : getItemInputsForEachInventory()) {
+                if (processRecipe(aStack, tItemInputs.getLeft(), tItemInputs.getRight())) {
+                    return true;
+                }
+            }
+            return false;
+        } else {
+            ItemStack[] tItemInputs = getInventoriesForInput().getStacks().toArray(new ItemStack[0]);
+            return processRecipe(aStack, tItemInputs, null);
+        }
+    }
+
+    private boolean processRecipe(ItemStack aStack, ItemStack[] aItemInputs, String aInventory) {
+        GT_Recipe_Map tRecipeMap = GT_Recipe_Map.sMaceratorRecipes;
+        GT_Recipe tRecipe = tRecipeMap.findRecipe(this, false, TierEU.IV, null, aItemInputs);
+        if (tRecipe == null) {
+            return false;
+        }
+
+        if (!tRecipe.isRecipeInputEqual(true, false, 1, null, aItemInputs)) {
+            return false;
+        }
+
+        mMaxProgressTime = tRecipe.mDuration;
+
+        setItemOutputs(tRecipe.mOutputs, aInventory);
+        return true;
+    }
 }