Refactor MTECable to update MTE without block swap

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

@@ -55,6 +55,7 @@
 import gregtech.api.util.GTUtility;
 import gregtech.api.util.ISerializableObject;
 import gregtech.common.GTClient;
+import gregtech.common.blocks.ItemMachines;
 import gregtech.common.covers.CoverInfo;
 import gregtech.common.covers.CoverSolarPanel;
 import ic2.api.energy.EnergyNet;
@@ -263,6 +264,151 @@ public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
         }
     }
 
+    @Override
+    public void onLeftclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        // Only perform the logic if the player is sneaking.
+        if (!aPlayer.isSneaking()) {
+            return;
+        }
+
+        ItemStack handItem = aPlayer.inventory.getCurrentItem();
+        if (handItem == null) {
+            return;
+        }
+
+        IMetaTileEntity meta = ItemMachines.getMetaTileEntity(handItem);
+        if (!(meta instanceof MTECable handCable)) {
+            return;
+        }
+
+        // 1) Record & disconnect old cable from all sides where it was connected
+        MTECable oldCable = this;
+        byte oldConnections = oldCable.mConnections;
+
+        // We'll remember which sides were connected, so we can reconnect the new cable
+        List<ForgeDirection> oldConnectedSides = new ArrayList<>();
+        for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
+            if (oldCable.isConnectedAtSide(side)) {
+                oldConnectedSides.add(side);
+            }
+        }
+
+        short newMetaID = (short) handItem.getItemDamage();
+        long oldVoltage = this.mVoltage;
+        long oldAmperage = this.mAmperage;
+
+        // If the existing cable has the same specs as what we're holding, skip.
+        if (this.getClass() == handCable.getClass() && this.mMaterial == handCable.mMaterial
+            && this.mVoltage == handCable.mVoltage
+            && this.mAmperage == handCable.mAmperage) {
+            return;
+        }
+
+        short oldMetaID = (short) aBaseMetaTileEntity.getMetaTileID();
+
+        // Construct the new cable
+        MTECable newCable = new MTECable(
+            handCable.mName,
+            handCable.mThickNess,
+            handCable.mMaterial,
+            handCable.mCableLossPerMeter,
+            handCable.mAmperage,
+            handCable.mVoltage,
+            handCable.mInsulated,
+            handCable.mCanShock);
+
+        // Swap in the new cable
+        aBaseMetaTileEntity.setMetaTileID(newMetaID);
+        aBaseMetaTileEntity.setMetaTileEntity(newCable);
+
+        aBaseMetaTileEntity.markDirty();
+        aBaseMetaTileEntity.issueTextureUpdate();
+        aBaseMetaTileEntity.issueBlockUpdate();
+        aBaseMetaTileEntity.outputsEnergyTo(ForgeDirection.UNKNOWN, false);
+
+        // 7) Reconnect the *new* cable to the old sides
+        if (newCable.getBaseMetaTileEntity() != null) {
+            // For each side that was previously connected
+            for (ForgeDirection side : oldConnectedSides) {
+                int result = newCable.connect(side);
+                if (result > 0) {
+                    // Also force the neighbor to connect back if it is a cable
+                    IGregTechTileEntity neighborTile = newCable.getBaseMetaTileEntity()
+                        .getIGregTechTileEntityAtSide(side);
+                    if (neighborTile != null
+                        && neighborTile.getMetaTileEntity() instanceof IConnectable neighborCable) {
+                        neighborCable.connect(side.getOpposite());
+                    }
+                } else {
+                    newCable.disconnect(side);
+                }
+            }
+        } else {
+            GTUtility.sendChatToPlayer(aPlayer, "Warning: new cable's tile is null! No reconnect done.");
+        }
+
+        // Handle inventory changes (old <-> new cable) if not creative
+        if (!aPlayer.capabilities.isCreativeMode) {
+            ItemStack oldCableStack = new ItemStack(handItem.getItem(), 1, oldMetaID);
+            boolean addedToInventory = false;
+
+            if (oldCableStack != null) {
+                // Try stacking with existing inventory
+                for (int i = 0; i < aPlayer.inventory.mainInventory.length; i++) {
+                    ItemStack slot = aPlayer.inventory.mainInventory[i];
+                    if (slot != null && slot.getItem() == oldCableStack.getItem()
+                        && slot.getItemDamage() == oldCableStack.getItemDamage()
+                        && slot.stackSize < slot.getMaxStackSize()) {
+                        slot.stackSize++;
+                        addedToInventory = true;
+                        break;
+                    }
+                }
+
+                // If not stacked, add new item
+                if (!addedToInventory) {
+                    addedToInventory = aPlayer.inventory.addItemStackToInventory(oldCableStack);
+                }
+                // If still unsuccessful, drop it
+                if (!addedToInventory) {
+                    aPlayer.dropPlayerItemWithRandomChoice(oldCableStack, false);
+                }
+            }
+
+            // Decrease the held cable quantity
+            handItem.stackSize--;
+            if (handItem.stackSize <= 0) {
+                aPlayer.inventory.setInventorySlotContents(aPlayer.inventory.currentItem, null);
+            }
+        }
+
+        // Optionally, notify the player if voltage or amperage changed
+        if (oldAmperage != handCable.mAmperage || oldVoltage != handCable.mVoltage) {
+            StringBuilder message = new StringBuilder();
+            if (oldAmperage != handCable.mAmperage) {
+                message.append(oldAmperage)
+                    .append("A → ")
+                    .append(handCable.mAmperage > oldAmperage ? EnumChatFormatting.GREEN : EnumChatFormatting.RED)
+                    .append(handCable.mAmperage)
+                    .append("A")
+                    .append(EnumChatFormatting.RESET);
+            }
+            if (oldAmperage != handCable.mAmperage && oldVoltage != handCable.mVoltage) {
+                message.append(" | ");
+            }
+            if (oldVoltage != handCable.mVoltage) {
+                message.append(oldVoltage)
+                    .append("V → ")
+                    .append(handCable.mVoltage > oldVoltage ? EnumChatFormatting.GREEN : EnumChatFormatting.RED)
+                    .append(handCable.mVoltage)
+                    .append("V")
+                    .append(EnumChatFormatting.RESET);
+            }
+            GTUtility
+                .sendChatToPlayer(aPlayer, StatCollector.translateToLocal("GT5U.item.cable.swapped") + " " + message);
+        }
+    }
+
     @Override
     public boolean onWireCutterRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer aPlayer,
         float aX, float aY, float aZ) {

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

@@ -433,6 +433,7 @@ public static void writePlaceholderStrings() {
         addStringLocalization("Interaction_DESCRIPTION_Index_221", "Item threshold");
         addStringLocalization("Interaction_DESCRIPTION_Index_222", "Fluid threshold");
         addStringLocalization("Interaction_DESCRIPTION_Index_222.1", "Energy threshold");
+
         addStringLocalization(
             "Interaction_DESCRIPTION_Index_223",
             "Single recipe locking enabled. Will lock to next recipe.");

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

@@ -679,6 +679,7 @@ GT5U.item.cable.max_voltage=Max Voltage
 GT5U.item.cable.max_amperage=Max Amperage
 GT5U.item.cable.loss=Loss/Meter/Ampere
 GT5U.item.cable.eu_volt=EU-Volt
+GT5U.item.cable.swapped=Cable swapped:
 GT5U.item.tank.locked_to=Content locked to %s
 
 GT5U.item.pipe.capacity=Capacity