fine ironman

1 files changed, 357 insertions, 0 deletions

diff --git a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/SlotLocking.java b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/SlotLocking.java
new file mode 100644
index 00000000..99ab6a84
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/SlotLocking.java
@@ -0,0 +1,357 @@
+package io.github.moulberry.notenoughupdates.miscfeatures;
+
+import com.google.gson.JsonObject;
+import io.github.moulberry.notenoughupdates.NotEnoughUpdates;
+import io.github.moulberry.notenoughupdates.core.config.KeybindHelper;
+import io.github.moulberry.notenoughupdates.core.util.render.RenderUtils;
+import io.github.moulberry.notenoughupdates.util.SBInfo;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Gui;
+import net.minecraft.client.gui.ScaledResolution;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.RenderHelper;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.WorldRenderer;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.inventory.Slot;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.event.GuiScreenEvent;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import org.apache.commons.lang3.tuple.Triple;
+import org.lwjgl.input.Keyboard;
+import org.lwjgl.input.Mouse;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.util.vector.Vector2f;
+import org.lwjgl.util.vector.Vector3f;
+
+import java.util.HashMap;
+import java.util.function.Consumer;
+
+public class SlotLocking {
+
+    private static final SlotLocking INSTANCE = new SlotLocking();
+
+    private static final LockedSlot DEFAULT_LOCKED_SLOT = new LockedSlot();
+    private final ResourceLocation LOCK = new ResourceLocation("notenoughupdates:slotlocking/lock.png");
+
+    public static SlotLocking getInstance() {
+        return INSTANCE;
+    }
+
+    public static class LockedSlot {
+        public boolean locked = false;
+        public int boundTo = -1;
+    }
+
+    public static class SlotLockData {
+        public LockedSlot[] lockedSlots = new LockedSlot[40];
+    }
+
+    public static class SlotLockProfile {
+        int currentProfile = 0;
+
+        public SlotLockData[] slotLockData = new SlotLockData[9];
+    }
+
+    public static class SlotLockingConfig {
+        public HashMap<String, SlotLockProfile> profileData = new HashMap<>();
+    }
+
+    private SlotLockingConfig config = new SlotLockingConfig();
+    private boolean lockKeyHeld = false;
+    private Slot pairingSlot = null;
+
+    private LockedSlot[] getDataForProfile() {
+        if(!NotEnoughUpdates.INSTANCE.hasSkyblockScoreboard()) return null;
+        if(SBInfo.getInstance().currentProfile == null) return null;
+
+        SlotLockProfile profile = config.profileData.computeIfAbsent(SBInfo.getInstance().currentProfile,
+                k->new SlotLockProfile());
+
+        if(profile.currentProfile < 0) profile.currentProfile = 0;
+        if(profile.currentProfile >= 9) profile.currentProfile = 8;
+
+        if(profile.slotLockData[profile.currentProfile] == null) {
+            profile.slotLockData[profile.currentProfile] = new SlotLockData();
+        }
+
+        return profile.slotLockData[profile.currentProfile].lockedSlots;
+    }
+
+    private LockedSlot getLockedSlot(LockedSlot[] lockedSlots, int index) {
+        if(lockedSlots == null) {
+            return DEFAULT_LOCKED_SLOT;
+        }
+
+        LockedSlot slot = lockedSlots[index];
+
+        if(slot == null) {
+            return DEFAULT_LOCKED_SLOT;
+        }
+
+        return slot;
+    }
+
+    @SubscribeEvent
+    public void keyboardInput(GuiScreenEvent.KeyboardInputEvent.Post event) {
+        if(!NotEnoughUpdates.INSTANCE.hasSkyblockScoreboard()) {
+            return;
+        }
+        if(!(Minecraft.getMinecraft().currentScreen instanceof GuiContainer)) {
+            return;
+        }
+        GuiContainer container = (GuiContainer) Minecraft.getMinecraft().currentScreen;
+
+        int key = Keyboard.KEY_L;
+        if(!lockKeyHeld && KeybindHelper.isKeyPressed(key)) {
+            final ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+            final int scaledWidth = scaledresolution.getScaledWidth();
+            final int scaledHeight = scaledresolution.getScaledHeight();
+            int mouseX = Mouse.getX() * scaledWidth / Minecraft.getMinecraft().displayWidth;
+            int mouseY = scaledHeight - Mouse.getY() * scaledHeight / Minecraft.getMinecraft().displayHeight - 1;
+
+            Slot slot = container.getSlotAtPosition(mouseX, mouseY);
+            if(slot != null && slot.inventory == Minecraft.getMinecraft().thePlayer.inventory) {
+                int slotNum = slot.getSlotIndex();
+                if(slotNum >= 0 && slotNum <= 39) {
+                    boolean isHotbar = slotNum < 9;
+                    boolean isInventory = !isHotbar && slotNum < 36;
+                    boolean isArmor = !isHotbar && !isInventory;
+
+                    if(isInventory || isArmor) {
+                        pairingSlot = slot;
+                    } else {
+                        pairingSlot = null;
+                    }
+
+                    LockedSlot[] lockedSlots = getDataForProfile();
+
+                    if(lockedSlots != null) {
+                        if(lockedSlots[slotNum] == null) {
+                            lockedSlots[slotNum] = new LockedSlot();
+                            lockedSlots[slotNum].locked = true;
+                            lockedSlots[slotNum].boundTo = -1;
+                        } else {
+                            lockedSlots[slotNum].locked = !lockedSlots[slotNum].locked;
+                            lockedSlots[slotNum].boundTo = -1;
+                        }
+                    }
+                }
+            }
+        }
+        lockKeyHeld = KeybindHelper.isKeyDown(key);
+        if(!lockKeyHeld) {
+            pairingSlot = null;
+        }
+    }
+
+    @SubscribeEvent
+    public void mouseEvent(GuiScreenEvent.MouseInputEvent event) {
+        if(!NotEnoughUpdates.INSTANCE.hasSkyblockScoreboard()) {
+            return;
+        }
+        if(!(Minecraft.getMinecraft().currentScreen instanceof GuiContainer)) {
+            return;
+        }
+        GuiContainer container = (GuiContainer) Minecraft.getMinecraft().currentScreen;
+
+        if(lockKeyHeld && pairingSlot != null) {
+            final ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+            final int scaledWidth = scaledresolution.getScaledWidth();
+            final int scaledHeight = scaledresolution.getScaledHeight();
+            int mouseX = Mouse.getX() * scaledWidth / Minecraft.getMinecraft().displayWidth;
+            int mouseY = scaledHeight - Mouse.getY() * scaledHeight / Minecraft.getMinecraft().displayHeight - 1;
+
+            Slot slot = container.getSlotAtPosition(mouseX, mouseY);
+            if(slot != null && slot.inventory == Minecraft.getMinecraft().thePlayer.inventory) {
+                int slotNum = slot.getSlotIndex();
+                if(slotNum >= 0 && slotNum <= 39) {
+                    boolean isHotbar = slotNum < 9;
+                    boolean isInventory = !isHotbar && slotNum < 36;
+                    boolean isArmor = !isHotbar && !isInventory;
+
+                    int pairingNum = pairingSlot.getSlotIndex();
+                    if(isHotbar && slotNum != pairingNum) {
+                        LockedSlot[] lockedSlots = getDataForProfile();
+                        if(lockedSlots != null) {
+                            if(lockedSlots[pairingNum] == null) {
+                                lockedSlots[pairingNum] = new LockedSlot();
+                            }
+                            lockedSlots[pairingNum].boundTo = slotNum;
+                            lockedSlots[pairingNum].locked = false;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+
+    @SubscribeEvent(priority = EventPriority.LOW)
+    public void drawScreenEvent(GuiScreenEvent.DrawScreenEvent.Post event) {
+        if(!event.isCanceled() && pairingSlot != null && lockKeyHeld) {
+            if(!(Minecraft.getMinecraft().currentScreen instanceof GuiContainer)) {
+                return;
+            }
+            GuiContainer container = (GuiContainer) Minecraft.getMinecraft().currentScreen;
+
+            int x2 = event.mouseX;
+            int y2 = event.mouseY;
+
+            LockedSlot[] lockedSlots = getDataForProfile();
+            LockedSlot lockedSlot = getLockedSlot(lockedSlots, pairingSlot.getSlotIndex());
+            if(lockedSlot.boundTo >= 0 && lockedSlot.boundTo < 9) {
+                Slot boundSlot = container.inventorySlots.getSlotFromInventory(Minecraft.getMinecraft().thePlayer.inventory, lockedSlot.boundTo);
+                x2 = container.guiLeft+boundSlot.xDisplayPosition+8;
+                y2 = container.guiTop+boundSlot.yDisplayPosition+8;
+            }
+
+            drawLinkArrow(container.guiLeft+pairingSlot.xDisplayPosition+8,
+                    container.guiTop+pairingSlot.yDisplayPosition+8,
+                    x2, y2);
+        }
+    }
+
+    private void drawLinkArrow(int x1, int y1, int x2, int y2) {
+        GlStateManager.color(0x33/255f, 0xff/255f, 0xcc/255f, 1f);
+        GlStateManager.disableLighting();
+        RenderHelper.disableStandardItemLighting();
+        GlStateManager.disableTexture2D();
+        GlStateManager.enableBlend();
+        GlStateManager.tryBlendFuncSeparate(770, 771, 1, 0);
+
+        GlStateManager.translate(0, 0, 500);
+        drawLine(x1, y1, x2, y2);
+        GlStateManager.translate(0, 0, -500);
+
+        GlStateManager.enableTexture2D();
+    }
+
+    private void drawLine(int x1, int y1, int x2, int y2) {
+        Vector2f vec = new Vector2f(x2 - x1, y2 - y1);
+        vec.normalise(vec);
+        Vector2f side = new Vector2f(vec.y, -vec.x);
+
+        GL11.glLineWidth(1f);
+        GL11.glEnable(GL11.GL_LINE_SMOOTH);
+
+        /*worldrenderer.begin(GL11.GL_TRIANGLE_STRIP, DefaultVertexFormats.POSITION);
+        worldrenderer.pos(x1, y1, 0.0D).endVertex();
+        worldrenderer.pos(x1+vec.x-side.x, y1+vec.y-side.y, 0.0D).endVertex();
+        worldrenderer.pos(x1+vec.x+side.x, y1+vec.y+side.y, 0.0D).endVertex();
+        worldrenderer.pos(x2-vec.x-side.x, y2-vec.y-side.y, 0.0D).endVertex();
+        worldrenderer.pos(x2-vec.x+side.x, y2-vec.y+side.y, 0.0D).endVertex();
+        worldrenderer.pos(x2, y2, 0.0D).endVertex();*/
+
+        Tessellator tessellator = Tessellator.getInstance();
+        WorldRenderer worldrenderer = tessellator.getWorldRenderer();
+        worldrenderer.begin(GL11.GL_LINES, DefaultVertexFormats.POSITION);
+        worldrenderer.pos(x1, y1, 0.0D).endVertex();
+        worldrenderer.pos(x2, y2, 0.0D).endVertex();
+        tessellator.draw();
+
+        worldrenderer.begin(GL11.GL_LINES, DefaultVertexFormats.POSITION);
+        worldrenderer.pos(x1-side.x/2f, y1-side.y/2f, 0.0D).endVertex();
+        worldrenderer.pos(x2-side.x/2f, y2-side.y/2f, 0.0D).endVertex();
+        tessellator.draw();
+
+        worldrenderer.begin(GL11.GL_LINES, DefaultVertexFormats.POSITION);
+        worldrenderer.pos(x1+side.x/2f, y1+side.y/2f, 0.0D).endVertex();
+        worldrenderer.pos(x2+side.x/2f, y2+side.y/2f, 0.0D).endVertex();
+        tessellator.draw();
+    }
+
+    public void onWindowClick(Slot slotIn, int slotId, int clickedButton, int clickType, Consumer<Triple<Integer, Integer, Integer>> consumer) {
+        LockedSlot locked = getLockedSlot(slotIn);
+        if(locked == null) {
+            return;
+        } else if(isSlotLocked(slotIn) || (clickType == 2 && SlotLocking.getInstance().isSlotIndexLocked(clickedButton))) {
+            consumer.accept(null);
+        } else if(clickType == 1 && locked.boundTo >= 0 && locked.boundTo < 9) {
+            if(slotId > 9) {
+                consumer.accept(Triple.of(slotId, locked.boundTo, 2));
+
+                GuiContainer container = (GuiContainer) Minecraft.getMinecraft().currentScreen;
+                Slot boundSlot = container.inventorySlots.getSlotFromInventory(Minecraft.getMinecraft().thePlayer.inventory, locked.boundTo);
+
+                LockedSlot boundLocked = getLockedSlot(boundSlot);
+
+
+            }
+
+        }
+    }
+
+    public void drawSlot(Slot slot) {
+        LockedSlot locked = getLockedSlot(slot);
+        if(locked != null) {
+            if(locked.locked) {
+                GlStateManager.translate(0, 0, 400);
+                Minecraft.getMinecraft().getTextureManager().bindTexture(LOCK);
+                GlStateManager.color(1, 1, 1, 0.5f);
+                GlStateManager.depthMask(false);
+                RenderUtils.drawTexturedRect(slot.xDisplayPosition, slot.yDisplayPosition, 16, 16, 0, 1, 0, 1, GL11.GL_NEAREST);
+                GlStateManager.depthMask(true);
+                GlStateManager.enableBlend();
+                GlStateManager.translate(0, 0, -400);
+            } else if(slot.canBeHovered() && locked.boundTo >= 0 && locked.boundTo < 9) {
+                if(!(Minecraft.getMinecraft().currentScreen instanceof GuiContainer)) {
+                    return;
+                }
+                GuiContainer container = (GuiContainer) Minecraft.getMinecraft().currentScreen;
+
+                final ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+                final int scaledWidth = scaledresolution.getScaledWidth();
+                final int scaledHeight = scaledresolution.getScaledHeight();
+                int mouseX = Mouse.getX() * scaledWidth / Minecraft.getMinecraft().displayWidth;
+                int mouseY = scaledHeight - Mouse.getY() * scaledHeight / Minecraft.getMinecraft().displayHeight - 1;
+
+                if(container.isMouseOverSlot(slot, mouseX, mouseY)) {
+                    Slot boundSlot = container.inventorySlots.getSlotFromInventory(Minecraft.getMinecraft().thePlayer.inventory, locked.boundTo);
+                    int x2 = boundSlot.xDisplayPosition+8;
+                    int y2 = boundSlot.yDisplayPosition+8;
+
+                    drawLinkArrow(slot.xDisplayPosition+8,
+                            slot.yDisplayPosition+8, x2, y2);
+                }
+            }
+        }
+    }
+
+    public LockedSlot getLockedSlot(Slot slot) {
+        if(!NotEnoughUpdates.INSTANCE.hasSkyblockScoreboard()) return null;
+        if(slot == null) {
+            return null;
+        }
+        if(slot.inventory != Minecraft.getMinecraft().thePlayer.inventory) {
+            return null;
+        }
+        int index = slot.getSlotIndex();
+        if(index < 0 || index > 39) {
+            return null;
+        }
+        return getLockedSlotIndex(index);
+    }
+
+    public LockedSlot getLockedSlotIndex(int index) {
+        if(!NotEnoughUpdates.INSTANCE.hasSkyblockScoreboard()) return null;
+
+        LockedSlot[] lockedSlots = getDataForProfile();
+        if(lockedSlots == null) return null;
+        return getLockedSlot(lockedSlots, index);
+    }
+
+    public boolean isSlotLocked(Slot slot) {
+        LockedSlot locked = getLockedSlot(slot);
+        return locked != null && locked.locked;
+    }
+
+    public boolean isSlotIndexLocked(int index) {
+        LockedSlot locked = getLockedSlotIndex(index);
+
+        return locked != null && locked.locked;
+    }
+
+}