Refactor AutoReplenish (MeteorDevelopment#5307)

- clean up the code
- fix unstackables not getting replenished (mostly)

Author: machiecodes

src/main/java/meteordevelopment/meteorclient/mixin/ItemStackAccessor.java

@@ -6,27 +6,26 @@
 package meteordevelopment.meteorclient.systems.modules.player;
 
 import meteordevelopment.meteorclient.events.world.TickEvent;
-import meteordevelopment.meteorclient.mixin.ItemStackAccessor;
 import meteordevelopment.meteorclient.settings.*;
 import meteordevelopment.meteorclient.systems.modules.Categories;
 import meteordevelopment.meteorclient.systems.modules.Module;
 import meteordevelopment.meteorclient.systems.modules.Modules;
 import meteordevelopment.meteorclient.systems.modules.combat.AutoTotem;
 import meteordevelopment.meteorclient.utils.player.InvUtils;
-import meteordevelopment.meteorclient.utils.player.SlotUtils;
 import meteordevelopment.orbit.EventHandler;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.Items;
 
+import java.util.Arrays;
 import java.util.List;
 
 public class AutoReplenish extends Module {
     private final SettingGroup sgGeneral = settings.getDefaultGroup();
 
-    private final Setting<Integer> threshold = sgGeneral.add(new IntSetting.Builder()
-        .name("threshold")
-        .description("The threshold of items left this actives at.")
+    private final Setting<Integer> minCount = sgGeneral.add(new IntSetting.Builder()
+        .name("min-count")
+        .description("Replenish a slot when it reaches this item count.")
         .defaultValue(8)
         .min(1)
         .sliderRange(1, 63)
@@ -35,47 +34,59 @@ public class AutoReplenish extends Module {
 
     private final Setting<Integer> tickDelay = sgGeneral.add(new IntSetting.Builder()
         .name("delay")
-        .description("The tick delay to replenish your hotbar.")
+        .description("How long in ticks to wait between replenishing your hotbar.")
         .defaultValue(1)
         .min(0)
         .build()
     );
 
     private final Setting<Boolean> offhand = sgGeneral.add(new BoolSetting.Builder()
         .name("offhand")
-        .description("Whether or not to refill your offhand with items.")
+        .description("Whether or not to replenish items in your offhand.")
         .defaultValue(true)
         .build()
     );
 
     private final Setting<Boolean> unstackable = sgGeneral.add(new BoolSetting.Builder()
         .name("unstackable")
-        .description("Replenishes unstackable items.")
+        .description("Replenish unstackable items.")
         .defaultValue(true)
         .build()
     );
 
+    private final Setting<Boolean> sameEnchants = sgGeneral.add(new BoolSetting.Builder()
+        .name("same-enchants")
+        .description("Only replace unstackables with items that have the same enchants.")
+        .defaultValue(true)
+        .visible(unstackable::get)
+        .build()
+    );
+
     private final Setting<Boolean> searchHotbar = sgGeneral.add(new BoolSetting.Builder()
         .name("search-hotbar")
-        .description("Uses items in your hotbar to replenish if they are the only ones left.")
-        .defaultValue(true)
+        .description("Combine stacks in your hotbar/offhand as a last resort.")
+        .defaultValue(false)
         .build()
     );
 
     private final Setting<List<Item>> excludedItems = sgGeneral.add(new ItemListSetting.Builder()
         .name("excluded-items")
-        .description("Items that WILL NOT replenish.")
+        .description("Items that won't be replenished.")
         .build()
     );
 
+    /**
+     * Represents the items the player had last tick. Indices 0-8 represent the
+     * hotbar from left to right, index 9 represents the player's offhand
+     */
     private final ItemStack[] items = new ItemStack[10];
     private boolean prevHadOpenScreen;
     private int tickDelayLeft;
 
     public AutoReplenish() {
         super(Categories.Player, "auto-replenish", "Automatically refills items in your hotbar, main hand, or offhand.");
 
-        for (int i = 0; i < items.length; i++) items[i] = new ItemStack(Items.AIR);
+        Arrays.fill(items, Items.AIR.getDefaultStack());
     }
 
     @Override
@@ -94,97 +105,83 @@ private void onTick(TickEvent.Pre event) {
         prevHadOpenScreen = mc.currentScreen != null;
         if (mc.player.currentScreenHandler.getStacks().size() != 46 || mc.currentScreen != null) return;
 
-        if (tickDelayLeft <= 0) {
-            tickDelayLeft = tickDelay.get();
-
-            // Hotbar
-            for (int i = 0; i < 9; i++) {
-                ItemStack stack = mc.player.getInventory().getStack(i);
-                checkSlot(i, stack);
-            }
+        if (tickDelayLeft > 0) {
+            tickDelayLeft--;
+            return;
+        }
 
-            // Offhand
-            if (offhand.get() && !Modules.get().get(AutoTotem.class).isLocked()) {
-                ItemStack stack = mc.player.getOffHandStack();
-                checkSlot(SlotUtils.OFFHAND, stack);
-            }
+        // Hotbar
+        for (int i = 0; i < 9; i++) {
+            ItemStack stack = mc.player.getInventory().getStack(i);
+            checkSlot(i, stack);
         }
-        else {
-            tickDelayLeft--;
+
+        // Offhand
+        if (offhand.get() && !Modules.get().get(AutoTotem.class).isLocked()) {
+            ItemStack stack = mc.player.getOffHandStack();
+            checkSlot(9, stack);
         }
+
+        tickDelayLeft = tickDelay.get();
     }
 
     private void checkSlot(int slot, ItemStack stack) {
-        ItemStack prevStack = getItem(slot);
+        ItemStack prevStack = items[slot];
+        items[slot] = stack.copy();
 
-        // Stackable items 1
-        if (!stack.isEmpty() && stack.isStackable() && !excludedItems.get().contains(stack.getItem())) {
-            if (stack.getCount() <= threshold.get()) {
-                addSlots(slot, findItem(stack, slot, threshold.get() - stack.getCount() + 1));
-            }
+        if (excludedItems.get().contains(stack.getItem())) return;
+        if (excludedItems.get().contains(prevStack.getItem())) return;
+
+        int fromSlot = -1;
+
+        // If there are still items left in the stack, but it just crossed the threshold
+        if (stack.isStackable() && !stack.isEmpty() && stack.getCount() <= minCount.get()) {
+            fromSlot = findItem(stack, slot, minCount.get() - stack.getCount() + 1);
         }
 
-        if (stack.isEmpty() && !prevStack.isEmpty() && !excludedItems.get().contains(prevStack.getItem())) {
-            // Stackable items 2
-            if (prevStack.isStackable()) {
-                addSlots(slot, findItem(prevStack, slot, threshold.get() - stack.getCount() + 1));
-            }
-            // Unstackable items
-            else {
-                if (unstackable.get()) {
-                    addSlots(slot, findItem(prevStack, slot, 1));
-                }
-            }
+        // If the stack just went from above the threshold to empty in a single tick
+        // this can happen if the threshold is set low enough while using modules that
+        // place many blocks per tick, like surround or holefiller
+        if (prevStack.isStackable() && stack.isEmpty() && !prevStack.isEmpty()) {
+            fromSlot = findItem(prevStack, slot, minCount.get() - stack.getCount() + 1);
         }
 
-        setItem(slot, stack);
+        // Unstackable items
+        if (unstackable.get() && !prevStack.isStackable() && stack.isEmpty() && !prevStack.isEmpty()) {
+            fromSlot = findItem(prevStack, slot, 1);
+        }
+
+        InvUtils.move().from(fromSlot).to(slot);
     }
 
-    private int findItem(ItemStack itemStack, int excludedSlot, int goodEnoughCount) {
+    private int findItem(ItemStack lookForStack, int excludedSlot, int goodEnoughCount) {
         int slot = -1;
         int count = 0;
 
         for (int i = mc.player.getInventory().size() - 2; i >= (searchHotbar.get() ? 0 : 9); i--) {
+            if (i == excludedSlot) continue;
+
             ItemStack stack = mc.player.getInventory().getStack(i);
+            if (stack.getItem() != lookForStack.getItem()) continue;
+
+            if (sameEnchants.get() && !stack.getEnchantments().equals(lookForStack.getEnchantments())) continue;
 
-            if (i != excludedSlot && stack.getItem() == itemStack.getItem() && ItemStack.areItemsAndComponentsEqual(itemStack, stack)) {
-                if (stack.getCount() > count) {
-                    slot = i;
-                    count = stack.getCount();
+            if (stack.getCount() > count) {
+                slot = i;
+                count = stack.getCount();
 
-                    if (count >= goodEnoughCount) break;
-                }
+                if (count >= goodEnoughCount) break;
             }
         }
 
         return slot;
     }
 
-    private void addSlots(int to, int from) {
-        InvUtils.move().from(from).to(to);
-    }
-
     private void fillItems() {
         for (int i = 0; i < 9; i++) {
-            setItem(i, mc.player.getInventory().getStack(i));
+            items[i] = mc.player.getInventory().getStack(i).copy();
         }
 
-        setItem(SlotUtils.OFFHAND, mc.player.getOffHandStack());
-    }
-
-    private ItemStack getItem(int slot) {
-        if (slot == SlotUtils.OFFHAND) slot = 9;
-
-        return items[slot];
-    }
-
-    private void setItem(int slot, ItemStack stack) {
-        if (slot == SlotUtils.OFFHAND) slot = 9;
-
-        ItemStack s = items[slot];
-        ((ItemStackAccessor) (Object) s).setItem(stack.getItem());
-        s.setCount(stack.getCount());
-        s.applyComponentsFrom(stack.getComponents());
-        if (stack.isEmpty()) ((ItemStackAccessor) (Object) s).setItem(Items.AIR);
+        items[9] = mc.player.getOffHandStack().copy();
     }
 }

src/main/java/meteordevelopment/meteorclient/systems/modules/player/AutoReplenish.java

@@ -113,7 +113,6 @@
     "ItemGroupsMixin",
     "ItemMixin",
     "ItemRendererMixin",
-    "ItemStackAccessor",
     "ItemStackMixin",
     "JukeboxPlayableComponentMixin",
     "KeyBindingAccessor",