feat: LEFT_SHIFT implementation and handling within stonecutters (#5195) (#6222)

* feat: LEFT_SHIFT implementation and handling within stonecutters (fixes #5195)

chore: early return if there are no remaining items

readability!

chore: add a smol comment to clarify this variable

because why the hell not?

* cleanup: reduce redundant code & (hopefully) fix touchscreen compat

* Fix touchscreen and ensure only one shift click is sent (#1)

<3 you, AJ!

---------

Co-authored-by: AJ Ferguson <AJ-Ferguson@users.noreply.github.com>

Author: Skullians

core/src/main/java/org/geysermc/geyser/inventory/click/ClickPlan.java

@@ -157,13 +157,13 @@ public void execute(boolean refresh) {
             }
 
             ServerboundContainerClickPacket clickPacket = new ServerboundContainerClickPacket(
-                    inventory.getJavaId(),
-                    stateId,
-                    action.slot,
-                    action.click.actionType,
-                    action.click.action,
-                    DataComponentHashers.hashStack(session, clickedItemStack),
-                    changedHashedItems
+                inventory.getJavaId(),
+                stateId,
+                action.slot,
+                action.click.actionType,
+                action.click.action,
+                DataComponentHashers.hashStack(session, clickedItemStack),
+                changedHashedItems
             );
 
             session.sendDownstreamGamePacket(clickPacket);
@@ -397,7 +397,40 @@ private void simulateAction(ClickAction action) {
                     swap(action.slot, inventory.getOffsetForHotbar(8), clicked);
                     break;
                 case LEFT_SHIFT:
-                    //TODO
+                    if (clicked.isEmpty()) {
+                        break;
+                    }
+                    
+                    int remaining = clicked.getAmount();
+                    // are we shift-clicking items from the player inventory, or from the container?
+                    boolean sourceInPlayerInventory = action.slot >= translator.size;
+
+                    if (!sourceInPlayerInventory) {
+                        int hotbarOffset = inventory.getOffsetForHotbar(0);
+                        int mainStart = hotbarOffset - 27;
+                        int mainEnd = hotbarOffset - 1;
+                        int hotbarEnd = hotbarOffset + 8;
+
+                        // from what I understand, java has this priority for shift clicks:
+                        // 1. existing partial stacks in main inventory, top rows first
+                        // 2. existing partial stacks in hotbar
+                        // 3. empty slots in main inventory
+                        // 4. empty slots in hotbar
+                        
+                        // fill partial stacks in main inventory, then opt for hotbar afterwards
+                        remaining = fillPartialStacks(action.slot, clicked, remaining, mainStart, mainEnd);
+                        remaining = fillPartialStacks(action.slot, clicked, remaining, hotbarOffset, hotbarEnd);
+                        
+                        // fill empty slots in main inventory, then opt for hotbar afterwards
+                        remaining = fillEmptySlots(action.slot, clicked, remaining, mainStart, mainEnd);
+                        fillEmptySlots(action.slot, clicked, remaining, hotbarOffset, hotbarEnd); // remaining is no longer used 
+                    } else { // the other way around. the source is the player inventory, and we're shift clicking into the target container
+                        // fill partial stacks in top inventory, then opt for empty slots
+                        // this isn't a player's inventory, so we do not need the hotbar/main-inventory logic and vice versa :P
+                        remaining = fillPartialStacks(action.slot, clicked, remaining, 0, translator.size - 1);
+                        fillEmptySlots(action.slot, clicked, remaining, 0, translator.size - 1);
+                    }
+                    
                     break;
                 case DROP_ONE:
                     if (!clicked.isEmpty()) {
@@ -501,6 +534,47 @@ private void reduceCraftingGrid(boolean makeAll) {
         }
     }
 
+    /**
+     * Utility method for LEFT_SHIFT. Java has some specific logic where it will try fill partial stacks first, so this is
+     * just a util method to reduce code duplication.
+     * 
+     * @return The remaining item count
+     */
+    private int fillPartialStacks(int sourceSlot, GeyserItemStack source, int remaining, int rangeStart, int rangeEnd) {
+        if (remaining <= 0) return 0; // we already return early within the underlying loop, this is a sanity check and/or readability to avoid confusion
+        for (int i = rangeStart; i <= rangeEnd && remaining > 0; i++) {
+            if (!canStack(i, source)) continue;
+
+            GeyserItemStack dest = getItem(i);
+            int canAdd = Math.min(remaining, dest.getMaxStackSize() - dest.getAmount());
+            if (canAdd <= 0) continue;
+
+            add(i, dest, canAdd);
+            sub(sourceSlot, source, canAdd);
+            remaining -= canAdd;
+        }
+        return remaining;
+    }
+
+    /**
+     * Utility method for LEFT_SHIFT. Java has some specific logic where it will fill empty slots AFTER attempting to fill partial slots...
+     * 
+     * @return The remaining item count
+     */
+    private int fillEmptySlots(int sourceSlot, GeyserItemStack source, int remaining, int rangeStart, int rangeEnd) {
+        if (remaining <= 0) return 0; // we already return early within the underlying loop, this is a sanity check and/or readability to avoid confusion
+        for (int i = rangeStart; i <= rangeEnd && remaining > 0; i++) {
+            if (!isEmpty(i)) continue;
+
+            int toMove = Math.min(remaining, source.getMaxStackSize());
+
+            setItem(i, source.copy(toMove));
+            sub(sourceSlot, source, toMove);
+            remaining -= toMove;
+        }
+        return remaining;
+    }
+
     /**
      * @return a new set of all affected slots.
      */

core/src/main/java/org/geysermc/geyser/translator/inventory/StonecutterInventoryTranslator.java

@@ -25,15 +25,19 @@
 
 package org.geysermc.geyser.translator.inventory;
 
+import it.unimi.dsi.fastutil.ints.IntSet;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.cloudburstmc.protocol.bedrock.data.inventory.ContainerSlotType;
 import org.cloudburstmc.protocol.bedrock.data.inventory.itemstack.request.ItemStackRequest;
 import org.cloudburstmc.protocol.bedrock.data.inventory.itemstack.request.ItemStackRequestSlotData;
 import org.cloudburstmc.protocol.bedrock.data.inventory.itemstack.request.action.CraftRecipeAction;
 import org.cloudburstmc.protocol.bedrock.data.inventory.itemstack.request.action.ItemStackRequestAction;
 import org.cloudburstmc.protocol.bedrock.data.inventory.itemstack.request.action.ItemStackRequestActionType;
+import org.cloudburstmc.protocol.bedrock.data.inventory.itemstack.request.action.TransferItemStackRequestAction;
 import org.cloudburstmc.protocol.bedrock.data.inventory.itemstack.response.ItemStackResponse;
 import org.geysermc.geyser.inventory.*;
+import org.geysermc.geyser.inventory.click.Click;
+import org.geysermc.geyser.inventory.click.ClickPlan;
 import org.geysermc.geyser.inventory.recipe.GeyserStonecutterData;
 import org.geysermc.geyser.inventory.updater.UIInventoryUpdater;
 import org.geysermc.geyser.level.block.Blocks;
@@ -79,6 +83,48 @@ protected ItemStackResponse translateSpecialRequest(GeyserSession session, Stone
             container.setItem(1, GeyserItemStack.from(session, javaOutput), session);
         }
 
+        // The client might send multiple ItemStackRequests for one shift click,
+        // so check if input is empty, meaning we already sent one
+        GeyserItemStack input = container.getItem(0);
+        if (input.isEmpty()) {
+            return rejectRequest(request, false);
+        }
+
+        // support for quick move on the output.
+        // CRAFT_RECIPE is always at index 0 so we do instanceof checks for obvious reasons
+        if (data.getNumberOfRequestedCrafts() > 1) {
+            for (ItemStackRequestAction action : request.getActions()) {
+                if (action instanceof TransferItemStackRequestAction transfer) {
+                    if (transfer.getSource().getContainerName().getContainer() == ContainerSlotType.CREATED_OUTPUT) {
+                        ContainerSlotType destContainer = transfer.getDestination().getContainerName().getContainer();
+
+                        if (destContainer == ContainerSlotType.HOTBAR
+                            || destContainer == ContainerSlotType.HOTBAR_AND_INVENTORY
+                            || destContainer == ContainerSlotType.INVENTORY) {
+
+                            // shift click of the result into the inventory
+                            ClickPlan plan = new ClickPlan(session, this, container);
+                            plan.add(Click.LEFT_SHIFT, 1);
+                            plan.execute(true);
+
+                            // slot 0 = stonecutter input, special logic here as getGridSize is non existent! yay!
+                            // from my testing, this seems to cause ClickPlan#reduceCraftingGrid to return early which is
+                            // why we have to handle this logic ourselves...
+                            // to do, check in to the mental asylum
+                            container.setItem(0, GeyserItemStack.EMPTY, session); // assume that all input was used. server will resync
+
+                            // we need to ALWAYS update slot 0 as well so that the client knows the new input count
+                            IntSet reportedSlots = plan.getAffectedSlots();
+                            reportedSlots.add(0);
+
+                            return acceptRequest(request, makeContainerEntries(session, container, reportedSlots));
+                        }
+                    }
+                }
+            }
+        }
+        
+        // translate the request normally as it's a plain single craft. no shift-click transfer actions found
         return translateRequest(session, container, request);
     }