Make the Alchemic Router's UX Better

src/main/java/WayofTime/alchemicalWizardry/client/nei/IMCForNEI.java

@@ -96,6 +96,7 @@ public static void IMCSender() {
         sendInfoPage("AWWayofTime masterStone,blockAlchemicCalcinator", "nei.infopage.reagents.1");
         sendInfoPage("AWWayofTime masterStone,blockAlchemicCalcinator|<AWWayofTime:terrae>", "nei.infopage.reagents.2");
         sendInfoPage("AWWayofTime masterStone,blockAlchemicCalcinator,itemAttunedCrystal", "nei.infopage.reagents.3");
+        sendInfoPage("AWWayofTime masterStone,blockAlchemicCalcinator,itemAttunedCrystal", "nei.infopage.reagents.3b");
         sendInfoPage(
                 "AWWayofTime masterStone,blockAlchemicCalcinator,itemTankSegmenter,itemDestinationClearer",
                 "nei.infopage.reagents.4");

src/main/java/WayofTime/alchemicalWizardry/common/block/BlockReagentConduit.java

@@ -1,13 +1,21 @@
 package WayofTime.alchemicalWizardry.common.block;
 
+import java.util.List;
+import java.util.Map;
+
 import net.minecraft.block.BlockContainer;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ChatComponentTranslation;
 import net.minecraft.world.World;
 
 import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.Int3;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IReagentManipulator;
 import WayofTime.alchemicalWizardry.common.tileEntity.TEReagentConduit;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
@@ -41,6 +49,36 @@ public boolean canProvidePower() {
     @Override
     public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float what,
             float these, float are) {
+        if (!world.isRemote) {
+            ItemStack held = player.getHeldItem();
+            if (held == null || !(held.getItem() instanceof IReagentManipulator)) {
+                TileEntity tile = world.getTileEntity(x, y, z);
+                if (tile instanceof TEReagentConduit relay) {
+                    if (relay.reagentTargetList.isEmpty()) {
+                        player.addChatComponentMessage(
+                                new ChatComponentTranslation("message.reagentconduit.noconnections"));
+                    } else {
+                        player.addChatComponentMessage(
+                                new ChatComponentTranslation("message.reagentconduit.connections"));
+                        for (Map.Entry<Reagent, List<Int3>> entry : relay.reagentTargetList.entrySet()) {
+                            Reagent reagent = entry.getKey();
+                            List<Int3> offsets = entry.getValue();
+                            if (offsets == null) continue;
+                            for (Int3 offset : offsets) {
+                                player.addChatComponentMessage(
+                                        new ChatComponentTranslation(
+                                                "message.reagentconduit.connection.entry",
+                                                reagent.name(),
+                                                x + offset.x(),
+                                                y + offset.y(),
+                                                z + offset.z()));
+                            }
+                        }
+                    }
+                    return true;
+                }
+            }
+        }
         return super.onBlockActivated(world, x, y, z, player, side, what, these, are);
     }
 

src/main/java/WayofTime/alchemicalWizardry/common/items/energy/ItemAttunedCrystal.java

@@ -60,6 +60,9 @@ public String getItemStackDisplayName(ItemStack stack) {
     public void addInformation(ItemStack item, EntityPlayer player, List<String> tooltip, boolean adv) {
         tooltip.add(StatCollector.translateToLocal("tooltip.attunedcrystal.desc1"));
         tooltip.add(StatCollector.translateToLocal("tooltip.attunedcrystal.desc2"));
+        tooltip.add(StatCollector.translateToLocal("tooltip.attunedcrystal.desc3"));
+        tooltip.add(StatCollector.translateToLocal("tooltip.attunedcrystal.desc4"));
+        tooltip.add(StatCollector.translateToLocal("tooltip.attunedcrystal.desc5"));
 
         if (item.getTagCompound() == null) {
             return;
@@ -131,107 +134,141 @@ public ItemStack onItemRightClick(ItemStack itemStack, World world, EntityPlayer
             return itemStack;
         }
 
-        MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(world, player, false);
-
-        if (movingobjectposition == null) {
-            if (player.isSneaking()) {
+        // Sneak wipes the source first, then the reagent — regardless of where the cursor points.
+        if (player.isSneaking()) {
+            if (this.getHasSavedCoordinates(itemStack)) {
                 this.setHasSavedCoordinates(itemStack, false);
                 player.addChatComponentMessage(new ChatComponentTranslation("message.attunedcrystal.clearing"));
+            } else if (this.getReagent(itemStack) != null) {
+                this.clearReagent(itemStack);
+                player.addChatComponentMessage(new ChatComponentTranslation("message.attunedcrystal.reagentcleared"));
             }
+            return itemStack;
+        }
 
+        MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(world, player, false);
+        if (movingobjectposition == null
+                || movingobjectposition.typeOfHit != MovingObjectPosition.MovingObjectType.BLOCK) {
             return itemStack;
-        } else {
-            if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK) {
-                int x = movingobjectposition.blockX;
-                int y = movingobjectposition.blockY;
-                int z = movingobjectposition.blockZ;
+        }
 
-                TileEntity tile = world.getTileEntity(x, y, z);
+        int x = movingobjectposition.blockX;
+        int y = movingobjectposition.blockY;
+        int z = movingobjectposition.blockZ;
+
+        TileEntity tile = world.getTileEntity(x, y, z);
+        if (!(tile instanceof IReagentHandler relay)) {
+            return itemStack;
+        }
+
+        if (this.getHasSavedCoordinates(itemStack)) {
+            Int3 coords = this.getCoordinates(itemStack);
+            int dimension = this.getDimension(itemStack);
+            if (coords == null) {
+                return itemStack;
+            }
 
-                if (!(tile instanceof IReagentHandler relay)) {
+            // Re-clicking the saved source cycles its reagents, never tries to self-link.
+            if (dimension == world.provider.dimensionId && coords.x() == x && coords.y() == y && coords.z() == z) {
+                List<Reagent> reagentList = collectReagents(relay);
+                if (reagentList.size() <= 1) {
+                    player.addChatComponentMessage(
+                            new ChatComponentTranslation("message.attunedcrystal.error.cannotlinktoself"));
                     return itemStack;
                 }
 
-                if (player.isSneaking()) {
-                    ReagentContainerInfo[] infos = relay.getContainerInfo(ForgeDirection.UNKNOWN);
-                    if (infos != null) {
-                        List<Reagent> reagentList = getReagents(infos);
-
-                        Reagent pastReagent = this.getReagent(itemStack);
+                Reagent pastReagent = this.getReagent(itemStack);
+                int reagentLocation = reagentList.indexOf(pastReagent);
+                Reagent next = (reagentLocation == -1 || reagentLocation + 1 >= reagentList.size())
+                        ? reagentList.getFirst()
+                        : reagentList.get(reagentLocation + 1);
+                this.setReagentWithNotification(itemStack, next, player);
+                return itemStack;
+            }
 
-                        if (reagentList.isEmpty()) {
-                            return itemStack;
-                        }
+            if (dimension != world.provider.dimensionId || Math.abs(coords.x() - x) > maxDistance
+                    || Math.abs(coords.y() - y) > maxDistance
+                    || Math.abs(coords.z() - z) > maxDistance) {
+                player.addChatComponentMessage(new ChatComponentTranslation("message.attunedcrystal.error.toofar"));
+                return itemStack;
+            }
 
-                        int reagentLocation;
+            TileEntity pastTile = world.getTileEntity(coords.x(), coords.y(), coords.z());
+            if (!(pastTile instanceof TEReagentConduit pastRelay)) {
+                // Saved source is gone — clear it so the player can start over without a manual reset.
+                this.setHasSavedCoordinates(itemStack, false);
+                player.addChatComponentMessage(new ChatComponentTranslation("message.attunedcrystal.error.cannotfind"));
+                return itemStack;
+            }
 
-                        reagentLocation = reagentList.indexOf(pastReagent);
+            Reagent reagent = this.getReagent(itemStack);
+            if (reagent == null) {
+                player.addChatComponentMessage(new ChatComponentTranslation("message.attunedcrystal.error.noreagent"));
+                return itemStack;
+            }
 
-                        if (reagentLocation == -1 || reagentLocation + 1 >= reagentList.size()) {
-                            this.setReagentWithNotification(itemStack, reagentList.getFirst(), player);
-                        } else {
-                            this.setReagentWithNotification(itemStack, reagentList.get(reagentLocation + 1), player);
-                        }
-                    }
-                } else {
-                    if (this.getHasSavedCoordinates(itemStack)) {
-                        Int3 coords = this.getCoordinates(itemStack);
-                        int dimension = this.getDimension(itemStack);
-
-                        if (coords == null) {
-                            return itemStack;
-                        }
-
-                        if (dimension != world.provider.dimensionId || Math.abs(coords.x() - x) > maxDistance
-                                || Math.abs(coords.y() - y) > maxDistance
-                                || Math.abs(coords.z() - z) > maxDistance) {
-                            player.addChatComponentMessage(
-                                    new ChatComponentTranslation("message.attunedcrystal.error.toofar"));
-                            return itemStack;
-                        }
-
-                        TileEntity pastTile = world.getTileEntity(coords.x(), coords.y(), coords.z());
-                        if (!(pastTile instanceof TEReagentConduit pastRelay)) {
-                            player.addChatComponentMessage(
-                                    new ChatComponentTranslation("message.attunedcrystal.error.cannotfind"));
-                            return itemStack;
-                        }
-
-                        Reagent reagent = this.getReagent(itemStack);
-
-                        if (reagent == null) {
-                            return itemStack;
-                        }
-
-                        if (player.isSneaking()) {
-                            pastRelay.removeReagentDestinationViaActual(reagent, x, y, z);
-                        } else {
-                            if (pastRelay.addReagentDestinationViaActual(reagent, x, y, z)) {
-                                player.addChatComponentMessage(
-                                        new ChatComponentText(
-                                                StatCollector.translateToLocal("message.attunedcrystal.linked") + " "
-                                                        + reagent.name()));
-                            } else {
-                                player.addChatComponentMessage(
-                                        new ChatComponentTranslation("message.attunedcrystal.error.noconnections"));
-                            }
-                        }
-                        world.markBlockForUpdate(coords.x(), coords.y(), coords.z());
-                    } else {
-                        int dimension = world.provider.dimensionId;
-
-                        this.setDimension(itemStack, dimension);
-                        this.setCoordinates(itemStack, new Int3(x, y, z));
-
-                        player.addChatComponentMessage(new ChatComponentTranslation("message.attunedcrystal.linking"));
-                    }
-                }
+            if (pastRelay.hasReagentDestination(reagent, x, y, z)) {
+                player.addChatComponentMessage(new ChatComponentTranslation("message.attunedcrystal.error.duplicate"));
+            } else if (pastRelay.addReagentDestinationViaActual(reagent, x, y, z)) {
+                int used = pastRelay.getTotalConnections();
+                int max = pastRelay.maxConnextions;
+                player.addChatComponentMessage(
+                        new ChatComponentTranslation("message.attunedcrystal.linked", reagent.name(), used, max));
+                // Successful link: clear the source so the next click starts a fresh link, but
+                // keep the reagent so the player can fan out to multiple destinations quickly.
+                this.setHasSavedCoordinates(itemStack, false);
+            } else {
+                player.addChatComponentMessage(
+                        new ChatComponentTranslation("message.attunedcrystal.error.noconnections"));
             }
+            world.markBlockForUpdate(coords.x(), coords.y(), coords.z());
+            return itemStack;
         }
 
+        // No saved source — this click saves one and (when useful) copies its reagent.
+        if (tile instanceof TEReagentConduit conduit && conduit.getTotalConnections() >= conduit.maxConnextions) {
+            player.addChatComponentMessage(new ChatComponentTranslation("message.attunedcrystal.error.sourcefull"));
+            return itemStack;
+        }
+
+        List<Reagent> reagentList = collectReagents(relay);
+        Reagent currentReagent = this.getReagent(itemStack);
+        if (reagentList.isEmpty() && currentReagent == null) {
+            player.addChatComponentMessage(new ChatComponentTranslation("message.attunedcrystal.error.nothingtocopy"));
+            return itemStack;
+        }
+
+        // Keep the crystal's existing reagent if the source has it (or if the source is empty);
+        // otherwise replace with the source's first tank.
+        if (!reagentList.isEmpty() && (currentReagent == null || !reagentList.contains(currentReagent))) {
+            this.setReagentWithNotification(itemStack, reagentList.getFirst(), player);
+        }
+
+        this.setDimension(itemStack, world.provider.dimensionId);
+        this.setCoordinates(itemStack, new Int3(x, y, z));
+        player.addChatComponentMessage(new ChatComponentTranslation("message.attunedcrystal.linking", x, y, z));
+
         return itemStack;
     }
 
+    private static List<Reagent> collectReagents(IReagentHandler relay) {
+        List<Reagent> reagentList = new LinkedList<>();
+        ReagentContainerInfo[] infos = relay.getContainerInfo(ForgeDirection.UNKNOWN);
+        if (infos == null) {
+            return reagentList;
+        }
+        for (ReagentContainerInfo info : infos) {
+            if (info == null) continue;
+            ReagentStack reagentStack = info.reagent;
+            if (reagentStack == null) continue;
+            Reagent reagent = reagentStack.reagent;
+            if (reagent != null && !reagentList.contains(reagent)) {
+                reagentList.add(reagent);
+            }
+        }
+        return reagentList;
+    }
+
     public static List<Reagent> getReagents(ReagentContainerInfo[] infos) {
         List<Reagent> reagentList = new LinkedList<>();
         for (ReagentContainerInfo info : infos) {
@@ -248,6 +285,13 @@ public static List<Reagent> getReagents(ReagentContainerInfo[] infos) {
         return reagentList;
     }
 
+    public void clearReagent(ItemStack stack) {
+        if (!stack.hasTagCompound()) {
+            stack.setTagCompound(new NBTTagCompound());
+        }
+        stack.getTagCompound().setString("reagent", "");
+    }
+
     public void setCoordinates(ItemStack stack, Int3 coords) {
         if (!stack.hasTagCompound()) {
             stack.setTagCompound(new NBTTagCompound());