From 4cf57ee42f05d75ed12ac113d3b17003527bee2e Mon Sep 17 00:00:00 2001 From: Michael Doyle Date: Tue, 10 Jun 2025 03:01:34 -0400 Subject: [PATCH] Add Keybind to pull looked-at item into inventory from AE2 System --- .../github/loader/ChannelLoader.java | 6 + .../github/loader/KeybindLoader.java | 41 +++ .../network/CPacketPickBlockWithdraw.java | 300 ++++++++++++++++++ .../resources/assets/ae2fc/lang/en_US.lang | 1 + 4 files changed, 348 insertions(+) create mode 100644 src/main/java/com/glodblock/github/network/CPacketPickBlockWithdraw.java diff --git a/src/main/java/com/glodblock/github/loader/ChannelLoader.java b/src/main/java/com/glodblock/github/loader/ChannelLoader.java index 87fd2f96..69fa9088 100644 --- a/src/main/java/com/glodblock/github/loader/ChannelLoader.java +++ b/src/main/java/com/glodblock/github/loader/ChannelLoader.java @@ -15,6 +15,7 @@ import com.glodblock.github.network.CPacketLevelMaintainer; import com.glodblock.github.network.CPacketLevelTerminalCommands; import com.glodblock.github.network.CPacketPatternMultiSet; import com.glodblock.github.network.CPacketPatternValueSet; +import com.glodblock.github.network.CPacketPickBlockWithdraw; import com.glodblock.github.network.CPacketRenamer; import com.glodblock.github.network.CPacketSwitchGuis; import com.glodblock.github.network.CPacketTransferRecipe; @@ -93,6 +94,11 @@ public class ChannelLoader implements Runnable { SPacketLevelMaintainerGuiUpdate.class, id++, Side.CLIENT); + netHandler.registerMessage( + new CPacketPickBlockWithdraw.Handler(), + CPacketPickBlockWithdraw.class, + id++, + Side.SERVER); } public static void sendPacketToAllPlayers(Packet packet, World world) { diff --git a/src/main/java/com/glodblock/github/loader/KeybindLoader.java b/src/main/java/com/glodblock/github/loader/KeybindLoader.java index 81654539..3d4f9629 100644 --- a/src/main/java/com/glodblock/github/loader/KeybindLoader.java +++ b/src/main/java/com/glodblock/github/loader/KeybindLoader.java @@ -4,12 +4,15 @@ import net.minecraft.client.Minecraft; import net.minecraft.client.entity.EntityClientPlayerMP; import net.minecraft.client.settings.KeyBinding; import net.minecraft.item.ItemStack; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.MovingObjectPosition; import org.apache.commons.lang3.tuple.ImmutablePair; import org.lwjgl.input.Keyboard; import com.glodblock.github.FluidCraft; import com.glodblock.github.common.item.ItemWirelessUltraTerminal; +import com.glodblock.github.network.CPacketPickBlockWithdraw; import com.glodblock.github.network.CPacketValueConfig; import com.glodblock.github.util.Util; @@ -25,13 +28,16 @@ public class KeybindLoader implements Runnable { public static KeyBinding openTerminal; public static KeyBinding restock; + public static KeyBinding pickBlock; @Override public void run() { openTerminal = new KeyBinding(FluidCraft.MODID + ".key.OpenTerminal", Keyboard.CHAR_NONE, "itemGroup.ae2fc"); restock = new KeyBinding(FluidCraft.MODID + ".key.Restock", Keyboard.CHAR_NONE, "itemGroup.ae2fc"); + pickBlock = new KeyBinding(FluidCraft.MODID + ".key.PickBlock", Keyboard.CHAR_NONE, "itemGroup.ae2fc"); ClientRegistry.registerKeyBinding(openTerminal); ClientRegistry.registerKeyBinding(restock); + ClientRegistry.registerKeyBinding(pickBlock); FMLCommonHandler.instance().bus().register(this); } @@ -42,6 +48,8 @@ public class KeybindLoader implements Runnable { handleOpenTerminalKey(); } else if (restock.isPressed()) { handleRestockKey(); + } else if (pickBlock.isPressed()) { + handlePickBlockKey(); } } @@ -52,6 +60,8 @@ public class KeybindLoader implements Runnable { handleOpenTerminalKey(); } else if (restock.isPressed()) { handleRestockKey(); + } else if (pickBlock.isPressed()) { + handlePickBlockKey(); } } @@ -82,4 +92,35 @@ public class KeybindLoader implements Runnable { FluidCraft.proxy.netHandler.sendToServer(new CPacketValueConfig(0, 1)); } } + + private void handlePickBlockKey() { + Minecraft minecraft = Minecraft.getMinecraft(); + if (minecraft.currentScreen != null) return; // Don't act if a GUI is open + + EntityClientPlayerMP player = minecraft.thePlayer; + if (player == null) return; + + // Ensure the player has the wireless terminal + ImmutablePair terminalAndInventorySlot = Util.getUltraWirelessTerm(player); + if (terminalAndInventorySlot == null) { + player.addChatMessage(new ChatComponentText("Could not find wireless terminal.")); + return; + } + + ItemStack terminal = terminalAndInventorySlot.getRight(); + if (terminal == null || !(terminal.getItem() instanceof ItemWirelessUltraTerminal)) { + player.addChatMessage(new ChatComponentText("Terminal must be universal version.")); + return; + } + + // Get the block the player is currently looking at + MovingObjectPosition movingObject = minecraft.objectMouseOver; + if (movingObject == null || movingObject.typeOfHit != MovingObjectPosition.MovingObjectType.BLOCK) { + return; + } + + // Send packet to server with block coordinates + FluidCraft.proxy.netHandler.sendToServer( + new CPacketPickBlockWithdraw(movingObject.blockX, movingObject.blockY, movingObject.blockZ)); + } } diff --git a/src/main/java/com/glodblock/github/network/CPacketPickBlockWithdraw.java b/src/main/java/com/glodblock/github/network/CPacketPickBlockWithdraw.java new file mode 100644 index 00000000..3db8e0aa --- /dev/null +++ b/src/main/java/com/glodblock/github/network/CPacketPickBlockWithdraw.java @@ -0,0 +1,300 @@ +package com.glodblock.github.network; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.network.play.server.S09PacketHeldItemChange; +import net.minecraft.world.World; + +import org.apache.commons.lang3.tuple.ImmutablePair; + +import com.glodblock.github.common.item.ItemWirelessUltraTerminal; +import com.glodblock.github.inventory.item.WirelessCraftingTerminalInventory; +import com.glodblock.github.util.Util; + +import appeng.api.AEApi; +import appeng.api.networking.IGridNode; +import appeng.api.storage.data.IAEItemStack; +import appeng.api.storage.data.IAEStack; +import cpw.mods.fml.common.network.simpleimpl.IMessage; +import cpw.mods.fml.common.network.simpleimpl.IMessageHandler; +import cpw.mods.fml.common.network.simpleimpl.MessageContext; +import io.netty.buffer.ByteBuf; + +/** + * Network packet sent from client to server when a player looks at a block and requests to withdraw that block type + * from their wireless terminal's ME network. + * + *

+ * This packet handles the entire withdrawal flow including: + *

+ * + *

+ * The packet carries the coordinates of the block the player is looking at, which determines what item type to withdraw + * from the ME network. + */ +public class CPacketPickBlockWithdraw implements IMessage { + + private int blockX; + private int blockY; + private int blockZ; + + public CPacketPickBlockWithdraw() { + // Required for FML + } + + public CPacketPickBlockWithdraw(int x, int y, int z) { + this.blockX = x; + this.blockY = y; + this.blockZ = z; + } + + @Override + public void fromBytes(ByteBuf buf) { + this.blockX = buf.readInt(); + this.blockY = buf.readInt(); + this.blockZ = buf.readInt(); + } + + @Override + public void toBytes(ByteBuf buf) { + buf.writeInt(this.blockX); + buf.writeInt(this.blockY); + buf.writeInt(this.blockZ); + } + + public static class Handler implements IMessageHandler { + + @Override + public IMessage onMessage(CPacketPickBlockWithdraw message, MessageContext ctx) { + EntityPlayerMP player = ctx.getServerHandler().playerEntity; + if (player == null || player.inventory == null) { + return null; + } + World world = player.worldObj; + + // Ensure the player has the wireless terminal + ImmutablePair terminalAndInventorySlot = Util.getUltraWirelessTerm(player); + if (terminalAndInventorySlot == null) { + return null; + } + + ItemStack terminalStack = terminalAndInventorySlot.getRight(); + if (terminalStack == null || !(terminalStack.getItem() instanceof ItemWirelessUltraTerminal)) { + return null; + } + + IGridNode wirelessGrid = Util.getWirelessGrid(terminalStack); + if (wirelessGrid == null) { + return null; + } + + // Create the terminal inventory handler + WirelessCraftingTerminalInventory terminalInventory = new WirelessCraftingTerminalInventory( + terminalStack, + terminalAndInventorySlot.getLeft(), + wirelessGrid, + player); + + // Get the target block + Block targetBlock = world.getBlock(message.blockX, message.blockY, message.blockZ); + if (targetBlock == Blocks.air) { + return null; // Don't try to withdraw air + } + + Item targetItem = Item.getItemFromBlock(targetBlock); + if (targetItem == null) { + return null; // Should not happen for non-air blocks + } + + // Check player inventory for existing stacks to determine how much to withdraw. + ItemStack itemToFind = new ItemStack( + targetItem, + 1, + world.getBlockMetadata(message.blockX, message.blockY, message.blockZ)); + + // 1. Initial Scan for full/partial stacks + int fullStackSlot = -1; + List partialStackSlotsList = new ArrayList<>(); + for (int i = 0; i < player.inventory.mainInventory.length; i++) { + ItemStack stackInSlot = player.inventory.mainInventory[i]; + if (stackInSlot != null && stackInSlot.isItemEqual(itemToFind) + && ItemStack.areItemStackTagsEqual(stackInSlot, itemToFind)) { + if (stackInSlot.stackSize >= stackInSlot.getMaxStackSize()) { + fullStackSlot = i; + break; // Found a full stack, no need to do anything. + } + partialStackSlotsList.add(i); + } + } + + // 2. If a full stack already exists, put in active slot and return. + if (fullStackSlot >= 0) { + setSlotAsActiveSlot(player, fullStackSlot); + return null; + } + + // 3. If there are no partial stacks and the player's inventory is full, + // then return since we cannot add a retrieved stack to a full inventory + int nextEmptySlot = getFirstEmptyStackReverse(player.inventory); + if (partialStackSlotsList.isEmpty() && nextEmptySlot == -1) { + return null; + } + + // 4. Consolidate if multiple partial stacks exist. + ItemStack consolidatedStack = null; + int consolidatedStackSlot = -1; + for (Integer partialStackSlot : partialStackSlotsList) { + if (consolidatedStack == null) { + consolidatedStack = player.inventory.getStackInSlot(partialStackSlot); + consolidatedStackSlot = partialStackSlot; + } else { + consolidateItemStacks(player.inventory, partialStackSlot, consolidatedStackSlot); + } + + // Check if we created a full stack of items + if (consolidatedStack.stackSize == consolidatedStack.getMaxStackSize()) { + setSlotAsActiveSlot(player, consolidatedStackSlot); + return null; + } + } + + // Ensure the wireless terminal is within network range, + // if not, move consolidated stack to the active slot and return + if (!Util.rangeCheck(terminalStack, player, wirelessGrid)) { + setSlotAsActiveSlot(player, consolidatedStackSlot); + + // TODO: Return out of network range player message. + return null; + } + + // 5. Calculate withdrawal amount + int amountToWithdraw = consolidatedStack == null ? itemToFind.getMaxStackSize() + : itemToFind.getMaxStackSize() - consolidatedStack.stackSize; + if (amountToWithdraw <= 0) { + return null; + } + + // Create an IAEItemStack for the target block with the calculated amount + ItemStack targetItemStack = itemToFind.copy(); + targetItemStack.stackSize = amountToWithdraw; + IAEItemStack targetAeItemStack = AEApi.instance().storage().createItemStack(targetItemStack); + if (targetAeItemStack == null) { + return null; + } + + // 6. Extract items from the network + IAEStack extractedStack = terminalInventory.extractItems(targetAeItemStack); + if (extractedStack instanceof IAEItemStack extractedAeItemStack && extractedStack.getStackSize() > 0) { + ItemStack itemsToGive = extractedAeItemStack.getItemStack(); + // Update the player's inventory with the withdrawn items + if (itemsToGive != null && itemsToGive.stackSize > 0) { + if (consolidatedStack == null) { + player.inventory.setInventorySlotContents(nextEmptySlot, itemsToGive); + } else { + consolidatedStack.stackSize += itemsToGive.stackSize; + } + player.inventory.markDirty(); + } + } + + // If the target stack is already in the player's hotbar, set that as the active slot. + // Otherwise, move the target stack to the active slot. + int slotToSwap = consolidatedStack == null ? nextEmptySlot : consolidatedStackSlot; + setSlotAsActiveSlot(player, slotToSwap); + + return null; // No reply packet needed + } + + private int getFirstEmptyStackReverse(InventoryPlayer inventory) { + for (int i = inventory.mainInventory.length - 1; i >= 0; --i) { + if (inventory.mainInventory[i] == null) { + return i; + } + } + + return -1; + } + + private void setSlotAsActiveSlot(EntityPlayerMP player, int slot) { + if (slot >= 0 && slot <= 8) { + player.inventory.currentItem = slot; + player.playerNetServerHandler.sendPacket(new S09PacketHeldItemChange(slot)); + } else { + swapInventorySlots(player.inventory, player.inventory.currentItem, slot); + } + player.inventory.markDirty(); + } + + /** + * Moves an ItemStack from a source slot to a destination slot in the player's inventory. If the destination + * slot is occupied, the items are swapped. + * + * @param inventory The player's inventory. + * @param slot1 The index of the first ItemStack to move. + * @param slot2 The index of the second ItemStack to move. + */ + private void swapInventorySlots(InventoryPlayer inventory, int slot1, int slot2) { + if (slot1 == slot2) { + return; + } + + // Get the stacks from both slots + ItemStack sourceStack = inventory.getStackInSlot(slot1); + ItemStack destinationStack = inventory.getStackInSlot(slot2); + + // Set the destination slot with the source stack (even if it's null) + inventory.setInventorySlotContents(slot2, sourceStack); + + // Set the source slot with the original destination stack + inventory.setInventorySlotContents(slot1, destinationStack); + + // Mark the inventory as dirty to ensure changes are saved and synced + inventory.markDirty(); + } + + /** + * Consolidate ItemStacks from a source slot to a destination slot in the player's inventory. + * + * @param inventory The player's inventory. + * @param sourceSlot The index of the slot to move the item from. + * @param destinationSlot The index of the slot to move the item to. + */ + private void consolidateItemStacks(InventoryPlayer inventory, int sourceSlot, int destinationSlot) { + ItemStack sourceStack = inventory.getStackInSlot(sourceSlot); + ItemStack destinationStack = inventory.getStackInSlot(destinationSlot); + + if (!sourceStack.isItemEqual(destinationStack) + || !ItemStack.areItemStackTagsEqual(sourceStack, destinationStack)) { + return; + } + + int missingQuantity = destinationStack.getMaxStackSize() - destinationStack.stackSize; + if (missingQuantity >= sourceStack.stackSize) { + destinationStack.stackSize = destinationStack.stackSize + sourceStack.stackSize; + sourceStack = null; + } else { + sourceStack.stackSize -= missingQuantity; + destinationStack.stackSize += missingQuantity; + } + + // Update the inventory stacks + inventory.setInventorySlotContents(destinationSlot, destinationStack); + inventory.setInventorySlotContents(sourceSlot, sourceStack); + + // Mark the inventory as dirty to ensure changes are saved and synced + inventory.markDirty(); + } + } +} diff --git a/src/main/resources/assets/ae2fc/lang/en_US.lang b/src/main/resources/assets/ae2fc/lang/en_US.lang index 8a17a5ad..8cf25054 100644 --- a/src/main/resources/assets/ae2fc/lang/en_US.lang +++ b/src/main/resources/assets/ae2fc/lang/en_US.lang @@ -219,6 +219,7 @@ error.unknown=Unknown ae2fc.key.OpenTerminal=Open Wireless Universal Terminal ae2fc.key.Restock=Toggle Restock +ae2fc.key.PickBlock=AE2 Pick Block itemGroup.ae2fc=Fluid Craft For AE2