This exists above. I need to also check imports are correct. Actually the mixin uses `BlockPos` - it needs to import it. Let me check this is right. Also, `ItemPlacementContext#getBlockPos()` returns BlockPos, and `context.getWorld()` returns `World`. And `world.getBlockState(pos)` returns `BlockState`. All good. But wait - the mixin checks `if (result != ActionResult.SUCCESS && result != ActionResult.CONSUME)`. In 1.21.11, block placement that succeeds returns `ActionResult.SUCCESS` typically. Let me double check. In the vanilla `BlockItem.place()` method, on success it returns `ActionResult.SUCCESS` (or `ActionResult.CONSUME` for some cases). This should be fine. Let me also verify the `Entity#getEntityWorld()` usage in AutoChargeManager. Yes, I used `player.getEntityWorld()` which is correct for 1.21.9+. Let me also check the scheduled action record syntax: ```java private record ScheduledAction(int remainingTicks, Runnable runnable) { ScheduledAction(int delayTicks, Runnable runnable) { this(delayTicks, runnable); } } ``` Actually, the compact constructor isn't needed since the canonical constructor matches. Let me just use: ```java private record ScheduledAction(int remainingTicks, Runnable runnable) {} ``` This creates a canonical constructor `ScheduledAction(int remainingTicks, Runnable runnable)` which works fine. Let me fix that and also fix the switch logic in `switchHeldItem` which has a bug (the swap logic is wrong). Here's the fixed switchHeldItem: ```java private static void switchHeldItem(ServerPlayerEntity player, String target) { if (target.equals("NONE")) return; if (!player.isAlive()) return; net.minecraft.item.Item targetItem; if (target.equals("TOTEM")) { targetItem = Items.TOTEM_OF_UNDYING; } else if (target.equals("ANCHOR")) { targetItem = Blocks.RESPAWN_ANCHOR.asItem(); } else { return; } // Find target item in inventory (skip current main hand) int slot = findItemInInventory(player, targetItem); if (slot == -1) return; ItemStack currentMain = player.getMainHandStack().copy(); ItemStack foundStack = player.getInventory().getStack(slot).copy(); player.getInventory().setStack(slot, currentMain); player.getInventory().setStack(player.getInventory().selectedSlot, foundStack); player.playerScreenHandler.sendContentUpdates(); } ``` Let me also reconsider the `switchHeldItem` - it copies stacks then sets them, which should work fine. The issue with the record is the duplicate constructor name. Let me just use a simple class instead of a record since records auto-generate the constructor. Let me rewrite AutoChargeManager to fix these issues. Actually, thinking more carefully - the `findItem` method checks main hand too but I need it for finding glowstone. For finding the target item, I use `findItemInInventory` which skips the main hand. This is correct logic. Also for the `findItem` method, it returns -2 for offhand but the code in `chargeAnchor` handles it. Let me change it to use the actual offhand slot index instead of a magic number -2. Actually, `player.getOffHandStack()` returns the offhand ItemStack but the inventory slot for offhand isn't in `player.getInventory()`. The inventory only has 36 slots (0-8 hotbar, 9-35 main inventory, and... actually there's also armor slots). The offhand has a separate method. Let me use a simpler approach: in `chargeAnchor`, remove the special -2 handling and just find glowstone in any inventory slot including the hotbar, then consume from whatever slot it's in. Let me rewrite the AutoChargeManager more carefully. Also, I should simplify the scheduled action - just use a static inner class instead of a record to avoid confusion. Let me rewrite AutoChargeManager.java: ```java package com.autoanchor; import net.minecraft.block.BlockState; import net.minecraft.block.Blocks; import net.minecraft.block.RespawnAnchorBlock; import net.minecraft.item.ItemStack; import net.minecraft.item.Items; import net.minecraft.server.network.ServerPlayerEntity; import net.minecraft.text.Text; import net.minecraft.util.ActionResult; import net.minecraft.util.Formatting; import net.minecraft.util.Hand; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; import java.util.*; import java.util.concurrent.ThreadLocalRandom; public class AutoChargeManager { private static final Map> pendingActions = new HashMap<>(); public static void onAnchorPlaced(ServerPlayerEntity player, BlockPos pos) { AutoAnchorConfig config = AutoAnchorConfig.get(); if (!config.enabled) return; int chargeDelayTicks = msToTicks(randomDelay(config)); int switchDelayTicks = msToTicks(randomDelay(config)); schedule(player.getUuid(), chargeDelayTicks, () -> chargeAnchor(player, pos)); schedule(player.getUuid(), chargeDelayTicks + switchDelayTicks, () -> switchHeldItem(player, config.switchTarget)); } public static void tick() { synchronized (pendingActions) { Iterator> listIt = pendingActions.values().iterator(); while (listIt.hasNext()) { List actions = listIt.next(); Iterator it = actions.iterator(); while (it.hasNext()) { ScheduledAction action = it.next(); action.remainingTicks--; if (action.remainingTicks <= 0) { try { action.runnable.run(); } catch (Exception e) { AutoAnchorRespawn.LOGGER.error("Error in scheduled action", e); } it.remove(); } } if (actions.isEmpty()) { listIt.remove(); } } } } public static void clearPending(UUID playerUuid) { synchronized (pendingActions) { pendingActions.remove(playerUuid); } } private static void schedule(UUID playerUuid, int delayTicks, Runnable action) { synchronized (pendingActions) { pendingActions.computeIfAbsent(playerUuid, k -> new ArrayList<>()) .add(new ScheduledAction(delayTicks, action)); } } private static void chargeAnchor(ServerPlayerEntity player, BlockPos pos) { if (!player.isAlive()) return; if (!player.interactionManager.getGameMode().isSurvivalLike()) return; World world = player.getEntityWorld(); BlockState state = world.getBlockState(pos); if (!state.isOf(Blocks.RESPAWN_ANCHOR)) return; int charges = state.get(RespawnAnchorBlock.CHARGES); if (charges >= 4) return; // Find glowstone in inventory int glowstoneSlot = -1; for (int i = 0; i < player.getInventory().size(); i++) { if (player.getInventory().getStack(i).isOf(Items.GLOWSTONE)) { glowstoneSlot = i; break; } } if (glowstoneSlot == -1) { player.sendMessage(Text.translatable("text.autoanchor.no_glowstone").formatted(Formatting.RED), true); return; } // Consume one glowstone ItemStack glowstoneStack = player.getInventory().getStack(glowstoneSlot); glowstoneStack.decrement(1); // Charge the anchor world.setBlockState(pos, state.with(RespawnAnchorBlock.CHARGES, charges + 1)); world.syncWorldEvent(null, 1502, pos, charges + 1); player.sendMessage(Text.translatable("text.autoanchor.charged", charges + 1).formatted(Formatting.GREEN), true); } private static void switchHeldItem(ServerPlayerEntity player, String target) { if (target.equals("NONE")) return; if (!player.isAlive()) return; net.minecraft.item.Item targetItem; if (target.equals("TOTEM")) { targetItem = Items.TOTEM_OF_UNDYING; } else if (target.equals("ANCHOR")) { targetItem = Blocks.RESPAWN_ANCHOR.asItem(); } else { return; } // Find target item in inventory, skipping current main hand int targetSlot = -1; int mainHandSlot = player.getInventory().selectedSlot; for (int i = 0; i < player.getInventory().size(); i++) { if (i == mainHandSlot) continue; if (player.getInventory().getStack(i).isOf(targetItem)) { targetSlot = i; break; } } if (targetSlot == -1) return; // Swap ItemStack currentMain = player.getMainHandStack().copy(); ItemStack foundStack = player.getInventory().getStack(targetSlot).copy(); player.getInventory().setStack(targetSlot, currentMain); player.getInventory().setStack(mainHandSlot, foundStack); player.playerScreenHandler.sendContentUpdates(); } private static int randomDelay(AutoAnchorConfig config) { return ThreadLocalRandom.current().nextInt(config.minDelayMs, config.maxDelayMs + 1); } private static int msToTicks(int ms) { return Math.max(1, (int) Math.ceil(ms / 50.0)); } private static class ScheduledAction { int remainingTicks; final Runnable runnable; ScheduledAction(int delayTicks, Runnable runnable) { this.remainingTicks = delayTicks; this.runnable = runnable; } } } ``` This is cleaner. Let me also handle the findItem and findItemInInventory removal since they're now inline. Now let me also think about the mixin more carefully. `BlockItem.place()` in 1.21.11 - I need to verify the method signature. In Yarn 1.21.11, `BlockItem.place()` takes `ItemPlacementContext` and returns `ActionResult`. The inject at RETURN should work. However, there's a concern: when the item is a Respawn Anchor, `BlockItem.place()` is called. But I also want to make sure I'm not getting false positives - what if the player right-clicks with an anchor item but doesn't actually place it? The `ActionResult` check handles this - if the result is not SUCCESS or CONSUME, the placement didn't happen. OK, let me now recreate the AutoChargeManager with the fixed version, and also verify other files are correct. Actually, I already created the old version of AutoChargeManager above. Since use `