steal PlayerInventoryGuiFactory from retro sophisticated backpacks with baubles compat

Author: brachy84

dependencies.gradle

@@ -23,4 +23,6 @@
  */
 dependencies {
     embed 'org.mariuszgromada.math:MathParser.org-mXparser:6.1.0'
+
+    implementation(rfg.deobf("curse.maven:baubles-227083:2518667"))
 }

src/main/java/com/cleanroommc/modularui/ModularUI.java

@@ -38,6 +38,7 @@ public class ModularUI {
     private static boolean blurLoaded = false;
     private static boolean sorterLoaded = false;
     private static boolean jeiLoaded = false;
+    private static boolean baubleLoaded = false;
 
     static {
         // confirm mXparser license
@@ -49,6 +50,7 @@ public void preInit(FMLPreInitializationEvent event) {
         blurLoaded = Loader.isModLoaded("blur");
         sorterLoaded = Loader.isModLoaded(BOGO_SORT);
         jeiLoaded = Loader.isModLoaded("jei");
+        baubleLoaded = Loader.isModLoaded("baubles");
         proxy.preInit(event);
     }
 
@@ -73,4 +75,8 @@ public static boolean isSortModLoaded() {
     public static boolean isJeiLoaded() {
         return jeiLoaded;
     }
+
+    public static boolean isBaubleLoaded() {
+        return baubleLoaded;
+    }
 }

src/main/java/com/cleanroommc/modularui/factory/AbstractUIFactory.java

@@ -8,12 +8,21 @@
 import com.cleanroommc.modularui.screen.UISettings;
 import com.cleanroommc.modularui.value.sync.PanelSyncManager;
 
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Objects;
 
 public abstract class AbstractUIFactory<T extends GuiData> implements UIFactory<T> {
 
+    protected static EntityPlayerMP verifyServerSide(EntityPlayer player) {
+        if (player == null) throw new NullPointerException("Can't open UI for null player!");
+        if (player instanceof EntityPlayerMP entityPlayerMP) return entityPlayerMP;
+        throw new IllegalStateException("Synced GUI must be opened from server side!");
+    }
+
     private final String name;
 
     protected AbstractUIFactory(String name) {

src/main/java/com/cleanroommc/modularui/factory/GuiFactories.java

@@ -16,10 +16,15 @@ public static SidedTileEntityGuiFactory sidedTileEntity() {
         return SidedTileEntityGuiFactory.INSTANCE;
     }
 
+    @Deprecated
     public static ItemGuiFactory item() {
         return ItemGuiFactory.INSTANCE;
     }
 
+    public static PlayerInventoryGuiFactory playerInventory() {
+        return PlayerInventoryGuiFactory.INSTANCE;
+    }
+
     public static SimpleGuiFactory createSimple(String name, IGuiHolder<GuiData> holder) {
         return new SimpleGuiFactory(name, holder);
     }
@@ -33,6 +38,7 @@ public static void init() {
         GuiManager.registerFactory(tileEntity());
         GuiManager.registerFactory(sidedTileEntity());
         GuiManager.registerFactory(item());
+        GuiManager.registerFactory(playerInventory());
     }
 
     private GuiFactories() {}

src/main/java/com/cleanroommc/modularui/factory/ItemGuiFactory.java

@@ -11,6 +11,7 @@
 
 import java.util.Objects;
 
+@Deprecated
 public class ItemGuiFactory extends AbstractUIFactory<HandGuiData> {
 
     public static final ItemGuiFactory INSTANCE = new ItemGuiFactory();

src/main/java/com/cleanroommc/modularui/factory/PlayerInventoryGuiData.java

@@ -0,0 +1,34 @@
+package com.cleanroommc.modularui.factory;
+
+import com.cleanroommc.modularui.factory.inventory.InventoryType;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+
+public class PlayerInventoryGuiData extends GuiData {
+
+    private final InventoryType inventoryType;
+    private final int slotIndex;
+
+    public PlayerInventoryGuiData(EntityPlayer player, InventoryType inventoryType, int slotIndex) {
+        super(player);
+        this.inventoryType = inventoryType;
+        this.slotIndex = slotIndex;
+    }
+
+    public InventoryType getInventoryType() {
+        return inventoryType;
+    }
+
+    public int getSlotIndex() {
+        return slotIndex;
+    }
+
+    public ItemStack getUsedItemStack() {
+        return getInventoryType().getStackInSlot(getPlayer(), this.slotIndex);
+    }
+
+    public void setUsedItemStack(ItemStack stack) {
+        getInventoryType().setStackInSlot(getPlayer(), this.slotIndex, stack);
+    }
+}

src/main/java/com/cleanroommc/modularui/factory/PlayerInventoryGuiFactory.java

@@ -0,0 +1,62 @@
+package com.cleanroommc.modularui.factory;
+
+import com.cleanroommc.modularui.ModularUI;
+import com.cleanroommc.modularui.api.IGuiHolder;
+import com.cleanroommc.modularui.factory.inventory.InventoryType;
+
+import com.cleanroommc.modularui.factory.inventory.InventoryTypes;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.network.PacketBuffer;
+
+import net.minecraft.util.EnumHand;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public class PlayerInventoryGuiFactory extends AbstractUIFactory<PlayerInventoryGuiData> {
+
+    public static final PlayerInventoryGuiFactory INSTANCE = new PlayerInventoryGuiFactory();
+
+    public void openFromPlayerInventory(EntityPlayer player, int index) {
+        GuiManager.open(
+                this, new PlayerInventoryGuiData(player, InventoryTypes.PLAYER, index), verifyServerSide(player));
+    }
+
+    public void openFromHand(EntityPlayer player, EnumHand hand) {
+        openFromPlayerInventory(player, hand == EnumHand.OFF_HAND ? 40 : player.inventory.currentItem);
+    }
+
+    public void openFromBaubles(EntityPlayer player, int index) {
+        if (!ModularUI.isBaubleLoaded()) {
+            throw new IllegalArgumentException("Can't open UI for baubles item when bauble is not loaded!");
+        }
+        GuiManager.open(
+                this, new PlayerInventoryGuiData(player, InventoryTypes.BAUBLES, index), verifyServerSide(player));
+    }
+
+    public void open(EntityPlayer player, InventoryType type, int index) {
+        GuiManager.open(this, new PlayerInventoryGuiData(player, type, index), verifyServerSide(player));
+    }
+
+    private PlayerInventoryGuiFactory() {
+        super("mui:player_inv");
+    }
+
+    @Override
+    public @NotNull IGuiHolder<PlayerInventoryGuiData> getGuiHolder(PlayerInventoryGuiData data) {
+        return Objects.requireNonNull(castGuiHolder(data.getUsedItemStack().getItem()), "Item was not a gui holder!");
+    }
+
+    @Override
+    public void writeGuiData(PlayerInventoryGuiData guiData, PacketBuffer buffer) {
+        guiData.getInventoryType().write(buffer);
+        buffer.writeVarInt(guiData.getSlotIndex());
+    }
+
+    @Override
+    public @NotNull PlayerInventoryGuiData readGuiData(EntityPlayer player, PacketBuffer buffer) {
+        return new PlayerInventoryGuiData(player, InventoryType.read(buffer), buffer.readVarInt());
+    }
+}

src/main/java/com/cleanroommc/modularui/factory/inventory/Inventory.java

@@ -0,0 +1,29 @@
+package com.cleanroommc.modularui.factory.inventory;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+
+public abstract class Inventory extends InventoryType {
+
+    public Inventory(String id) {
+        super(id);
+    }
+
+    public abstract IInventory getInventory(EntityPlayer player);
+
+    @Override
+    public ItemStack getStackInSlot(EntityPlayer player, int index) {
+        return getInventory(player).getStackInSlot(index);
+    }
+
+    @Override
+    public void setStackInSlot(EntityPlayer player, int index, ItemStack stack) {
+        getInventory(player).setInventorySlotContents(index, stack);
+    }
+
+    @Override
+    public int getSlotCount(EntityPlayer player) {
+        return getInventory(player).getSizeInventory();
+    }
+}

src/main/java/com/cleanroommc/modularui/factory/inventory/InventoryType.java

@@ -0,0 +1,134 @@
+package com.cleanroommc.modularui.factory.inventory;
+
+import com.cleanroommc.modularui.network.NetworkUtils;
+
+import com.cleanroommc.modularui.utils.Platform;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.PacketBuffer;
+import net.minecraftforge.items.ItemHandlerHelper;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+
+/**
+ * A way of finding and setting an item in an inventory, that is owned by a player.
+ * This includes the normal player inventory with all its slots including main hand, off-hand and armor slots.
+ * It can also be used for bauble inventory if baubles is loaded.
+ * An inventory type has an id assigned used for syncing. It is crucial, types are created in the same order on client and server.
+ * Currently, the amount of types is limited to 16, but I don't think we will ever fill that.
+ * @see InventoryTypes InventoryTypes for default implementations
+ */
+public abstract class InventoryType {
+
+    private static final Map<String, InventoryType> inventoryTypes = new Object2ObjectOpenHashMap<>();
+
+    private final String id;
+
+    public InventoryType(String id) {
+        this.id = id;
+        inventoryTypes.put(id, this);
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public abstract ItemStack getStackInSlot(EntityPlayer player, int index);
+
+    public abstract void setStackInSlot(EntityPlayer player, int index, ItemStack stack);
+
+    public abstract int getSlotCount(EntityPlayer player);
+
+    public int findFirstStackable(EntityPlayer player, ItemStack stack) {
+        for (int i = 0, n = getSlotCount(player); i < n; ++i) {
+            ItemStack stackInSlot = getStackInSlot(player, i);
+            if (Platform.isStackEmpty(stackInSlot)) {
+                if (Platform.isStackEmpty(stack)) {
+                    return i;
+                }
+                continue;
+            }
+            if (ItemHandlerHelper.canItemStacksStack(stackInSlot, stack)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    public boolean visitAllStackable(EntityPlayer player, ItemStack stack, InventoryVisitor visitor) {
+        for (int i = 0, n = getSlotCount(player); i < n; ++i) {
+            ItemStack stackInSlot = getStackInSlot(player, i);
+            if (Platform.isStackEmpty(stackInSlot)) {
+                if (Platform.isStackEmpty(stack)) {
+                    if (visitor.visit(this, i, stackInSlot)) {
+                        return true;
+                    }
+                }
+                continue;
+            }
+            if (ItemHandlerHelper.canItemStacksStack(stackInSlot, stack)) {
+                if (visitor.visit(this, i, stackInSlot)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    public boolean visitAll(EntityPlayer player, InventoryVisitor visitor) {
+        for (int i = 0, n = getSlotCount(player); i < n; ++i) {
+            ItemStack stackInSlot = getStackInSlot(player, i);
+            if (visitor.visit(this, i, stackInSlot)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void write(PacketBuffer buf) {
+        NetworkUtils.writeStringSafe(buf, id);
+    }
+
+    public static InventoryType read(PacketBuffer buf) {
+        return getFromId(NetworkUtils.readStringSafe(buf));
+    }
+
+    public static InventoryType getFromId(String id) {
+        return inventoryTypes.get(id);
+    }
+
+    public static Collection<InventoryType> getAll() {
+        return Collections.unmodifiableCollection(inventoryTypes.values());
+    }
+
+    public static Pair<InventoryType, Integer> findFirstStackableInAll(EntityPlayer player, ItemStack stack) {
+        for (InventoryType type : getAll()) {
+            int i = type.findFirstStackable(player, stack);
+            if (i >= 0) return Pair.of(type, i);
+        }
+        return null;
+    }
+
+    public static void visitAllStackableInAll(EntityPlayer player, ItemStack stack, InventoryVisitor visitor) {
+        for (InventoryType type : getAll()) {
+            if (type.visitAllStackable(player, stack, visitor)) {
+                return;
+            }
+        }
+    }
+
+    public static void visitAllInAll(EntityPlayer player, InventoryVisitor visitor) {
+        for (InventoryType type : getAll()) {
+            if (type.visitAll(player, visitor)) {
+                return;
+            }
+        }
+    }
+}

src/main/java/com/cleanroommc/modularui/factory/inventory/InventoryTypes.java

@@ -0,0 +1,29 @@
+package com.cleanroommc.modularui.factory.inventory;
+
+import baubles.api.BaublesApi;
+
+import com.cleanroommc.modularui.ModularUI;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraftforge.items.IItemHandlerModifiable;
+
+public class InventoryTypes {
+
+    public static final InventoryType PLAYER = new Inventory("player") {
+        @Override
+        public IInventory getInventory(EntityPlayer player) {
+            return player.inventory;
+        }
+    };
+
+    public static final InventoryType BAUBLES = new ItemHandler("baubles") {
+        @Override
+        public IItemHandlerModifiable getInventory(EntityPlayer player) {
+            if (ModularUI.isBaubleLoaded()) {
+                return BaublesApi.getBaublesHandler(player);
+            }
+            throw new IllegalArgumentException("Tried to receive bauble item, but bauble is not loaded");
+        }
+    };
+}