Merge branch 'master' into TreeGrowthSim

dependencies.gradle

@@ -1,13 +1,13 @@
 dependencies {
-    api('com.github.GTNewHorizons:GT5-Unofficial:5.09.45.73:dev')
+    api('com.github.GTNewHorizons:GT5-Unofficial:5.09.45.77:dev')
     api("com.github.GTNewHorizons:bartworks:0.9.11:dev")
 
     implementation('curse.maven:cofh-core-69162:2388751')
     // https://www.curseforge.com/minecraft/mc-mods/advancedsolarpanels
     implementation('curse.maven:advsolar-362768:2885953')
 
     compileOnly('com.github.GTNewHorizons:Baubles:1.0.4:dev') {transitive=false}
-    compileOnly('com.github.GTNewHorizons:EnderCore:0.4.1:dev') {transitive=false}
+    compileOnly('com.github.GTNewHorizons:EnderCore:0.4.4:dev') {transitive=false}
     compileOnly('com.github.GTNewHorizons:SC2:2.1.0:dev') {transitive=false}
     compileOnly('com.github.GTNewHorizons:Binnie:2.3.3:dev') {transitive = false}
     compileOnly('curse.maven:PlayerAPI-228969:2248928') {transitive=false}

src/main/java/gtPlusPlus/core/recipe/RECIPES_Machines.java

@@ -251,6 +251,7 @@ private static void run() {
         thermicFluidHeater();
         advHeatExchanger();
         chiselBuses();
+        solidifierHatches();
 
         gt4FarmManager();
         gt4Inventory();
@@ -3040,4 +3041,26 @@ private static void chiselBuses() {
         }
     }
 
+    private static void solidifierHatches() {
+        ItemStack[] mSuperBusesInput = new ItemStack[] { ItemList.Hatch_Input_IV.get(1),
+                ItemList.Hatch_Input_LuV.get(1), ItemList.Hatch_Input_ZPM.get(1), ItemList.Hatch_Input_UV.get(1), };
+
+        ItemStack[] mSolidifierHatches = new ItemStack[] { GregtechItemList.GT_MetaTileEntity_Solidifier_I.get(1),
+                GregtechItemList.GT_MetaTileEntity_Solidifier_II.get(1),
+                GregtechItemList.GT_MetaTileEntity_Solidifier_III.get(1),
+                GregtechItemList.GT_MetaTileEntity_Solidifier_IV.get(1), };
+
+        for (int i = 0; i < 4; i++) {
+            int componentTier = i + 5;
+            CORE.RA.addSixSlotAssemblingRecipe(
+                    new ItemStack[] { CI.getNumberedCircuit(17), mSuperBusesInput[i], CI.getSensor(componentTier, 1),
+                            CI.getFluidRegulator(componentTier, 1),
+                            CI.getTieredComponent(OrePrefixes.circuit, componentTier + 1, 4),
+                            ItemUtils.getSimpleStack(Blocks.chest) },
+                    CI.getTieredFluid(componentTier, 144 * 2),
+                    mSolidifierHatches[i],
+                    20 * 30,
+                    (int) GT_Values.VP[componentTier]);
+        }
+    }
 }

src/main/java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java

@@ -560,6 +560,12 @@ public enum GregtechItemList implements GregtechItemContainer {
     GT_MetaTileEntity_ChiselBus_MV,
     GT_MetaTileEntity_ChiselBus_HV,
 
+    // Solidifier Hatches for Industrial Multi Machine
+    GT_MetaTileEntity_Solidifier_I,
+    GT_MetaTileEntity_Solidifier_II,
+    GT_MetaTileEntity_Solidifier_III,
+    GT_MetaTileEntity_Solidifier_IV,
+
     // ----------------------------------------------------------------------------
 
     /**

src/main/java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Solidifier.java

@@ -0,0 +1,70 @@
+package gtPlusPlus.xmod.gregtech.api.metatileentity.implementations;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.widget.SlotWidget;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
+import gregtech.api.util.GT_Utility;
+
+public class GT_MetaTileEntity_Hatch_Solidifier extends GT_MetaTileEntity_Hatch_Input {
+
+    static final int moldSlot = 2;
+
+    public GT_MetaTileEntity_Hatch_Solidifier(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier);
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[] {
+                "Fluid Input with Mold for " + EnumChatFormatting.YELLOW
+                        + "Large Processing Factory"
+                        + EnumChatFormatting.RESET,
+                "#22 Circuit is imprinted in Hatch", "Capacity: " + GT_Utility.formatNumbers(getCapacity()) + "L",
+                "Added by: " + EnumChatFormatting.AQUA
+                        + "Quetz4l"
+                        + " - "
+                        + EnumChatFormatting.RED
+                        + "[GT++]"
+                        + EnumChatFormatting.RESET };
+    }
+
+    public GT_MetaTileEntity_Hatch_Solidifier(String aName, int aTier, String[] aDescription,
+            ITexture[][][] aTextures) {
+        super(aName, getSlots(aTier), aTier, aDescription, aTextures);
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GT_MetaTileEntity_Hatch_Solidifier(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    public ItemStack getMold() {
+        return this.getStackInSlot(moldSlot);
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        super.addUIWidgets(builder, buildContext);
+        builder.widget(new SlotWidget(inventoryHandler, moldSlot).setPos(125, 35).setSize(18, 18));
+    }
+
+    @Override
+    public void onBlockDestroyed() {
+        super.onBlockDestroyed();
+    }
+
+    // for a drop-down form when the hatch is destroyed
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        if (aIndex == moldSlot) return true;
+        else return super.isValidSlot(aIndex);
+    }
+}

src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialMultiMachine.java

@@ -11,11 +11,13 @@
 import static gregtech.api.enums.GT_HatchElement.OutputBus;
 import static gregtech.api.enums.GT_HatchElement.OutputHatch;
 import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
+import static gregtech.api.util.GT_Utility.filterValidMTEs;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Stream;
 
 import javax.annotation.Nonnull;
@@ -30,7 +32,9 @@
 import net.minecraft.util.StatCollector;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
 
+import com.google.common.collect.Lists;
 import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
 import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
 import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
@@ -41,16 +45,26 @@
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.logic.ProcessingLogic;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBus;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_MultiInput;
 import gregtech.api.recipe.RecipeMap;
 import gregtech.api.recipe.RecipeMaps;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
 import gregtech.api.util.GT_LanguageManager;
 import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
 import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
+import gregtech.common.tileentities.machines.GT_MetaTileEntity_Hatch_Input_ME;
+import gregtech.common.tileentities.machines.IDualInputHatch;
+import gregtech.common.tileentities.machines.IDualInputInventory;
 import gtPlusPlus.core.block.ModBlocks;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
 import gtPlusPlus.core.util.minecraft.PlayerUtils;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Solidifier;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
 import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
 import mcp.mobius.waila.api.IWailaConfigHandler;
@@ -127,6 +141,9 @@ protected GT_Multiblock_Tooltip_Builder createTooltip() {
                                 + aBuiltStrings[2]
                                 + EnumChatFormatting.RESET)
                 .addInfo("Read Multi-Machine Manual for extra information")
+                .addInfo(
+                        EnumChatFormatting.AQUA + "You can use Solidifier Hatch to solidify multiple liquids."
+                                + EnumChatFormatting.RESET)
                 .addPollutionAmount(getPollutionPerSecond(null)).addSeparator().beginStructureBlock(3, 3, 3, true)
                 .addController("Front Center").addCasingInfoMin("Multi-Use Casings", 6, false)
                 .addInputBus("Any Casing", 1).addOutputBus("Any Casing", 1).addInputHatch("Any Casing", 1)
@@ -362,6 +379,130 @@ public void getWailaNBTData(EntityPlayerMP player, TileEntity tile, NBTTagCompou
         tag.setInteger("mode", mInternalMode);
     }
 
+    @Override
+    protected CheckRecipeResult doCheckRecipe() {
+
+        if (mInternalMode != 2 || !isInputSeparationEnabled()) {
+            return super.doCheckRecipe();
+        } else {
+            CheckRecipeResult result = CheckRecipeResultRegistry.NO_RECIPE;
+
+            // check crafting input hatches first
+            if (supportsCraftingMEBuffer()) {
+                for (IDualInputHatch dualInputHatch : mDualInputHatches) {
+                    for (var it = dualInputHatch.inventories(); it.hasNext();) {
+                        IDualInputInventory slot = it.next();
+                        processingLogic.setInputItems(slot.getItemInputs());
+                        processingLogic.setInputFluids(slot.getFluidInputs());
+                        CheckRecipeResult foundResult = processingLogic.process();
+                        if (foundResult.wasSuccessful()) {
+                            return foundResult;
+                        }
+                        if (foundResult != CheckRecipeResultRegistry.NO_RECIPE) {
+                            // Recipe failed in interesting way, so remember that and continue searching
+                            result = foundResult;
+                        }
+                    }
+                }
+            }
+
+            // Logic for GT_MetaTileEntity_Hatch_Solidifier
+            for (GT_MetaTileEntity_Hatch_Input solidifierHatch : mInputHatches) {
+                if (solidifierHatch instanceof GT_MetaTileEntity_Hatch_Solidifier) {
+                    ItemStack mold = ((GT_MetaTileEntity_Hatch_Solidifier) solidifierHatch).getMold();
+                    FluidStack fluid = solidifierHatch.getFluid();
+
+                    if (mold != null && fluid != null) {
+                        List<ItemStack> inputItems = new ArrayList<>();
+                        inputItems.add(mold);
+                        inputItems.add(ItemUtils.getGregtechCircuit(22));
+
+                        processingLogic.setInputItems(inputItems.toArray(new ItemStack[0]));
+                        processingLogic.setInputFluids(fluid);
+
+                        CheckRecipeResult foundResult = processingLogic.process();
+                        if (foundResult.wasSuccessful()) {
+                            return foundResult;
+                        }
+                        if (foundResult != CheckRecipeResultRegistry.NO_RECIPE) {
+                            // Recipe failed in interesting way, so remember that and continue searching
+                            result = foundResult;
+                        }
+                    }
+                }
+            }
+            processingLogic.clear();
+            processingLogic.setInputFluids(getStoredFluids());
+            // Default logic
+            for (GT_MetaTileEntity_Hatch_InputBus bus : mInputBusses) {
+                List<ItemStack> inputItems = new ArrayList<>();
+                for (int i = bus.getSizeInventory() - 1; i >= 0; i--) {
+                    ItemStack stored = bus.getStackInSlot(i);
+                    if (stored != null) {
+                        inputItems.add(stored);
+                    }
+                }
+                if (canUseControllerSlotForRecipe() && getControllerSlot() != null) {
+                    inputItems.add(getControllerSlot());
+                }
+                processingLogic.setInputItems(inputItems.toArray(new ItemStack[0]));
+                CheckRecipeResult foundResult = processingLogic.process();
+                if (foundResult.wasSuccessful()) {
+                    return foundResult;
+                }
+                if (foundResult != CheckRecipeResultRegistry.NO_RECIPE) {
+                    // Recipe failed in interesting way, so remember that and continue searching
+                    result = foundResult;
+                }
+            }
+
+            return result;
+        }
+    }
+
+    @Override
+    public ArrayList<FluidStack> getStoredFluids() {
+        if (supportsCraftingMEBuffer()) {
+            for (IDualInputHatch tHatch : mDualInputHatches) {
+                if (tHatch.supportsFluids()) {
+                    Optional<IDualInputInventory> inventory = tHatch.getFirstNonEmptyInventory();
+                    if (inventory.isPresent()) {
+                        return Lists.newArrayList(inventory.get().getFluidInputs());
+                    }
+                }
+            }
+        }
+
+        ArrayList<FluidStack> rList = new ArrayList<>();
+        for (GT_MetaTileEntity_Hatch_Input tHatch : filterValidMTEs(mInputHatches)) {
+            if (tHatch instanceof GT_MetaTileEntity_Hatch_Solidifier) {
+                continue;
+            }
+
+            setHatchRecipeMap(tHatch);
+            if (tHatch instanceof GT_MetaTileEntity_Hatch_MultiInput) {
+                for (FluidStack tFluid : ((GT_MetaTileEntity_Hatch_MultiInput) tHatch).getStoredFluid()) {
+                    if (tFluid != null) {
+                        rList.add(tFluid);
+                    }
+                }
+            } else if (tHatch instanceof GT_MetaTileEntity_Hatch_Input_ME) {
+                if (tHatch.isValid()) {
+                    for (FluidStack fluidStack : ((GT_MetaTileEntity_Hatch_Input_ME) tHatch).getStoredFluids()) {
+                        if (fluidStack == null) continue;
+                        rList.add(fluidStack);
+                    }
+                }
+            } else {
+                if (tHatch.getFillableStack() != null) {
+                    rList.add(tHatch.getFillableStack());
+                }
+            }
+        }
+
+        return rList;
+    }
+
     @Override
     public void getWailaBody(ItemStack itemStack, List<String> currentTip, IWailaDataAccessor accessor,
             IWailaConfigHandler config) {

src/main/java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechCustomHatches.java

@@ -11,6 +11,7 @@
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Muffler_Adv;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Naquadah;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Reservoir;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Solidifier;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_TurbineProvider;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_SuperBus_Input;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_SuperBus_Output;
@@ -26,6 +27,7 @@ public static void run() {
         }
         run3();
         run4(); // Chisel buses
+        run6(); // Solidifier hatches
     }
 
     private static void run1() {
@@ -242,7 +244,7 @@ private static GT_MetaTileEntity_ChiselBus makeChiselBus(int id, String unlocali
     }
 
     private static void run4() {
-        int aID = 31778;
+        int aID = 31778; // 31778 - 31780
 
         GregtechItemList.GT_MetaTileEntity_ChiselBus_LV
                 .set((makeChiselBus(aID++, "hatch.chisel.tier.01", "Chisel Bus I", 1)).getStackForm(1L));
@@ -252,4 +254,22 @@ private static void run4() {
                 .set((makeChiselBus(aID++, "hatch.chisel.tier.03", "Chisel Bus III", 3)).getStackForm(1L));
 
     }
+
+    private static void run6() {
+        int aID = 31781; // 31781-31784
+
+        GregtechItemList.GT_MetaTileEntity_Solidifier_I.set(
+                new GT_MetaTileEntity_Hatch_Solidifier(aID++, "hatch.solidifier.tier.05", "Solidifier Hatch I", 5)
+                        .getStackForm(1L));
+        GregtechItemList.GT_MetaTileEntity_Solidifier_II.set(
+                new GT_MetaTileEntity_Hatch_Solidifier(aID++, "hatch.solidifier.tier.06", "Solidifier Hatch II", 6)
+                        .getStackForm(1L));
+        GregtechItemList.GT_MetaTileEntity_Solidifier_III.set(
+                new GT_MetaTileEntity_Hatch_Solidifier(aID++, "hatch.solidifier.tier.07", "Solidifier Hatch III", 7)
+                        .getStackForm(1L));
+        GregtechItemList.GT_MetaTileEntity_Solidifier_IV.set(
+                new GT_MetaTileEntity_Hatch_Solidifier(aID, "hatch.solidifier.tier.08", "Solidifier Hatch IV", 8)
+                        .getStackForm(1L));
+    }
+
 }