Ender Chest support and fixes

Avanatiker · Avanatiker · commit fcb458effcfe · 2025-12-09T05:00:32.000+01:00
diff --git a/src/main/java/com/lambda/mixin/items/BlockItemMixin.java b/src/main/java/com/lambda/mixin/items/BlockItemMixin.java
@@ -34,8 +34,8 @@ public BlockItemMixin(Settings settings) {
 
     @Override
     public Optional<TooltipData> getTooltipData(ItemStack stack) {
-        if (ContainerPreview.INSTANCE.isEnabled() && ContainerPreview.isShulkerBox(stack)) {
-            return Optional.of(new ContainerPreview.ShulkerComponent(stack));
+        if (ContainerPreview.INSTANCE.isEnabled() && ContainerPreview.isPreviewableContainer(stack)) {
+            return Optional.of(new ContainerPreview.ContainerComponent(stack));
         }
         return super.getTooltipData(stack);
     }
diff --git a/src/main/java/com/lambda/mixin/render/DrawContextMixin.java b/src/main/java/com/lambda/mixin/render/DrawContextMixin.java
@@ -50,8 +50,8 @@ private void onDrawTooltip(TextRenderer textRenderer, List<Text> text, Optional<
             return;
         }
 
-        // Check if this is a shulker box tooltip with ContainerPreview
-        if (data.isPresent() && data.get() instanceof ContainerPreview.ShulkerComponent component) {
+        // Check if this is a container tooltip with ContainerPreview
+        if (data.isPresent() && data.get() instanceof ContainerPreview.ContainerComponent component) {
             // Cancel the default tooltip and render our custom one
             ci.cancel();
             ContainerPreview.renderShulkerTooltip((DrawContext)(Object)this, textRenderer, component, x, y);
diff --git a/src/main/java/com/lambda/mixin/render/HandledScreenMixin.java b/src/main/java/com/lambda/mixin/render/HandledScreenMixin.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lambda.mixin.render;
+
+import com.lambda.module.modules.render.ContainerPreview;
+import net.minecraft.client.gui.screen.ingame.HandledScreen;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(HandledScreen.class)
+public class HandledScreenMixin {
+    @Inject(method = "mouseClicked", at = @At("HEAD"), cancellable = true)
+    private void onMouseClicked(double mouseX, double mouseY, int button, CallbackInfoReturnable<Boolean> cir) {
+        // Block clicks when container preview tooltip is locked and mouse is over it
+        if (ContainerPreview.INSTANCE.isEnabled() && ContainerPreview.isLocked()) {
+            if (ContainerPreview.isMouseOverLockedTooltip((int) mouseX, (int) mouseY)) {
+                cir.setReturnValue(true);
+            }
+        }
+    }
+
+    @Inject(method = "mouseReleased", at = @At("HEAD"), cancellable = true)
+    private void onMouseReleased(double mouseX, double mouseY, int button, CallbackInfoReturnable<Boolean> cir) {
+        // Block releases when container preview tooltip is locked and mouse is over it
+        if (ContainerPreview.INSTANCE.isEnabled() && ContainerPreview.isLocked()) {
+            if (ContainerPreview.isMouseOverLockedTooltip((int) mouseX, (int) mouseY)) {
+                cir.setReturnValue(true);
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/lambda/mixin/render/ScreenMixin.java b/src/main/java/com/lambda/mixin/render/ScreenMixin.java
@@ -20,6 +20,8 @@
 import com.lambda.gui.components.QuickSearch;
 import com.lambda.module.modules.render.ContainerPreview;
 import com.lambda.module.modules.render.NoRender;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.gui.DrawContext;
 import net.minecraft.client.gui.screen.Screen;
@@ -45,9 +47,11 @@ private void injectRenderInGameBackground(DrawContext context, CallbackInfo ci)
         if (NoRender.INSTANCE.isEnabled() && NoRender.getNoGuiShadow()) ci.cancel();
     }
 
-    @Inject(method = "renderWithTooltip", at = @At("TAIL"))
-    private void onRenderWithTooltip(DrawContext context, int mouseX, int mouseY, float deltaTicks, CallbackInfo ci) {
-        // Render locked container preview tooltip at the end of screen rendering
+    @WrapOperation(method = "renderWithTooltip", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/gui/screen/Screen;render(Lnet/minecraft/client/gui/DrawContext;IIF)V"))
+    private void wrapRender(Screen instance, DrawContext context, int mouseX, int mouseY, float deltaTicks, Operation<Void> original) {
+        original.call(instance, context, mouseX, mouseY, deltaTicks);
+
+        // Render locked container preview tooltip after screen rendering
         if (ContainerPreview.INSTANCE.isEnabled() && ContainerPreview.isLocked()) {
             ContainerPreview.renderLockedTooltip(context, MinecraftClient.getInstance().textRenderer);
         }
diff --git a/src/main/java/com/lambda/mixin/render/TooltipComponentMixin.java b/src/main/java/com/lambda/mixin/render/TooltipComponentMixin.java
@@ -33,9 +33,9 @@
 public interface TooltipComponentMixin {
     @Inject(method = "of(Lnet/minecraft/item/tooltip/TooltipData;)Lnet/minecraft/client/gui/tooltip/TooltipComponent;", at = @At("HEAD"), cancellable = true)
     private static void of(TooltipData tooltipData, CallbackInfoReturnable<TooltipComponent> cir) {
-        // Handle ContainerPreview shulker box tooltip
-        if (ContainerPreview.INSTANCE.isEnabled() && tooltipData instanceof ContainerPreview.ShulkerComponent shulkerComponent) {
-            cir.setReturnValue(shulkerComponent);
+        // Handle ContainerPreview container tooltip (shulker boxes and ender chests)
+        if (ContainerPreview.INSTANCE.isEnabled() && tooltipData instanceof ContainerPreview.ContainerComponent containerComponent) {
+            cir.setReturnValue(containerComponent);
             return;
         }
 
diff --git a/src/main/kotlin/com/lambda/module/modules/render/ContainerPreview.kt b/src/main/kotlin/com/lambda/module/modules/render/ContainerPreview.kt
@@ -19,6 +19,7 @@ package com.lambda.module.modules.render
 
 import com.lambda.Lambda.mc
 import com.lambda.config.settings.complex.Bind
+import com.lambda.interaction.material.container.containers.EnderChestContainer
 import com.lambda.module.Module
 import com.lambda.module.tag.ModuleTag
 import com.lambda.util.KeyCode
@@ -32,6 +33,7 @@ import net.minecraft.client.gui.tooltip.TooltipComponent
 import net.minecraft.client.render.RenderLayer
 import net.minecraft.item.BlockItem
 import net.minecraft.item.ItemStack
+import net.minecraft.item.Items
 import net.minecraft.item.tooltip.TooltipData
 import net.minecraft.util.DyeColor
 import net.minecraft.util.Identifier
@@ -80,6 +82,18 @@ object ContainerPreview : Module(
     private fun getTooltipWidth(): Int = PADDING + COLS * SLOT_SIZE + PADDING
     private fun getTooltipHeight(): Int = TITLE_HEIGHT + ROWS * SLOT_SIZE + PADDING
 
+    /**
+     * Check if mouse is over the locked tooltip area (for click blocking)
+     */
+    @JvmStatic
+    fun isMouseOverLockedTooltip(mouseX: Int, mouseY: Int): Boolean {
+        if (!isLocked) return false
+        val width = getTooltipWidth()
+        val height = getTooltipHeight()
+        return mouseX >= lockedX && mouseX < lockedX + width &&
+                mouseY >= lockedY && mouseY < lockedY + height
+    }
+
     /**
      * Calculate text color based on background luminance.
      * Returns dark text for light backgrounds and white text for dark backgrounds.
@@ -97,7 +111,7 @@ object ContainerPreview : Module(
     }
 
     @JvmStatic
-    fun renderShulkerTooltip(context: DrawContext, textRenderer: TextRenderer, component: ShulkerComponent, mouseX: Int, mouseY: Int) {
+    fun renderShulkerTooltip(context: DrawContext, textRenderer: TextRenderer, component: ContainerComponent, mouseX: Int, mouseY: Int) {
         // Calculate tooltip position
         val width = getTooltipWidth()
         val height = getTooltipHeight()
@@ -144,33 +158,28 @@ object ContainerPreview : Module(
     }
 
     private fun renderTooltipForStack(context: DrawContext, textRenderer: TextRenderer, stack: ItemStack, x: Int, y: Int, allowHover: Boolean) {
-        val contents = stack.shulkerBoxContents
+        val contents = getContainerContents(stack)
         val width = getTooltipWidth()
         val height = getTooltipHeight()
 
         val matrices = context.matrices
         matrices.push()
         matrices.translate(0f, 0f, 400f)
 
-        // Get shulker box color
-        val color = getShulkerColor(stack)
-        val tintColor = if (colorTint && color != null) {
-            color.entityColor
-        } else {
-            0xFFFFFFFF.toInt()
-        }
+        // Get container color (shulker box color or purple for ender chest)
+        val tintColor = getContainerTintColor(stack)
 
         // Draw background with color tint
         drawBackground(context, x, y, width, height, tintColor)
 
-        // Draw title (shulker box name) with appropriate text color
+        // Draw title (container name) with appropriate text color
         val name = stack.name
         val textColor = getTextColor(tintColor)
         context.drawText(textRenderer, name, x + PADDING, y + 4, textColor, false)
 
-        // Draw items
-        val startX = x + PADDING + 1
-        val startY = y + TITLE_HEIGHT
+        // Slots start at padding offset, items are centered in 18px slots (1px padding on each side)
+        val slotsStartX = x + PADDING
+        val slotsStartY = y + TITLE_HEIGHT
 
         // Get actual mouse position for hover detection
         val actualMouseX = (mc.mouse.x * mc.window.scaledWidth / mc.window.width).toInt()
@@ -183,19 +192,25 @@ object ContainerPreview : Module(
         for ((index, item) in contents.withIndex()) {
             if (index >= COLS * ROWS) break
 
-            val slotX = index % COLS
-            val slotY = index / COLS
+            val slotCol = index % COLS
+            val slotRow = index / COLS
+
+            // Slot bounds (full 18x18 area for hover detection)
+            val slotX = slotsStartX + slotCol * SLOT_SIZE
+            val slotY = slotsStartY + slotRow * SLOT_SIZE
 
-            val itemX = startX + slotX * SLOT_SIZE
-            val itemY = startY + slotY * SLOT_SIZE
+            // Item position (centered in slot with 1px offset)
+            val itemX = slotX + 1
+            val itemY = slotY + 1
 
             // Check if this slot is hovered (only when locked/allowHover)
+            // Use full slot size (18x18) for hover detection to avoid dead zones
             if (allowHover) {
-                val isHovered = actualMouseX >= itemX && actualMouseX < itemX + 16 &&
-                        actualMouseY >= itemY && actualMouseY < itemY + 16
+                val isHovered = actualMouseX >= slotX && actualMouseX < slotX + SLOT_SIZE &&
+                        actualMouseY >= slotY && actualMouseY < slotY + SLOT_SIZE
 
                 if (isHovered && !item.isEmpty) {
-                    // Draw highlight
+                    // Draw highlight on the item area (16x16)
                     context.fill(itemX, itemY, itemX + 16, itemY + 16, 0x80FFFFFF.toInt())
                     hoveredStack = item
                     hoveredSlotX = actualMouseX
@@ -215,17 +230,52 @@ object ContainerPreview : Module(
         if (hoveredStack != null && allowHover) {
             matrices.push()
             matrices.translate(0f, 0f, 500f)  // Higher Z than the main tooltip
-            // Set flag to prevent recursive mixin interception
-            isRenderingSubTooltip = true
-            try {
-                context.drawItemTooltip(textRenderer, hoveredStack, hoveredSlotX, hoveredSlotY)
-            } finally {
-                isRenderingSubTooltip = false
+
+            // Check if hovered item is also a previewable container (shulker in echest)
+            if (isPreviewableContainer(hoveredStack)) {
+                // Render nested container preview recursively
+                val nestedWidth = getTooltipWidth()
+                val nestedHeight = getTooltipHeight()
+                val nestedX = calculateTooltipX(hoveredSlotX, nestedWidth)
+                val nestedY = calculateTooltipY(hoveredSlotY, nestedHeight)
+                renderTooltipForStack(context, textRenderer, hoveredStack, nestedX, nestedY, false)
+            } else {
+                // Regular item tooltip - use mixin bypass flag
+                isRenderingSubTooltip = true
+                try {
+                    context.drawItemTooltip(textRenderer, hoveredStack, hoveredSlotX, hoveredSlotY)
+                } finally {
+                    isRenderingSubTooltip = false
+                }
             }
             matrices.pop()
         }
     }
 
+    private fun getContainerContents(stack: ItemStack): List<ItemStack> {
+        return when {
+            isShulkerBox(stack) -> stack.shulkerBoxContents
+            isEnderChest(stack) -> EnderChestContainer.stacks
+            else -> emptyList()
+        }
+    }
+
+    private fun getContainerTintColor(stack: ItemStack): Int {
+        if (!colorTint) return 0xFFFFFFFF.toInt()
+
+        return when {
+            isShulkerBox(stack) -> {
+                val color = getShulkerColor(stack)
+                color?.entityColor ?: 0xFFFFFFFF.toInt()
+            }
+            isEnderChest(stack) -> {
+                // Ender chest purple/dark tint
+                0xFF1E1E2E.toInt()
+            }
+            else -> 0xFFFFFFFF.toInt()
+        }
+    }
+
     private fun calculateTooltipX(mouseX: Int, width: Int): Int {
         val screenWidth = mc.window.scaledWidth
         var x = mouseX + 12
@@ -309,13 +359,31 @@ object ContainerPreview : Module(
         return stack.item in shulkerBoxes
     }
 
-    class ShulkerComponent(val stack: ItemStack) : TooltipData, TooltipComponent {
+    @JvmStatic
+    fun isEnderChest(stack: ItemStack): Boolean {
+        return stack.item == Items.ENDER_CHEST && EnderChestContainer.stacks.isNotEmpty()
+    }
+
+    @JvmStatic
+    fun isPreviewableContainer(stack: ItemStack): Boolean {
+        return isShulkerBox(stack) || isEnderChest(stack)
+    }
+
+    open class ContainerComponent(val stack: ItemStack) : TooltipData, TooltipComponent {
         val contents: List<ItemStack>
-            get() = stack.shulkerBoxContents
+            get() = when {
+                isShulkerBox(stack) -> stack.shulkerBoxContents
+                isEnderChest(stack) -> EnderChestContainer.stacks
+                else -> emptyList()
+            }
 
         // These methods are not used since we render the tooltip ourselves
         override fun drawItems(textRenderer: TextRenderer, x: Int, y: Int, width: Int, height: Int, context: DrawContext) {}
         override fun getHeight(textRenderer: TextRenderer): Int = 0
         override fun getWidth(textRenderer: TextRenderer): Int = 0
     }
+
+    // Keep for backwards compatibility
+    @Deprecated("Use ContainerComponent instead", ReplaceWith("ContainerComponent"))
+    class ShulkerComponent(stack: ItemStack) : ContainerComponent(stack)
 }
diff --git a/src/main/resources/lambda.mixins.common.json b/src/main/resources/lambda.mixins.common.json
@@ -53,6 +53,7 @@
     "render.EntityRendererMixin",
     "render.FluidRendererMixin",
     "render.GameRendererMixin",
+    "render.HandledScreenMixin",
     "render.GlStateManagerMixin",
     "render.HeadFeatureRendererMixin",
     "render.HeldItemRendererMixin",

Original file line number	Diff line number	Diff line change
`@@ -34,8 +34,8 @@ public BlockItemMixin(Settings settings) {`
`34`	`34`
`35`	`35`	`@Override`
`36`	`36`	`public Optional<TooltipData> getTooltipData(ItemStack stack) {`
`37`		`- if (ContainerPreview.INSTANCE.isEnabled() && ContainerPreview.isShulkerBox(stack)) {`
`38`		`- return Optional.of(new ContainerPreview.ShulkerComponent(stack));`
	`37`	`+ if (ContainerPreview.INSTANCE.isEnabled() && ContainerPreview.isPreviewableContainer(stack)) {`
	`38`	`+ return Optional.of(new ContainerPreview.ContainerComponent(stack));`
`39`	`39`	`}`
`40`	`40`	`return super.getTooltipData(stack);`
`41`	`41`	`}`