Add Pipe Swapping functionality

src/main/java/gregtech/api/interfaces/tileentity/IKeyHandlerTile.java

@@ -0,0 +1,16 @@
+package gregtech.api.interfaces.tileentity;
+
+import net.minecraft.entity.player.EntityPlayer;
+
+public interface IKeyHandlerTile {
+
+    /**
+     * Called when a key interaction occurs
+     *
+     * @param aKey     The key identifier (e.g. KEY_CTRL = 1)
+     * @param aPressed True if key was pressed, false if released
+     * @param aPlayer  The player who triggered the key event
+     * @return True if the key event was handled
+     */
+    boolean onKeyInteraction(byte aKey, boolean aPressed, EntityPlayer aPlayer);
+}

src/main/java/gregtech/api/metatileentity/implementations/MTEFluid.java

@@ -38,24 +38,21 @@
 
 import org.apache.commons.lang3.tuple.MutableTriple;
 
+import com.gtnewhorizons.modularui.api.KeyboardUtil;
+
 import cpw.mods.fml.common.Optional;
 import gregtech.GTMod;
-import gregtech.api.enums.Dyes;
-import gregtech.api.enums.Materials;
-import gregtech.api.enums.Mods;
-import gregtech.api.enums.OrePrefixes;
-import gregtech.api.enums.ParticleFX;
-import gregtech.api.enums.SoundResource;
-import gregtech.api.enums.Textures;
-import gregtech.api.enums.ToolModes;
+import gregtech.api.enums.*;
 import gregtech.api.interfaces.IIconContainer;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.ICoverable;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.interfaces.tileentity.IKeyHandlerTile;
 import gregtech.api.items.MetaGeneratedTool;
 import gregtech.api.metatileentity.BaseMetaPipeEntity;
 import gregtech.api.metatileentity.MetaPipeEntity;
+import gregtech.api.net.GTPacketKeyEvent;
 import gregtech.api.render.TextureFactory;
 import gregtech.api.util.CoverBehavior;
 import gregtech.api.util.CoverBehaviorBase;
@@ -64,14 +61,15 @@
 import gregtech.api.util.ISerializableObject;
 import gregtech.api.util.WorldSpawnedEventBuilder.ParticleEventBuilder;
 import gregtech.common.GTClient;
+import gregtech.common.blocks.ItemMachines;
 import gregtech.common.config.Other;
 import gregtech.common.covers.CoverDrain;
 import gregtech.common.covers.CoverFluidRegulator;
 import gregtech.common.covers.CoverInfo;
 import mcp.mobius.waila.api.IWailaConfigHandler;
 import mcp.mobius.waila.api.IWailaDataAccessor;
 
-public class MTEFluid extends MetaPipeEntity {
+public class MTEFluid extends MetaPipeEntity implements IKeyHandlerTile {
 
     protected static final EnumMap<ForgeDirection, EnumMap<Border, ForgeDirection>> FACE_BORDER_MAP = new EnumMap<>(
         ForgeDirection.class);
@@ -111,6 +109,7 @@ public class MTEFluid extends MetaPipeEntity {
     public final boolean mGasProof;
     public final FluidStack[] mFluids;
     public byte mLastReceivedFrom = 0, oLastReceivedFrom = 0;
+    public static final byte KEY_CTRL = 1;
     /**
      * Bitmask for whether disable fluid input form each side.
      */
@@ -473,6 +472,163 @@ public void blockPipeOnSide(ForgeDirection side, EntityPlayer entityPlayer, byte
         }
     }
 
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, ForgeDirection side,
+        float aX, float aY, float aZ) {
+        if (aBaseMetaTileEntity.isClientSide()) {
+            if (KeyboardUtil.isCtrlKeyDown()) {
+                GTUtility.sendChatToPlayer(aPlayer, "Ctrl+Rightclick");
+                // Send key event packet with player name
+                GTValues.NW.sendToServer(
+                    new GTPacketKeyEvent(
+                        aBaseMetaTileEntity.getXCoord(),
+                        (short) aBaseMetaTileEntity.getYCoord(),
+                        aBaseMetaTileEntity.getZCoord(),
+                        KEY_CTRL,
+                        (byte) 1,
+                        aPlayer.getCommandSenderName()));
+                return true;
+            }
+            return false;
+        }
+        return super.onRightclick(aBaseMetaTileEntity, aPlayer, side, aX, aY, aZ);
+    }
+
+    // Implement the IKeyHandlerTile interface
+    @Override
+    public boolean onKeyInteraction(byte aKey, boolean aPressed, EntityPlayer aPlayer) {
+        if (aKey == KEY_CTRL && aPressed) {
+            IGregTechTileEntity te = getBaseMetaTileEntity();
+            if (te == null || aPlayer == null) return false;
+
+            // Now we use the exact player who triggered the event
+            final ItemStack handItem = aPlayer.inventory.getCurrentItem();
+            IMetaTileEntity meta = ItemMachines.getMetaTileEntity(handItem);
+            if (!(meta instanceof MTEFluid handFluid)) return false;
+
+            if (aPlayer == null) return false;
+
+            // Store old state before any changes
+            byte oldConnections = this.mConnections;
+            short oldMetaID = (short) te.getMetaTileID();
+
+            // Create new pipe using newMetaEntity to ensure proper initialization
+            MTEFluid newPipe = (MTEFluid) handFluid.newMetaEntity(te);
+            if (newPipe == null) return false;
+
+            // Preserve connections
+            newPipe.mConnections = oldConnections;
+
+            // Store values for comparison
+            long oldCapacity = this.mCapacity;
+            boolean oldGasProof = this.mGasProof;
+            int oldHeatResistance = this.mHeatResistance;
+
+            // Update the pipe
+            te.setMetaTileID((short) handItem.getItemDamage());
+            te.setMetaTileEntity(newPipe);
+
+            // Build status change message
+            StringBuilder message = new StringBuilder();
+
+            // Capacity change
+            if (oldCapacity != newPipe.mCapacity) {
+                message.append(oldCapacity * 20)
+                    .append("L/s → ");
+                if (newPipe.mCapacity > oldCapacity) {
+                    message.append(EnumChatFormatting.GREEN);
+                } else {
+                    message.append(EnumChatFormatting.RED);
+                }
+                message.append(newPipe.mCapacity * 20)
+                    .append("L/s");
+                message.append(EnumChatFormatting.RESET);
+            }
+
+            // Heat resistance change
+            if (oldHeatResistance != newPipe.mHeatResistance) {
+                if (message.length() > 0) message.append(" | ");
+                message.append(oldHeatResistance)
+                    .append("K → ");
+                if (newPipe.mHeatResistance > oldHeatResistance) {
+                    message.append(EnumChatFormatting.GREEN);
+                } else {
+                    message.append(EnumChatFormatting.RED);
+                }
+                message.append(newPipe.mHeatResistance)
+                    .append("K");
+                message.append(EnumChatFormatting.RESET);
+            }
+
+            // Gas handling change
+            if (oldGasProof != newPipe.mGasProof) {
+                if (message.length() > 0) message.append(" | ");
+                if (newPipe.mGasProof) {
+                    message.append(EnumChatFormatting.GREEN)
+                        .append("Now Gas-Proof");
+                } else {
+                    message.append(EnumChatFormatting.RED)
+                        .append("No Longer Gas-Proof");
+                }
+                message.append(EnumChatFormatting.RESET);
+            }
+
+            // Send message if there were any changes
+            if (message.length() > 0) {
+                GTUtility.sendChatToPlayer(
+                    aPlayer,
+                    StatCollector.translateToLocal("GT5U.item.pipe.swap") + message.toString());
+            }
+
+            // Force updates
+            te.markDirty();
+            te.issueTextureUpdate();
+            te.issueBlockUpdate();
+            te.issueClientUpdate();
+
+            // Handle inventory swapping
+            if (!aPlayer.capabilities.isCreativeMode) {
+                // Create ItemStack for the removed pipe
+                ItemStack oldPipe = new ItemStack(handItem.getItem(), 1, oldMetaID);
+
+                // Try to give the old pipe to the player
+                boolean addedToInventory = false;
+                if (oldPipe != null) {
+                    // First try to stack with existing pipes
+                    for (int i = 0; i < aPlayer.inventory.mainInventory.length; i++) {
+                        ItemStack slot = aPlayer.inventory.mainInventory[i];
+                        if (slot != null && slot.getItem() == oldPipe.getItem()
+                            && slot.getItemDamage() == oldPipe.getItemDamage()
+                            && slot.stackSize < slot.getMaxStackSize()) {
+                            slot.stackSize++;
+                            addedToInventory = true;
+                            break;
+                        }
+                    }
+
+                    // If couldn't stack, try to find empty slot
+                    if (!addedToInventory) {
+                        addedToInventory = aPlayer.inventory.addItemStackToInventory(oldPipe);
+                    }
+
+                    // If still couldn't add, drop in world
+                    if (!addedToInventory) {
+                        aPlayer.dropPlayerItemWithRandomChoice(oldPipe, false);
+                    }
+                }
+
+                // Use one pipe from player's hand
+                handItem.stackSize--;
+                if (handItem.stackSize <= 0) {
+                    aPlayer.inventory.setInventorySlotContents(aPlayer.inventory.currentItem, null);
+                }
+            }
+
+            return true;
+        }
+        return false;
+    }
+
     @Override
     public boolean onWrenchRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer entityPlayer,
         float aX, float aY, float aZ, ItemStack aTool) {

src/main/java/gregtech/api/net/GTPacketKeyEvent.java

@@ -0,0 +1,112 @@
+package gregtech.api.net;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+import com.google.common.io.ByteArrayDataInput;
+
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.interfaces.tileentity.IKeyHandlerTile;
+import gregtech.api.util.GTUtility;
+import io.netty.buffer.ByteBuf;
+
+public class GTPacketKeyEvent extends GTPacket {
+
+    private int mX, mZ;
+    private short mY;
+    private byte mKey;
+    private byte mAction;
+    private String mPlayerName; // Add player name
+
+    public GTPacketKeyEvent() {
+        super();
+    }
+
+    public GTPacketKeyEvent(int aX, short aY, int aZ, byte aKey, byte aAction, String aPlayerName) {
+        super();
+        mX = aX;
+        mY = aY;
+        mZ = aZ;
+        mKey = aKey;
+        mAction = aAction;
+        mPlayerName = aPlayerName;
+    }
+
+    @Override
+    public byte getPacketID() {
+        return GTPacketTypes.KEY_EVENT.id;
+    }
+
+    @Override
+    public void encode(ByteBuf aOut) {
+        aOut.writeInt(mX);
+        aOut.writeShort(mY);
+        aOut.writeInt(mZ);
+        aOut.writeByte(mKey);
+        aOut.writeByte(mAction);
+        writeString(aOut, mPlayerName);
+    }
+
+    @Override
+    public GTPacket decode(ByteArrayDataInput aData) {
+        return new GTPacketKeyEvent(
+            aData.readInt(),
+            aData.readShort(),
+            aData.readInt(),
+            aData.readByte(),
+            aData.readByte(),
+            readString(aData));
+    }
+
+    private void writeString(ByteBuf buf, String str) {
+        byte[] bytes = str.getBytes(java.nio.charset.StandardCharsets.UTF_8);
+        buf.writeInt(bytes.length);
+        buf.writeBytes(bytes);
+    }
+
+    private String readString(ByteArrayDataInput data) {
+        int length = data.readInt();
+        byte[] bytes = new byte[length];
+        data.readFully(bytes);
+        return new String(bytes, java.nio.charset.StandardCharsets.UTF_8);
+    }
+
+    @Override
+    public void process(IBlockAccess aWorld) {
+        if (!(aWorld instanceof World) || ((World) aWorld).isRemote) return;
+
+        World world = (World) aWorld;
+        TileEntity tTileEntity = world.getTileEntity(mX, mY, mZ);
+
+        // Find the player
+        EntityPlayer player = null;
+        for (Object obj : world.playerEntities) {
+            if (obj instanceof EntityPlayer && ((EntityPlayer) obj).getCommandSenderName()
+                .equals(mPlayerName)) {
+                player = (EntityPlayer) obj;
+                break;
+            }
+        }
+
+        if (player == null) {
+            // Can't send chat if we don't have a player
+            return;
+        }
+
+        GTUtility.sendChatToPlayer(player, "Processing packet at: " + mX + ", " + mY + ", " + mZ);
+
+        if (tTileEntity instanceof IGregTechTileEntity) {
+            IMetaTileEntity mte = ((IGregTechTileEntity) tTileEntity).getMetaTileEntity();
+            if (mte instanceof IKeyHandlerTile) {
+                ((IKeyHandlerTile) mte).onKeyInteraction(mKey, mAction == 1, player);
+            } else {
+                GTUtility.sendChatToPlayer(player, "Error: TileEntity does not handle key events");
+            }
+        } else {
+            GTUtility.sendChatToPlayer(player, "Error: Invalid TileEntity type");
+        }
+    }
+}

src/main/java/gregtech/api/net/GTPacketTypes.java

@@ -37,6 +37,7 @@ public enum GTPacketTypes {
     EIC(27, new PacketEIC()),
     CREATE_TILE_ENTITY(28, new GTPacketCreateTE()),
     NODE_INFO(29, new GTPacketNodeInfo()),
+    KEY_EVENT(30, new GTPacketKeyEvent()),
     // merge conflict prevention comment, keep a trailing comma above
     ;
 

src/main/java/gregtech/api/util/GTLanguageManager.java

@@ -427,6 +427,7 @@ public static void writePlaceholderStrings() {
         addStringLocalization("Interaction_DESCRIPTION_Index_213", "Input disabled");
         addStringLocalization("Interaction_DESCRIPTION_Index_214", "Connected");
         addStringLocalization("Interaction_DESCRIPTION_Index_215", "Disconnected");
+        addStringLocalization("Interaction_DESCRIPTION_Index_215.2", "Pipe Changed: ");
         addStringLocalization("Interaction_DESCRIPTION_Index_216", "Deprecated Recipe");
         addStringLocalization("Interaction_DESCRIPTION_Index_219", "Extended Facing: ");
         addStringLocalization("Interaction_DESCRIPTION_Index_220", "Single recipe locking disabled.");

src/main/resources/assets/gregtech/lang/en_US.lang

@@ -688,6 +688,7 @@ GT5U.item.pipe.gas_proof.yes=Yes
 GT5U.item.pipe.gas_proof.no=No
 GT5U.item.pipe.amount=Pipe Amount
 GT5U.item.pipe.empty=Empty
+GT5U.item.pipe.swap=Pipe Swapped:
 
 gt.behaviour.paintspray.infinite.gui.header=Select a Color
 gt.behaviour.paintspray.infinite.gui.lock_error=§eSpray can is §clocked§e! §bSneak middle-click to unlock.