Base functionality done, todo item collapsing, auto pull/push, and proper front textures

Zorbatron · Zorbatron · commit 0d8ecc00fcfb · 2025-04-11T14:42:05.000-04:00
diff --git a/src/main/java/gregtech/common/metatileentities/MetaTileEntities.java b/src/main/java/gregtech/common/metatileentities/MetaTileEntities.java
@@ -77,6 +77,7 @@
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityCleaningMaintenanceHatch;
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityComputationHatch;
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityDataAccessHatch;
+import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityDualHatch;
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityEnergyHatch;
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityFluidHatch;
 import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityItemBus;
@@ -261,6 +262,8 @@ public class MetaTileEntities {
     public static MetaTileEntityHPCACooler HPCA_HEAT_SINK_COMPONENT;
     public static MetaTileEntityHPCACooler HPCA_ACTIVE_COOLER_COMPONENT;
     public static MetaTileEntityHPCABridge HPCA_BRIDGE_COMPONENT;
+    public static MetaTileEntityDualHatch[] DUAL_INPUT_HATCH = new MetaTileEntityDualHatch[GTValues.V.length - 1];
+    public static MetaTileEntityDualHatch[] DUAL_OUTPUT_HATCH = new MetaTileEntityDualHatch[GTValues.V.length - 1];
 
     // Used for addons if they wish to disable certain tiers of machines
     private static final Map<String, Boolean> MID_TIER = new HashMap<>();
@@ -1218,6 +1221,20 @@ public static void init() {
 
         // 1820-1849 are taken for UHV+ 4A/16A/64A Energy/Dynamo Hatches
         // 1850-1869 are taken for UHV+ Input/Output Buses/Hatches
+
+        // Dual Input Hatches
+        for (int tier = GTValues.ULV; tier <= (GregTechAPI.isHighTier() ? GTValues.OpV : GTValues.UHV); tier++) {
+            String voltageName = GTValues.VN[tier].toLowerCase();
+            DUAL_INPUT_HATCH[tier] = registerMetaTileEntity(1879 + tier, new MetaTileEntityDualHatch(
+                    gregtechId(String.format("%s.%s", "dual_input_hatch", voltageName)), tier, false));
+        }
+
+        // Dual Output Hatches
+        for (int tier = GTValues.ULV; tier <= (GregTechAPI.isHighTier() ? GTValues.OpV : GTValues.UHV); tier++) {
+            String voltageName = GTValues.VN[tier].toLowerCase();
+            DUAL_INPUT_HATCH[tier] = registerMetaTileEntity(1893 + tier, new MetaTileEntityDualHatch(
+                    gregtechId(String.format("%s.%s", "dual_output_hatch", voltageName)), tier, true));
+        }
     }
 
     private static void registerSimpleMetaTileEntity(SimpleMachineMetaTileEntity[] machines,
diff --git a/src/main/java/gregtech/common/metatileentities/multi/multiblockpart/MetaTileEntityDualHatch.java b/src/main/java/gregtech/common/metatileentities/multi/multiblockpart/MetaTileEntityDualHatch.java
@@ -0,0 +1,351 @@
+package gregtech.common.metatileentities.multi.multiblockpart;
+
+import gregtech.api.GTValues;
+import gregtech.api.capability.DualHandler;
+import gregtech.api.capability.GregtechDataCodes;
+import gregtech.api.capability.IControllable;
+import gregtech.api.capability.IGhostSlotConfigurable;
+import gregtech.api.capability.impl.FluidTankList;
+import gregtech.api.capability.impl.GhostCircuitItemStackHandler;
+import gregtech.api.capability.impl.ItemHandlerList;
+import gregtech.api.capability.impl.NotifiableFluidTank;
+import gregtech.api.capability.impl.NotifiableItemStackHandler;
+import gregtech.api.items.itemhandlers.GTItemStackHandler;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.interfaces.IGregTechTileEntity;
+import gregtech.api.metatileentity.multiblock.AbilityInstances;
+import gregtech.api.metatileentity.multiblock.IMultiblockAbilityPart;
+import gregtech.api.metatileentity.multiblock.MultiblockAbility;
+import gregtech.api.mui.GTGuiTextures;
+import gregtech.api.mui.GTGuis;
+import gregtech.api.mui.widget.GhostCircuitSlotWidget;
+import gregtech.client.renderer.texture.Textures;
+import gregtech.client.renderer.texture.cube.SimpleOverlayRenderer;
+import gregtech.common.mui.widget.GTFluidSlot;
+
+import net.minecraft.client.resources.I18n;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.IFluidTank;
+import net.minecraftforge.items.IItemHandlerModifiable;
+
+import codechicken.lib.render.CCRenderState;
+import codechicken.lib.render.pipeline.IVertexOperation;
+import codechicken.lib.vec.Matrix4;
+import com.cleanroommc.modularui.api.drawable.IKey;
+import com.cleanroommc.modularui.api.widget.IWidget;
+import com.cleanroommc.modularui.factory.PosGuiData;
+import com.cleanroommc.modularui.screen.ModularPanel;
+import com.cleanroommc.modularui.value.BoolValue;
+import com.cleanroommc.modularui.value.sync.BooleanSyncValue;
+import com.cleanroommc.modularui.value.sync.PanelSyncManager;
+import com.cleanroommc.modularui.value.sync.SyncHandlers;
+import com.cleanroommc.modularui.widget.Widget;
+import com.cleanroommc.modularui.widgets.ItemSlot;
+import com.cleanroommc.modularui.widgets.SlotGroupWidget;
+import com.cleanroommc.modularui.widgets.ToggleButton;
+import com.cleanroommc.modularui.widgets.layout.Flow;
+import com.cleanroommc.modularui.widgets.layout.Grid;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class MetaTileEntityDualHatch extends MetaTileEntityMultiblockNotifiablePart implements
+                                     IMultiblockAbilityPart<IItemHandlerModifiable>,
+                                     IControllable,
+                                     IGhostSlotConfigurable {
+
+    @Nullable
+    protected GhostCircuitItemStackHandler circuitInventory;
+    @Nullable
+    private IItemHandlerModifiable actualImportItems;
+    private DualHandler dualHandler;
+
+    private boolean workingEnabled;
+    private boolean autoCollapse;
+
+    public MetaTileEntityDualHatch(ResourceLocation metaTileEntityId, int tier, boolean isExportHatch) {
+        super(metaTileEntityId, tier, isExportHatch);
+        initializeInventory();
+    }
+
+    @Override
+    public MetaTileEntity createMetaTileEntity(IGregTechTileEntity tileEntity) {
+        return new MetaTileEntityDualHatch(metaTileEntityId, getTier(), isExportHatch);
+    }
+
+    @Override
+    protected void initializeInventory() {
+        super.initializeInventory();
+        if (hasGhostCircuitInventory()) {
+            circuitInventory = new GhostCircuitItemStackHandler(this);
+            circuitInventory.addNotifiableMetaTileEntity(this);
+            actualImportItems = new ItemHandlerList(Arrays.asList(super.getImportItems(), circuitInventory));
+        } else {
+            actualImportItems = null;
+        }
+        dualHandler = new DualHandler(isExportHatch ? getExportItems() : getImportItems(),
+                isExportHatch ? getExportFluids() : getImportFluids(), isExportHatch);
+    }
+
+    @Override
+    public IItemHandlerModifiable getImportItems() {
+        return actualImportItems == null ? super.getImportItems() : actualImportItems;
+    }
+
+    protected IFluidTank[] createTanks() {
+        int size = 1 + Math.min(GTValues.UHV, getTier());
+        IFluidTank[] tanks = new IFluidTank[size];
+        for (int index = 0; index < tanks.length; index++) {
+            tanks[index] = new NotifiableFluidTank(getTankSize(), null, isExportHatch);
+        }
+        return tanks;
+    }
+
+    protected int getItemSize() {
+        int sizeRoot = 1 + Math.min(GTValues.UHV, getTier());
+        return sizeRoot * sizeRoot;
+    }
+
+    protected int getTankSize() {
+        return 8_000 * Math.min(Integer.MAX_VALUE, 1 << getTier());
+    }
+
+    @Override
+    protected IItemHandlerModifiable createImportItemHandler() {
+        return isExportHatch ? new GTItemStackHandler(this, 0) :
+                new NotifiableItemStackHandler(this, getItemSize(), null, false);
+    }
+
+    @Override
+    protected IItemHandlerModifiable createExportItemHandler() {
+        return isExportHatch ? new NotifiableItemStackHandler(this, getItemSize(), null, true) :
+                new GTItemStackHandler(this, 0);
+    }
+
+    @Override
+    protected FluidTankList createImportFluidHandler() {
+        return isExportHatch ? new FluidTankList(false) : new FluidTankList(false, createTanks());
+    }
+
+    @Override
+    protected FluidTankList createExportFluidHandler() {
+        return isExportHatch ? new FluidTankList(false, createTanks()) : new FluidTankList(false);
+    }
+
+    @Override
+    public boolean hasGhostCircuitInventory() {
+        return !this.isExportHatch;
+    }
+
+    @Override
+    public void setGhostCircuitConfig(int config) {
+        if (this.circuitInventory == null || this.circuitInventory.getCircuitValue() == config) {
+            return;
+        }
+        this.circuitInventory.setCircuitValue(config);
+        if (!getWorld().isRemote) {
+            markDirty();
+        }
+    }
+
+    @Override
+    public @Nullable MultiblockAbility<IItemHandlerModifiable> getAbility() {
+        return isExportHatch ? MultiblockAbility.EXPORT_ITEMS : MultiblockAbility.IMPORT_ITEMS;
+    }
+
+    @Override
+    public void registerAbilities(@NotNull AbilityInstances abilityInstances) {
+        abilityInstances.add(dualHandler);
+    }
+
+    @Override
+    public boolean usesMui2() {
+        return true;
+    }
+
+    @SuppressWarnings("DuplicatedCode")
+    @Override
+    public ModularPanel buildUI(PosGuiData guiData, PanelSyncManager guiSyncManager) {
+        int rowSize = (int) Math.sqrt(getItemSize());
+        guiSyncManager.registerSlotGroup("item_inv", rowSize);
+
+        int backgroundWidth = Math.max(
+                9 * 18 + 18 + 14 + 5,   // Player Inv width
+                rowSize * 18 + 14 + 18); // Bus Inv width
+        int backgroundHeight = 18 + 18 * rowSize + 94;
+
+        List<List<IWidget>> widgets = new ArrayList<>();
+        for (int i = 0; i < rowSize; i++) {
+            widgets.add(new ArrayList<>());
+            for (int j = 0; j < rowSize; j++) {
+                int index = i * rowSize + j;
+                IItemHandlerModifiable handler = isExportHatch ? exportItems : importItems;
+                widgets.get(i).add(new ItemSlot()
+                        .slot(SyncHandlers.itemSlot(handler, index)
+                                .slotGroup("item_inv")
+                                .changeListener((newItem, onlyAmountChanged, client, init) -> {
+                                    if (onlyAmountChanged &&
+                                            handler instanceof GTItemStackHandler gtHandler) {
+                                        gtHandler.onContentsChanged(index);
+                                    }
+                                })
+                                .accessibility(!isExportHatch, true)));
+            }
+
+            IFluidTank tankHandler = (isExportHatch ? exportFluids : importFluids).getTankAt(i);
+            widgets.get(i).add(new GTFluidSlot()
+                    .syncHandler(GTFluidSlot.sync(tankHandler)
+                            .accessibility(true, !isExportHatch)));
+        }
+
+        BooleanSyncValue workingStateValue = new BooleanSyncValue(() -> workingEnabled, val -> workingEnabled = val);
+        guiSyncManager.syncValue("working_state", workingStateValue);
+        BooleanSyncValue collapseStateValue = new BooleanSyncValue(() -> autoCollapse, val -> autoCollapse = val);
+        guiSyncManager.syncValue("collapse_state", collapseStateValue);
+
+        boolean hasGhostCircuit = hasGhostCircuitInventory() && this.circuitInventory != null;
+
+        return GTGuis.createPanel(this, backgroundWidth, backgroundHeight)
+                .child(IKey.lang(getMetaFullName()).asWidget().pos(5, 5))
+                .child(SlotGroupWidget.playerInventory().left(7).bottom(7)).child(new Grid()
+                        .top(18).height(rowSize * 18)
+                        .minElementMargin(0, 0)
+                        .minColWidth(18).minRowHeight(18)
+                        .alignX(0.5f)
+                        .matrix(widgets))
+                .child(Flow.column()
+                        .pos(backgroundWidth - 7 - 18, backgroundHeight - 18 * 4 - 7 - 5)
+                        .width(18).height(18 * 4 + 5)
+                        .child(GTGuiTextures.getLogo(getUITheme()).asWidget().size(17).top(18 * 3 + 5))
+                        .child(new ToggleButton()
+                                .top(18 * 2)
+                                .value(new BoolValue.Dynamic(workingStateValue::getBoolValue,
+                                        workingStateValue::setBoolValue))
+                                .overlay(GTGuiTextures.BUTTON_ITEM_OUTPUT)
+                                .tooltipBuilder(t -> t.setAutoUpdate(true)
+                                        .addLine(isExportHatch ?
+                                                (workingStateValue.getBoolValue() ?
+                                                        IKey.lang("gregtech.gui.item_auto_output.tooltip.enabled") :
+                                                        IKey.lang("gregtech.gui.item_auto_output.tooltip.disabled")) :
+                                                (workingStateValue.getBoolValue() ?
+                                                        IKey.lang("gregtech.gui.item_auto_input.tooltip.enabled") :
+                                                        IKey.lang("gregtech.gui.item_auto_input.tooltip.disabled")))))
+                        .child(new ToggleButton()
+                                .top(18)
+                                .value(new BoolValue.Dynamic(collapseStateValue::getBoolValue,
+                                        collapseStateValue::setBoolValue))
+                                .overlay(GTGuiTextures.BUTTON_AUTO_COLLAPSE)
+                                .tooltipBuilder(t -> t.setAutoUpdate(true)
+                                        .addLine(collapseStateValue.getBoolValue() ?
+                                                IKey.lang("gregtech.gui.item_auto_collapse.tooltip.enabled") :
+                                                IKey.lang("gregtech.gui.item_auto_collapse.tooltip.disabled"))))
+                        .childIf(hasGhostCircuit, new GhostCircuitSlotWidget()
+                                .slot(SyncHandlers.itemSlot(circuitInventory, 0))
+                                .background(GTGuiTextures.SLOT, GTGuiTextures.INT_CIRCUIT_OVERLAY))
+                        .childIf(!hasGhostCircuit, new Widget<>()
+                                .background(GTGuiTextures.SLOT, GTGuiTextures.BUTTON_X)
+                                .tooltip(t -> t.addLine(
+                                        IKey.lang("gregtech.gui.configurator_slot.unavailable.tooltip")))));
+    }
+
+    @Override
+    public void renderMetaTileEntity(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
+        super.renderMetaTileEntity(renderState, translation, pipeline);
+        SimpleOverlayRenderer renderer = isExportHatch ? Textures.PIPE_OUT_OVERLAY : Textures.PIPE_IN_OVERLAY;
+        renderer.renderSided(getFrontFacing(), renderState, translation, pipeline);
+        SimpleOverlayRenderer overlay = isExportHatch ? Textures.ITEM_HATCH_OUTPUT_OVERLAY :
+                Textures.ITEM_HATCH_INPUT_OVERLAY;
+        overlay.renderSided(getFrontFacing(), renderState, translation, pipeline);
+    }
+
+    @Override
+    public void writeInitialSyncData(PacketBuffer buf) {
+        super.writeInitialSyncData(buf);
+        buf.writeBoolean(workingEnabled);
+        buf.writeBoolean(autoCollapse);
+    }
+
+    @Override
+    public void receiveInitialSyncData(PacketBuffer buf) {
+        super.receiveInitialSyncData(buf);
+        this.workingEnabled = buf.readBoolean();
+        this.autoCollapse = buf.readBoolean();
+    }
+
+    @Override
+    public void setWorkingEnabled(boolean workingEnabled) {
+        this.workingEnabled = workingEnabled;
+        World world = getWorld();
+        if (world != null && !world.isRemote) {
+            writeCustomData(GregtechDataCodes.WORKING_ENABLED, buf -> buf.writeBoolean(workingEnabled));
+        }
+    }
+
+    @Override
+    public boolean isWorkingEnabled() {
+        return workingEnabled;
+    }
+
+    @Override
+    public void receiveCustomData(int dataId, PacketBuffer buf) {
+        super.receiveCustomData(dataId, buf);
+        if (dataId == GregtechDataCodes.WORKING_ENABLED) {
+            this.workingEnabled = buf.readBoolean();
+        } else if (dataId == GregtechDataCodes.TOGGLE_COLLAPSE_ITEMS) {
+            this.autoCollapse = buf.readBoolean();
+        }
+    }
+
+    @Override
+    public NBTTagCompound writeToNBT(NBTTagCompound data) {
+        super.writeToNBT(data);
+
+        data.setBoolean("workingEnabled", workingEnabled);
+        data.setBoolean("autoCollapse", autoCollapse);
+
+        if (circuitInventory != null) {
+            circuitInventory.write(data);
+        }
+
+        return data;
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound data) {
+        super.readFromNBT(data);
+
+        this.workingEnabled = data.getBoolean("workingEnabled");
+        this.autoCollapse = data.getBoolean("autoCollapse");
+
+        if (circuitInventory != null) {
+            circuitInventory.read(data);
+        }
+    }
+
+    @Override
+    public void addInformation(ItemStack stack, @Nullable World player, @NotNull List<String> tooltip,
+                               boolean advanced) {
+        if (this.isExportHatch)
+            tooltip.add(I18n.format("gregtech.machine.item_bus.export.tooltip"));
+        else
+            tooltip.add(I18n.format("gregtech.machine.item_bus.import.tooltip"));
+        tooltip.add(I18n.format("gregtech.universal.tooltip.item_storage_capacity", getItemSize()));
+        tooltip.add(I18n.format("gregtech.universal.tooltip.fluid_storage_capacity", getTankSize()));
+        tooltip.add(I18n.format("gregtech.universal.enabled"));
+    }
+
+    @Override
+    public void addToolUsages(ItemStack stack, @Nullable World world, List<String> tooltip, boolean advanced) {
+        tooltip.add(I18n.format("gregtech.tool_action.screwdriver.access_covers"));
+        tooltip.add(I18n.format("gregtech.tool_action.screwdriver.auto_collapse"));
+        tooltip.add(I18n.format("gregtech.tool_action.wrench.set_facing"));
+        super.addToolUsages(stack, world, tooltip, advanced);
+    }
+}
diff --git a/src/main/resources/assets/gregtech/lang/en_us.lang b/src/main/resources/assets/gregtech/lang/en_us.lang
