[MUI2] Programmed Circuit (#4311)

Author: TarLaboratories

src/main/java/com/gregtechceu/gtceu/api/item/ComponentItem.java

@@ -1,9 +1,15 @@
 package com.gregtechceu.gtceu.api.item;
 
+import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.IElectricItem;
 import com.gregtechceu.gtceu.api.item.capability.ElectricItem;
 import com.gregtechceu.gtceu.api.item.component.*;
+import com.gregtechceu.gtceu.api.mui.base.IItemUIHolder;
+import com.gregtechceu.gtceu.api.mui.factory.PlayerInventoryGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 
 import com.lowdragmc.lowdraglib.client.renderer.IItemRendererProvider;
 import com.lowdragmc.lowdraglib.client.renderer.IRenderer;
@@ -49,7 +55,8 @@
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
 public class ComponentItem extends Item
-                           implements HeldItemUIFactory.IHeldItemUIHolder, IItemRendererProvider, IComponentItem {
+                           implements HeldItemUIFactory.IHeldItemUIHolder, IItemRendererProvider, IComponentItem,
+                           IItemUIHolder {
 
     protected int burnTime = -1;
 
@@ -443,4 +450,24 @@ public ItemStack getInfiniteChargedStack() {
         electricItem.setInfiniteCharge(true);
         return itemStack;
     }
+
+    @Override
+    public @Nullable ModularPanel buildUI(PlayerInventoryGuiData<?> data, PanelSyncManager syncManager,
+                                          UISettings settings) {
+        for (IItemComponent component : getComponents()) {
+            if (component instanceof IItemUIHolder uiHolder) {
+                return uiHolder.buildUI(data, syncManager, settings);
+            }
+        }
+        GTCEu.LOGGER.error("Tried to get UI of {} item when it does not have one!", data.getUsedItemStack());
+        return null;
+    }
+
+    @Override
+    public boolean shouldOpenUI() {
+        for (IItemComponent component : getComponents()) {
+            if (component instanceof IItemUIHolder holder) return holder.shouldOpenUI();
+        }
+        return false;
+    }
 }

src/main/java/com/gregtechceu/gtceu/api/mui/base/IItemUIHolder.java

@@ -0,0 +1,39 @@
+package com.gregtechceu.gtceu.api.mui.base;
+
+import com.gregtechceu.gtceu.api.item.component.IInteractionItem;
+import com.gregtechceu.gtceu.api.mui.factory.PlayerInventoryGuiData;
+import com.gregtechceu.gtceu.api.mui.factory.PlayerInventoryUIFactory;
+
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.InteractionResultHolder;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.context.UseOnContext;
+import net.minecraft.world.level.Level;
+
+public interface IItemUIHolder extends IUIHolder<PlayerInventoryGuiData<?>>, IInteractionItem {
+
+    default boolean shouldOpenUI() {
+        return true;
+    }
+
+    @Override
+    default InteractionResultHolder<ItemStack> use(Item item, Level level, Player player, InteractionHand usedHand) {
+        if (!shouldOpenUI())
+            return IInteractionItem.super.use(item, level, player, usedHand);
+        if (level.isClientSide)
+            PlayerInventoryUIFactory.INSTANCE.openFromHandClient(usedHand);
+        return InteractionResultHolder.sidedSuccess(player.getItemInHand(usedHand), level.isClientSide);
+    }
+
+    @Override
+    default InteractionResult useOn(UseOnContext context) {
+        if (!shouldOpenUI())
+            return IInteractionItem.super.useOn(context);
+        if (context.getLevel().isClientSide)
+            PlayerInventoryUIFactory.INSTANCE.openFromHandClient(context.getHand());
+        return InteractionResult.SUCCESS;
+    }
+}

src/main/java/com/gregtechceu/gtceu/common/data/mui/GTMuiWidgets.java

@@ -3,6 +3,7 @@
 import com.gregtechceu.gtceu.api.machine.MachineDefinition;
 import com.gregtechceu.gtceu.api.machine.SimpleTieredMachine;
 import com.gregtechceu.gtceu.api.machine.feature.IAutoOutputItem;
+import com.gregtechceu.gtceu.api.machine.feature.IHasCircuitSlot;
 import com.gregtechceu.gtceu.api.machine.feature.IRecipeLogicMachine;
 import com.gregtechceu.gtceu.api.mui.base.IPanelHandler;
 import com.gregtechceu.gtceu.api.mui.base.drawable.IDrawable;
@@ -38,6 +39,8 @@
 import it.unimi.dsi.fastutil.booleans.BooleanConsumer;
 
 import java.util.function.BooleanSupplier;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
 
 public class GTMuiWidgets {
 
@@ -170,16 +173,17 @@ public static ToggleButton createInputFromOutputFluid(SimpleTieredMachine machin
                                 "cover.voiding.label.disabled")))));
     }
 
-    public static ButtonWidget<?> createCircuitSlotPanel(SimpleTieredMachine machine, ModularPanel parentPanel,
-                                                         PanelSyncManager syncManager) {
-        IntSyncValue circuitSyncValue = new IntSyncValue(() -> {
-            if (machine.getCircuitInventory().getStackInSlot(0).isEmpty()) return -1;
-            return IntCircuitBehaviour.getCircuitConfiguration(machine.getCircuitInventory().getStackInSlot(0));
+    private static IntSyncValue createCircuitSlotSyncValue(Consumer<ItemStack> circuitSetter,
+                                                           Supplier<ItemStack> circuitGetter) {
+        return new IntSyncValue(() -> {
+            if (circuitGetter.get().isEmpty()) return -1;
+            return IntCircuitBehaviour.getCircuitConfiguration(circuitGetter.get());
         },
-                (v) -> machine.getCircuitInventory().setStackInSlot(0,
-                        (v < 0 ? ItemStack.EMPTY : IntCircuitBehaviour.stack(v))));
-        syncManager.syncValue("circuit_slot", circuitSyncValue);
+                (v) -> circuitSetter.accept(v < 0 ? ItemStack.EMPTY : IntCircuitBehaviour.stack(v)));
+    }
 
+    public static ModularPanel createCircuitSlotPanel(IntSyncValue circuitSyncValue, PanelSyncManager syncManager) {
+        syncManager.syncValue("circuit_slot", circuitSyncValue);
         Grid buttonGrid = new Grid()
                 .coverChildren()
                 .mapTo(8, 32, i -> new ToggleButton()
@@ -191,12 +195,10 @@ public static ButtonWidget<?> createCircuitSlotPanel(SimpleTieredMachine machine
                                     if (v) circuitSyncValue.setValue(i + 1);
                                 })));
 
-        ModularPanel circuitPanel = new Dialog<>("circuit_panel")
+        return new Dialog<>("circuit_panel")
                 .setDisablePanelsBelow(false)
                 .setDraggable(true)
                 .setCloseOnOutOfBoundsClick(true)
-                .relative(parentPanel)
-                .leftRelOffset(0.0f, -180)
                 .height(105)
                 .child(new Column()
                         .padding(2)
@@ -207,7 +209,24 @@ public static ButtonWidget<?> createCircuitSlotPanel(SimpleTieredMachine machine
                         .alignX(Alignment.Center)
                         .child(IKey.lang("item.gtceu.circuit.integrated.gui").asWidget())
                         .child(buttonGrid));
+    }
+
+    public static ModularPanel createCircuitSlotPanel(Consumer<ItemStack> circuitSetter,
+                                                      Supplier<ItemStack> circuitGetter, PanelSyncManager syncManager) {
+        IntSyncValue circuitSyncValue = createCircuitSlotSyncValue(circuitSetter, circuitGetter);
+        return createCircuitSlotPanel(circuitSyncValue, syncManager);
+    }
 
+    public static ButtonWidget<?> createCircuitSlotPanel(IHasCircuitSlot machine, ModularPanel parentPanel,
+                                                         PanelSyncManager syncManager) {
+        IntSyncValue circuitSyncValue = createCircuitSlotSyncValue(
+                i -> machine.getCircuitInventory().setStackInSlot(0, i),
+                () -> machine.getCircuitInventory().getStackInSlot(0));
+        ModularPanel circuitPanel = createCircuitSlotPanel(
+                circuitSyncValue,
+                syncManager)
+                .relative(parentPanel)
+                .leftRelOffset(0.0f, -180);
         IPanelHandler circuitPanelHandler = syncManager.panel("circuit_panel",
                 (sm, sh) -> circuitPanel, true);
 

src/main/java/com/gregtechceu/gtceu/common/item/IntCircuitBehaviour.java

@@ -1,39 +1,28 @@
 package com.gregtechceu.gtceu.common.item;
 
-import com.gregtechceu.gtceu.api.blockentity.MetaMachineBlockEntity;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.item.component.IAddInformation;
-import com.gregtechceu.gtceu.api.item.component.IItemUIFactory;
-import com.gregtechceu.gtceu.api.machine.feature.IHasCircuitSlot;
-import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
-import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
+import com.gregtechceu.gtceu.api.mui.base.IItemUIHolder;
+import com.gregtechceu.gtceu.api.mui.factory.PlayerInventoryGuiData;
+import com.gregtechceu.gtceu.api.mui.value.sync.PanelSyncManager;
+import com.gregtechceu.gtceu.client.mui.screen.ModularPanel;
+import com.gregtechceu.gtceu.client.mui.screen.UISettings;
 import com.gregtechceu.gtceu.common.data.GTItems;
-import com.gregtechceu.gtceu.config.ConfigHolder;
+import com.gregtechceu.gtceu.common.data.mui.GTMuiWidgets;
 
 import com.lowdragmc.lowdraglib.gui.factory.HeldItemUIFactory;
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.ItemStackTexture;
-import com.lowdragmc.lowdraglib.gui.widget.ButtonWidget;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
 
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.chat.Component;
 import net.minecraft.util.Mth;
-import net.minecraft.world.InteractionResult;
-import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.TooltipFlag;
-import net.minecraft.world.item.context.UseOnContext;
 import net.minecraft.world.level.Level;
-import net.minecraft.world.level.block.entity.BlockEntity;
 
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-public class IntCircuitBehaviour implements IItemUIFactory, IAddInformation {
+public class IntCircuitBehaviour implements IAddInformation, IItemUIHolder {
 
     public static final int CIRCUIT_MAX = 32;
 
@@ -43,11 +32,6 @@ public static ItemStack stack(int configuration) {
         return stack;
     }
 
-    public static void setCircuitConfiguration(HeldItemUIFactory.HeldItemHolder holder, int configuration) {
-        setCircuitConfiguration(holder.getHeld(), configuration);
-        holder.markAsDirty();
-    }
-
     public static void setCircuitConfiguration(ItemStack itemStack, int configuration) {
         if (configuration < 0 || configuration > CIRCUIT_MAX)
             throw new IllegalArgumentException("Given configuration number is out of range!");
@@ -99,61 +83,7 @@ public void appendHoverText(ItemStack stack, @Nullable Level level, List<Compone
     }
 
     @Override
-    public ModularUI createUI(HeldItemUIFactory.HeldItemHolder holder, Player entityPlayer) {
-        LabelWidget label = new LabelWidget(9, 8, "Programmed Circuit Configuration");
-        label.setDropShadow(false);
-        label.setTextColor(0x404040);
-        var modular = new ModularUI(184, 132, holder, entityPlayer)
-                .widget(label);
-        SlotWidget slotwidget = new SlotWidget(
-                new CustomItemStackHandler(stack(getCircuitConfiguration(holder.getHeld()))),
-                0, 82, 20, false, false);
-        slotwidget.setBackground(GuiTextures.SLOT);
-        modular.widget(slotwidget);
-        int idx = 0;
-        for (int x = 0; x <= 2; x++) {
-            for (int y = 0; y <= 8; y++) {
-                int finalIdx = idx;
-                modular.widget(new ButtonWidget(10 + (18 * y), 48 + (18 * x), 18, 18,
-                        new GuiTextureGroup(GuiTextures.SLOT, new ItemStackTexture(stack(finalIdx)).scale(16f / 18)),
-                        data -> {
-                            setCircuitConfiguration(holder, finalIdx);
-                            slotwidget.setHandlerSlot(new CustomItemStackHandler(stack(finalIdx)), 0);
-                        }));
-                idx++;
-            }
-        }
-        for (int x = 0; x <= 5; x++) {
-            int finalIdx = x + 27;
-            modular.widget(new ButtonWidget(10 + (18 * x), 102, 18, 18,
-                    new GuiTextureGroup(GuiTextures.SLOT, new ItemStackTexture(stack(finalIdx)).scale(16f / 18)),
-                    data -> {
-                        setCircuitConfiguration(holder, finalIdx);
-                        slotwidget.setHandlerSlot(new CustomItemStackHandler(stack(finalIdx)), 0);
-                    }));
-        }
-        modular.mainGroup.setBackground(GuiTextures.BACKGROUND);
-        return modular;
-    }
-
-    @Override
-    public InteractionResult useOn(UseOnContext context) {
-        var stack = context.getItemInHand();
-        int circuitSetting = getCircuitConfiguration(stack);
-        BlockEntity entity = context.getLevel().getBlockEntity(context.getClickedPos());
-        if (entity instanceof MetaMachineBlockEntity machineEntity && context.isSecondaryUseActive()) {
-            if (machineEntity.metaMachine instanceof IHasCircuitSlot circuitMachine &&
-                    circuitMachine.getCircuitInventory().getSlots() > 0) {
-                setCircuitConfig(circuitMachine.getCircuitInventory(), circuitSetting);
-            }
-            if (!ConfigHolder.INSTANCE.machines.ghostCircuit)
-                stack.shrink(1);
-            return InteractionResult.SUCCESS;
-        }
-        return IItemUIFactory.super.useOn(context);
-    }
-
-    void setCircuitConfig(NotifiableItemStackHandler circuit, int value) {
-        circuit.setStackInSlot(0, IntCircuitBehaviour.stack(value));
+    public ModularPanel buildUI(PlayerInventoryGuiData<?> data, PanelSyncManager syncManager, UISettings settings) {
+        return GTMuiWidgets.createCircuitSlotPanel(data::setUsedItemStack, data::getUsedItemStack, syncManager);
     }
 }