Send controller nodes again with the new system

src/main/java/refinedstorage/apiimpl/network/NetworkNodeGraph.java

@@ -117,17 +117,27 @@ public class NetworkNodeGraph implements INetworkNodeGraph {
         this.nodeHashes = newNodeHashes;
 
         if (notify) {
+            boolean changed = false;
+
             for (INetworkNode newNode : nodes) {
                 if (!oldNodeHashes.contains(hashNode(newNode.getNodeWorld(), newNode))) {
                     newNode.onConnected(controller);
+
+                    changed = true;
                 }
             }
 
             for (INetworkNode oldNode : oldNodes) {
                 if (!nodeHashes.contains(hashNode(oldNode.getNodeWorld(), oldNode))) {
                     oldNode.onDisconnected(controller);
+
+                    changed = true;
                 }
             }
+
+            if (changed) {
+                controller.getDataManager().sendParameterToWatchers(TileController.NODES);
+            }
         }
     }
 
@@ -151,6 +161,8 @@ public class NetworkNodeGraph implements INetworkNodeGraph {
 
         nodes.clear();
         nodeHashes.clear();
+
+        controller.getDataManager().sendParameterToWatchers(TileController.NODES);
     }
 
     public World getWorld() {

src/main/java/refinedstorage/gui/GuiController.java

@@ -4,6 +4,7 @@ import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.client.renderer.RenderHelper;
 import refinedstorage.container.ContainerController;
 import refinedstorage.gui.sidebutton.SideButtonRedstoneMode;
+import refinedstorage.tile.ClientNode;
 import refinedstorage.tile.TileController;
 
 import java.util.List;
@@ -43,7 +44,7 @@ public class GuiController extends GuiBase {
 
         drawTexture(x, y, 0, 0, width, height);
 
-        int barHeightNew = controller.getEnergyScaled(barHeight);
+        int barHeightNew = TileController.getEnergyScaled(TileController.ENERGY_STORED.getValue(), TileController.ENERGY_CAPACITY.getValue(), barHeight);
 
         drawTexture(x + barX, y + barY + barHeight - barHeightNew, 178, barHeight - barHeightNew, barWidth, barHeightNew);
     }
@@ -60,23 +61,23 @@ public class GuiController extends GuiBase {
 
         RenderHelper.enableGUIStandardItemLighting();
 
-        List<TileController.ClientNode> nodes = controller.getClientNodes();
+        List<ClientNode> nodes = TileController.NODES.getValue();
 
-        TileController.ClientNode nodeHovering = null;
+        ClientNode nodeHovering = null;
 
         for (int i = 0; i < 4; ++i) {
             if (slot < nodes.size()) {
-                TileController.ClientNode node = nodes.get(slot);
+                ClientNode node = nodes.get(slot);
 
-                drawItem(x, y + 5, node.stack);
+                drawItem(x, y + 5, node.getStack());
 
                 float scale = 0.5f;
 
                 GlStateManager.pushMatrix();
                 GlStateManager.scale(scale, scale, 1);
 
-                drawString(calculateOffsetOnScale(x + 1, scale), calculateOffsetOnScale(y - 2, scale), node.stack.getDisplayName());
+                drawString(calculateOffsetOnScale(x + 1, scale), calculateOffsetOnScale(y - 2, scale), node.getStack().getDisplayName());
-                drawString(calculateOffsetOnScale(x + 21, scale), calculateOffsetOnScale(y + 10, scale), t("gui.refinedstorage:controller.machine_amount", node.amount));
+                drawString(calculateOffsetOnScale(x + 21, scale), calculateOffsetOnScale(y + 10, scale), t("gui.refinedstorage:controller.machine_amount", node.getAmount()));
 
                 GlStateManager.popMatrix();
 
@@ -96,7 +97,7 @@ public class GuiController extends GuiBase {
         }
 
         if (nodeHovering != null) {
-            drawTooltip(mouseX, mouseY, t("misc.refinedstorage:energy_usage_minimal", nodeHovering.energyUsage));
+            drawTooltip(mouseX, mouseY, t("misc.refinedstorage:energy_usage_minimal", nodeHovering.getEnergyUsage()));
         }
 
         if (inBounds(barX, barY, barWidth, barHeight, mouseX, mouseY)) {
@@ -109,7 +110,7 @@ public class GuiController extends GuiBase {
     }
 
     private int getRows() {
-        int max = (int) Math.ceil((float) controller.getClientNodes().size() / (float) 2);
+        int max = (int) Math.ceil((float) TileController.NODES.getValue().size() / (float) 2);
 
         return max < 0 ? 0 : max;
     }

src/main/java/refinedstorage/gui/GuiStorage.java

@@ -117,6 +117,8 @@ public class GuiStorage extends GuiBase {
     }
 
     public void updatePriority(int priority) {
-        priorityField.setText(String.valueOf(priority));
+        if (priorityField != null) {
+            priorityField.setText(String.valueOf(priority));
+        }
     }
 }

src/main/java/refinedstorage/gui/grid/GuiGrid.java

@@ -418,7 +418,9 @@ public class GuiGrid extends GuiBase {
     }
 
     public void updateSearchFieldFocus(int mode) {
-        searchField.setCanLoseFocus(!TileGrid.isSearchBoxModeWithAutoselection(mode));
+        if (searchField != null) {
-        searchField.setFocused(TileGrid.isSearchBoxModeWithAutoselection(mode));
+            searchField.setCanLoseFocus(!TileGrid.isSearchBoxModeWithAutoselection(mode));
+            searchField.setFocused(TileGrid.isSearchBoxModeWithAutoselection(mode));
+        }
     }
 }

src/main/java/refinedstorage/tile/ClientNode.java

@@ -0,0 +1,52 @@
+package refinedstorage.tile;
+
+import net.minecraft.item.ItemStack;
+import refinedstorage.api.storage.CompareUtils;
+
+public class ClientNode {
+    private ItemStack stack;
+    private int amount;
+    private int energyUsage;
+
+    public ClientNode(ItemStack stack, int amount, int energyUsage) {
+        this.stack = stack;
+        this.amount = amount;
+        this.energyUsage = energyUsage;
+    }
+
+    public ItemStack getStack() {
+        return stack;
+    }
+
+    public int getAmount() {
+        return amount;
+    }
+
+    public void setAmount(int amount) {
+        this.amount = amount;
+    }
+
+    public int getEnergyUsage() {
+        return energyUsage;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) {
+            return true;
+        }
+
+        if (!(other instanceof ClientNode)) {
+            return false;
+        }
+
+        return energyUsage == ((ClientNode) other).energyUsage && CompareUtils.compareStack(stack, ((ClientNode) other).stack);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = stack.hashCode();
+        result = 31 * result + energyUsage;
+        return result;
+    }
+}

src/main/java/refinedstorage/tile/TileController.java

@@ -3,6 +3,7 @@ package refinedstorage.tile;
 import cofh.api.energy.EnergyStorage;
 import cofh.api.energy.IEnergyReceiver;
 import net.darkhax.tesla.capability.TeslaCapabilities;
+import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
@@ -45,6 +46,7 @@ import refinedstorage.network.MessageGridUpdate;
 import refinedstorage.tile.config.IRedstoneConfigurable;
 import refinedstorage.tile.config.RedstoneMode;
 import refinedstorage.tile.data.ITileDataProducer;
+import refinedstorage.tile.data.RefinedStorageSerializers;
 import refinedstorage.tile.data.TileDataManager;
 import refinedstorage.tile.data.TileDataParameter;
 import refinedstorage.tile.externalstorage.ExternalStorage;
@@ -75,6 +77,41 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
         }
     });
 
+    public static final TileDataParameter<List<ClientNode>> NODES = TileDataManager.createParameter(RefinedStorageSerializers.CLIENT_NODE_SERIALIZER, new ITileDataProducer<List<ClientNode>, TileController>() {
+        @Override
+        public List<ClientNode> getValue(TileController tile) {
+            List<ClientNode> nodes = new ArrayList<>();
+
+            for (INetworkNode node : tile.nodeGraph.all()) {
+                if (node.canUpdate()) {
+                    IBlockState state = tile.worldObj.getBlockState(node.getPosition());
+
+                    ClientNode clientNode = new ClientNode(
+                        new ItemStack(state.getBlock(), 1, state.getBlock().getMetaFromState(state)),
+                        1,
+                        node.getEnergyUsage()
+                    );
+
+                    if (clientNode.getStack().getItem() != null) {
+                        if (nodes.contains(clientNode)) {
+                            for (ClientNode other : nodes) {
+                                if (other.equals(clientNode)) {
+                                    other.setAmount(other.getAmount() + 1);
+
+                                    break;
+                                }
+                            }
+                        } else {
+                            nodes.add(clientNode);
+                        }
+                    }
+                }
+            }
+
+            return nodes;
+        }
+    });
+
     public static final String NBT_ENERGY = "Energy";
     public static final String NBT_ENERGY_CAPACITY = "EnergyCapacity";
 
@@ -122,13 +159,12 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
 
     private RedstoneMode redstoneMode = RedstoneMode.IGNORE;
 
-    private List<ClientNode> clientNodes = new ArrayList<>();
-
     public TileController() {
         dataManager.addWatchedParameter(REDSTONE_MODE);
         dataManager.addWatchedParameter(ENERGY_USAGE);
         dataManager.addWatchedParameter(ENERGY_STORED);
         dataManager.addParameter(ENERGY_CAPACITY);
+        dataManager.addParameter(NODES);
 
         if (IntegrationIC2.isLoaded()) {
             this.energyEU = new ControllerEnergyIC2(this);
@@ -251,10 +287,6 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
         super.invalidate();
     }
 
-    public List<ClientNode> getClientNodes() {
-        return clientNodes;
-    }
-
     @Override
     public IGridHandler getGridHandler() {
         return gridHandler;
@@ -570,16 +602,16 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
         return energy.getEnergyStored();
     }
 
-    public int getEnergyScaled(int i) {
+    public static int getEnergyScaled(int stored, int capacity, int scale) {
-        return (int) ((float) energy.getEnergyStored() / (float) energy.getMaxEnergyStored() * (float) i);
+        return (int) ((float) stored / (float) capacity * (float) scale);
     }
 
     public int getEnergyScaledForDisplay() {
-        return getEnergyScaled(7);
+        return getEnergyScaled(energy.getEnergyStored(), energy.getMaxEnergyStored(), 7);
     }
 
     public int getEnergyScaledForComparator() {
-        return getEnergyScaled(15);
+        return getEnergyScaled(energy.getEnergyStored(), energy.getMaxEnergyStored(), 15);
     }
 
     @Override
@@ -625,79 +657,6 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
         return type == null ? EnumControllerType.NORMAL : type;
     }
 
-    // @TODO: Sync client nodes
-    /*@Override
-    public void readContainerData(ByteBuf buf) {
-        energy.setEnergyStored(buf.readInt());
-        this.energyUsage = buf.readInt();
-        this.redstoneMode = RedstoneMode.getById(buf.readInt());
-
-        List<ClientNode> nodes = new ArrayList<ClientNode>();
-
-        int size = buf.readInt();
-
-        for (int i = 0; i < size; ++i) {
-            ClientNode node = new ClientNode();
-
-            node.energyUsage = buf.readInt();
-            node.amount = buf.readInt();
-            node.stack = ByteBufUtils.readItemStack(buf);
-
-            nodes.add(node);
-        }
-
-        this.clientNodes = nodes;
-    }
-
-    @Override
-    public void writeContainerData(ByteBuf buf) {
-        buf.writeInt(energy.getEnergyStored());
-        buf.writeInt(getEnergyUsage());
-
-        buf.writeInt(redstoneMode.id);
-
-        List<ClientNode> clientNodes = new ArrayList<ClientNode>();
-
-        for (INetworkNode node : nodeGraph.all()) {
-            if (node.canUpdate()) {
-                IBlockState state = worldObj.getBlockState(node.getPosition());
-
-                ClientNode clientNode = new ClientNode();
-
-                clientNode.energyUsage = node.getEnergyUsage();
-                clientNode.amount = 1;
-                clientNode.stack = new ItemStack(state.getBlock(), 1, state.getBlock().getMetaFromState(state));
-
-                if (clientNode.stack.getItem() != null) {
-                    if (clientNodes.contains(clientNode)) {
-                        for (ClientNode other : clientNodes) {
-                            if (other.equals(clientNode)) {
-                                other.amount++;
-
-                                break;
-                            }
-                        }
-                    } else {
-                        clientNodes.add(clientNode);
-                    }
-                }
-            }
-        }
-
-        buf.writeInt(clientNodes.size());
-
-        for (ClientNode node : clientNodes) {
-            buf.writeInt(node.energyUsage);
-            buf.writeInt(node.amount);
-            ByteBufUtils.writeItemStack(buf, node.stack);
-        }
-    }
-
-    @Override
-    public Class<? extends Container> getContainer() {
-        return ContainerController.class;
-    }*/
-
     @Override
     public <T> T getCapability(Capability<T> capability, EnumFacing facing) {
         if (energyTesla != null && (capability == TeslaCapabilities.CAPABILITY_HOLDER || capability == TeslaCapabilities.CAPABILITY_CONSUMER)) {
@@ -711,30 +670,4 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
     public boolean hasCapability(Capability<?> capability, EnumFacing facing) {
         return (energyTesla != null && (capability == TeslaCapabilities.CAPABILITY_HOLDER || capability == TeslaCapabilities.CAPABILITY_CONSUMER)) || super.hasCapability(capability, facing);
     }
-
-    public class ClientNode {
-        public ItemStack stack;
-        public int amount;
-        public int energyUsage;
-
-        @Override
-        public boolean equals(Object other) {
-            if (this == other) {
-                return true;
-            }
-
-            if (!(other instanceof ClientNode)) {
-                return false;
-            }
-
-            return energyUsage == ((ClientNode) other).energyUsage && CompareUtils.compareStack(stack, ((ClientNode) other).stack);
-        }
-
-        @Override
-        public int hashCode() {
-            int result = stack.hashCode();
-            result = 31 * result + energyUsage;
-            return result;
-        }
-    }
 }

src/main/java/refinedstorage/tile/data/RefinedStorageSerializers.java

@@ -0,0 +1,44 @@
+package refinedstorage.tile.data;
+
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.network.datasync.DataParameter;
+import net.minecraft.network.datasync.DataSerializer;
+import net.minecraftforge.fml.common.network.ByteBufUtils;
+import refinedstorage.tile.ClientNode;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public final class RefinedStorageSerializers {
+    public static DataSerializer<List<ClientNode>> CLIENT_NODE_SERIALIZER = new DataSerializer<List<ClientNode>>() {
+        @Override
+        public void write(PacketBuffer buf, List<ClientNode> nodes) {
+            buf.writeInt(nodes.size());
+
+            for (ClientNode node : nodes) {
+                ByteBufUtils.writeItemStack(buf, node.getStack());
+                buf.writeInt(node.getAmount());
+                buf.writeInt(node.getEnergyUsage());
+            }
+        }
+
+        @Override
+        public List<ClientNode> read(PacketBuffer buf) throws IOException {
+            List<ClientNode> nodes = new ArrayList<>();
+
+            int size = buf.readInt();
+
+            for (int i = 0; i < size; ++i) {
+                nodes.add(new ClientNode(ByteBufUtils.readItemStack(buf), buf.readInt(), buf.readInt()));
+            }
+
+            return nodes;
+        }
+
+        @Override
+        public DataParameter<List<ClientNode>> createKey(int id) {
+            return null;
+        }
+    };
+}