this actually fixes #67 again ( i hope )

Author: matthewperiut

common/src/main/java/com/periut/chisel/gui/ChiselScreenHandler.java

@@ -139,25 +139,20 @@ public ItemStack quickMove(PlayerEntity player, int invSlot) {
     public void onClosed(PlayerEntity player) {
         super.onClosed(player);
         ItemStack hand = player.getHandItems().iterator().next();
-        if (!hand.isOf(Chisel.chiselSupplier.get()))
-        {
-            ItemStack chiselStack = ItemStack.EMPTY;
-            int chiselSlot = -1;
-
-            // Find the chisel in inventory
-            for (int i = 0; i < player.getInventory().size(); i++)
-            {
-                if(player.getInventory().getStack(i).isOf(Chisel.chiselSupplier.get()))
-                {
-                    chiselStack = player.getInventory().getStack(i);
-                    chiselSlot = i;
-                    break; // Stop at the first chisel found
-                }
-            }
 
-            // Only modify inventory if we found a chisel
-            if (chiselSlot != -1 && !chiselStack.isEmpty() && chiselStack.getCount() > 0) {
-                player.getInventory().removeStack(chiselSlot);
+        // Sanitize inventory before any modifications
+        sanitizeInventory(player.getInventory());
+
+        if (!hand.isOf(Chisel.chiselSupplier.get())) {
+            ItemStack chiselStack = findChiselInInventory(player);
+
+            // Only modify inventory if we found a valid chisel stack
+            if (chiselStack != null && !chiselStack.isEmpty() && chiselStack.getCount() > 0) {
+                // Ensure we're not creating an invalid stack
+                chiselStack = chiselStack.copyWithCount(Math.max(1, Math.min(chiselStack.getCount(), chiselStack.getMaxCount())));
+
+                // Remove from original slot and set to first slot
+                player.getInventory().removeStack(player.getInventory().getSlotWithStack(chiselStack));
                 player.getInventory().setStack(0, chiselStack);
             }
         }
@@ -171,7 +166,35 @@ public void onClosed(PlayerEntity player) {
             var changes = ComponentChanges.builder().remove(DataComponentTypes.BUNDLE_CONTENTS).add(DataComponentTypes.BUNDLE_CONTENTS, c).build();
             hand.applyChanges(changes);
         }
+    }
 
+    // Helper method to find a chisel in the player's inventory
+    private ItemStack findChiselInInventory(PlayerEntity player) {
+        for (int i = 0; i < player.getInventory().size(); i++) {
+            ItemStack stack = player.getInventory().getStack(i);
+            if (stack.isOf(Chisel.chiselSupplier.get()) && stack.getCount() > 0) {
+                return stack;
+            }
+        }
+        return null;
+    }
+
+    // Sanitization method for inventory
+    private void sanitizeInventory(PlayerInventory inventory) {
+        for (int i = 0; i < inventory.size(); i++) {
+            ItemStack stack = inventory.getStack(i);
+
+            // Sanitize stack
+            if (stack == null || stack.isEmpty() || stack.getCount() <= 0) {
+                inventory.setStack(i, ItemStack.EMPTY);
+            } else {
+                // Ensure count is within valid range
+                int sanitizedCount = Math.max(1, Math.min(stack.getCount(), stack.getMaxCount()));
+                if (sanitizedCount != stack.getCount()) {
+                    inventory.setStack(i, stack.copyWithCount(sanitizedCount));
+                }
+            }
+        }
     }
 
     @Override

common/src/main/java/com/periut/chisel/inventory/ChiselInventory.java

@@ -12,8 +12,7 @@
 public class ChiselInventory implements IInventory {
     private final DefaultedList<ItemStack> inventory;
 
-    public ChiselInventory()
-    {
+    public ChiselInventory() {
         this.inventory = DefaultedList.ofSize(61, ItemStack.EMPTY);
     }
 
@@ -24,46 +23,81 @@ public DefaultedList<ItemStack> getItems() {
 
     @Override
     public void setStack(int slot, ItemStack stack) {
-        if (stack.getCount() <= 0 || stack.getCount() > 99) {
-            stack = ItemStack.EMPTY; // Ensure invalid stacks are cleared
+        validateAndSetStack(slot, stack);
+    }
+
+    private void validateAndSetStack(int slot, ItemStack stack) {
+        // Ensure stack is either empty or has a valid count
+        if (stack == null) {
+            getItems().set(slot, ItemStack.EMPTY);
+            return;
         }
-        getItems().set(slot, stack);
+
+        // If stack is empty or count is invalid, set to empty
+        if (stack.isEmpty() || stack.getCount() <= 0) {
+            getItems().set(slot, ItemStack.EMPTY);
+        } else {
+            // Clamp count between 1 and 99
+            ItemStack sanitizedStack = stack.copyWithCount(Math.max(1, Math.min(stack.getCount(), 99)));
+            getItems().set(slot, sanitizedStack);
+        }
+
+        // Refresh if it's the input slot
         if (slot == 0) {
-            refresh(stack.getItem());
+            refresh(getStack(slot).getItem());
         }
     }
 
-
     @Override
     public ItemStack removeStack(int slot, int count) {
         ItemStack result = Inventories.splitStack(getItems(), slot, count);
+
+        // Ensure the result has a valid count
         if (!result.isEmpty()) {
-            markDirty();
+            // If the input slot, respect the current input stack count
             if (slot != 0 && !inventory.get(0).isEmpty()) {
-                int c = inventory.get(0).getCount();
-                result.setCount(Math.max(1, Math.min(c, 99))); // Clamp between 1 and 99
+                int inputCount = inventory.get(0).getCount();
+                result.setCount(Math.max(1, Math.min(result.getCount(), inputCount)));
             }
 
+            // Ensure the result always has at least 1 item
+            if (result.getCount() <= 0) {
+                result = ItemStack.EMPTY;
+            }
+
+            markDirty();
         }
+
         return result;
     }
 
-    public void refresh(Item item)
-    {
-        if (!(item instanceof BlockItem))
-        {
+    @Override
+    public ItemStack removeStack(int slot) {
+        ItemStack stack = getItems().get(slot);
+
+        // If the stack is empty or invalid, return empty stack
+        if (stack.isEmpty() || stack.getCount() <= 0) {
+            return ItemStack.EMPTY;
+        }
+
+        getItems().set(slot, ItemStack.EMPTY);
+        return stack;
+    }
+
+    public void refresh(Item item) {
+        if (!(item instanceof BlockItem)) {
             clearInv();
             return;
         }
         List<Item> chiselBlocks = ChiselGroupLookup.getBlocksInGroup(item);
         populate(chiselBlocks);
     }
 
-    public void populate(List<Item> chiselBlocks)
-    {
+    public void populate(List<Item> chiselBlocks) {
         clearInv();
         int baseCount = getStack(0).getCount();
         baseCount = Math.max(1, Math.min(baseCount, 99)); // Clamp stack size
+
         for (int i = 0; i < 60 && i < chiselBlocks.size(); i++) {
             this.setStack(i + 1, new ItemStack(chiselBlocks.get(i), baseCount));
         }
@@ -74,4 +108,12 @@ public void clearInv() {
             this.setStack(i, ItemStack.EMPTY);
         }
     }
+
+    // Additional method to ensure all stacks are valid before saving
+    public void sanitizeInventory() {
+        for (int i = 0; i < inventory.size(); i++) {
+            ItemStack stack = inventory.get(i);
+            validateAndSetStack(i, stack);
+        }
+    }
 }