Made network transmitter work over dimensions

src/main/java/refinedstorage/api/network/INetworkMaster.java

@@ -38,9 +38,9 @@ public interface INetworkMaster {
     boolean canRun();
 
     /**
-     * @return A list with all the network nodes
+     * @return A graph of connected nodes to this network
      */
-    List<INetworkNode> getNodes();
+    INetworkNodeGraph getNodeGraph();
 
     /**
      * @return The {@link IGridHandler} for this network
@@ -101,11 +101,6 @@ public interface INetworkMaster {
      */
     void rebuildPatterns();
 
-    /**
-     * Rebuilds the network node list.
-     */
-    void rebuildNodes();
-
     /**
      * Returns crafting patterns from an item stack.
      *

src/main/java/refinedstorage/api/network/INetworkNodeGraph.java

@@ -0,0 +1,13 @@
+package refinedstorage.api.network;
+
+import net.minecraft.util.math.BlockPos;
+
+import java.util.List;
+
+public interface INetworkNodeGraph {
+    void rebuild(BlockPos start);
+
+    List<INetworkNode> all();
+
+    void disconnectAll();
+}

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

@@ -0,0 +1,148 @@
+package refinedstorage.apiimpl.network;
+
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import net.minecraftforge.common.DimensionManager;
+import refinedstorage.api.network.INetworkNode;
+import refinedstorage.api.network.INetworkNodeGraph;
+import refinedstorage.tile.TileNetworkTransmitter;
+import refinedstorage.tile.controller.TileController;
+
+import java.util.*;
+
+public class NetworkNodeGraph implements INetworkNodeGraph {
+    private TileController controller;
+
+    private List<INetworkNode> nodes = new ArrayList<INetworkNode>();
+    private Set<BlockPos> nodesPos = new HashSet<BlockPos>();
+
+    public NetworkNodeGraph(TileController controller) {
+        this.controller = controller;
+    }
+
+    @Override
+    public void rebuild(BlockPos start) {
+        if (!controller.canRun()) {
+            if (!nodes.isEmpty()) {
+                disconnectAll();
+            }
+
+            return;
+        }
+
+        World world = getWorld();
+
+        List<INetworkNode> newNodes = new ArrayList<INetworkNode>();
+        List<INetworkNode> interDimensionalNodes = new ArrayList<INetworkNode>();
+        Set<BlockPos> newNodesPos = new HashSet<BlockPos>();
+
+        Set<BlockPos> checked = new HashSet<BlockPos>();
+        Queue<BlockPos> toCheck = new ArrayDeque<BlockPos>();
+
+        checked.add(start);
+        toCheck.add(start);
+
+        for (EnumFacing facing : EnumFacing.VALUES) {
+            BlockPos pos = start.offset(facing);
+
+            checked.add(pos);
+            toCheck.add(pos);
+        }
+
+        BlockPos currentPos;
+        while ((currentPos = toCheck.poll()) != null) {
+            TileEntity tile = world.getTileEntity(currentPos);
+
+            if (tile instanceof TileController && !controller.getPos().equals(tile.getPos())) {
+                world.createExplosion(null, tile.getPos().getX(), tile.getPos().getY(), tile.getPos().getZ(), 4.5f, true);
+            }
+
+            if (!(tile instanceof INetworkNode)) {
+                continue;
+            }
+
+            INetworkNode node = (INetworkNode) tile;
+
+            newNodes.add(node);
+            newNodesPos.add(node.getPosition());
+
+            if (tile instanceof TileNetworkTransmitter) {
+                final TileNetworkTransmitter transmitter = (TileNetworkTransmitter) tile;
+
+                if (transmitter.canTransmit()) {
+                    if (!transmitter.isInSameDimension()) {
+                        NetworkNodeGraph dimensionGraph = new NetworkNodeGraph(controller) {
+                            @Override
+                            public World getWorld() {
+                                return DimensionManager.getWorld(transmitter.getReceiverDimension());
+                            }
+                        };
+
+                        dimensionGraph.rebuild(transmitter.getReceiver());
+
+                        interDimensionalNodes.addAll(dimensionGraph.all());
+                    } else {
+                        BlockPos receiver = transmitter.getReceiver();
+
+                        if (checked.add(receiver)) {
+                            toCheck.add(receiver);
+                        }
+                    }
+                }
+            }
+
+            if (node.canConduct()) {
+                for (EnumFacing facing : EnumFacing.VALUES) {
+                    BlockPos pos = currentPos.offset(facing);
+
+                    if (checked.add(pos)) {
+                        toCheck.add(pos);
+                    }
+                }
+            }
+        }
+
+        List<INetworkNode> oldNodes = new ArrayList<INetworkNode>(nodes);
+        Set<BlockPos> oldNodesPos = new HashSet<BlockPos>(nodesPos);
+
+        this.nodes = newNodes;
+        this.nodesPos = newNodesPos;
+
+        for (INetworkNode newNode : nodes) {
+            if (!oldNodesPos.contains(newNode.getPosition())) {
+                newNode.onConnected(controller);
+            }
+        }
+
+        for (INetworkNode oldNode : oldNodes) {
+            if (!nodesPos.contains(oldNode.getPosition())) {
+                oldNode.onDisconnected(controller);
+            }
+        }
+
+        this.nodes.addAll(interDimensionalNodes);
+    }
+
+    @Override
+    public List<INetworkNode> all() {
+        return nodes;
+    }
+
+    @Override
+    public void disconnectAll() {
+        for (INetworkNode node : nodes) {
+            if (node.isConnected()) {
+                node.onDisconnected(controller);
+            }
+        }
+
+        nodes.clear();
+        nodesPos.clear();
+    }
+
+    public World getWorld() {
+        return controller.getWorld();
+    }
+}

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

@@ -37,7 +37,7 @@ public class WirelessGridHandler implements IWirelessGridHandler {
     public boolean onOpen(EntityPlayer player, EnumHand hand) {
         boolean inRange = false;
 
-        for (INetworkNode node : network.getNodes()) {
+        for (INetworkNode node : network.getNodeGraph().all()) {
             if (node instanceof IWirelessTransmitter) {
                 IWirelessTransmitter transmitter = (IWirelessTransmitter) node;
 

src/main/java/refinedstorage/apiimpl/storage/GroupedStorage.java

@@ -30,7 +30,7 @@ public class GroupedStorage implements IGroupedStorage {
     public void rebuild() {
         storages.clear();
 
-        for (INetworkNode node : network.getNodes()) {
+        for (INetworkNode node : network.getNodeGraph().all()) {
             if (node.canUpdate() && node instanceof IStorageProvider) {
                 ((IStorageProvider) node).addStorages(storages);
             }

src/main/java/refinedstorage/block/BlockController.java

@@ -104,7 +104,7 @@ public class BlockController extends BlockBase {
     @Override
     public void breakBlock(World world, BlockPos pos, IBlockState state) {
         if (!world.isRemote) {
-            ((TileController) world.getTileEntity(pos)).disconnectAll();
+            ((TileController) world.getTileEntity(pos)).getNodeGraph().disconnectAll();
         }
 
         super.breakBlock(world, pos, state);
@@ -115,7 +115,7 @@ public class BlockController extends BlockBase {
         super.neighborChanged(state, world, pos, block);
 
         if (!world.isRemote) {
-            ((TileController) world.getTileEntity(pos)).rebuildNodes();
+            ((TileController) world.getTileEntity(pos)).getNodeGraph().rebuild(pos);
         }
     }
 

src/main/java/refinedstorage/block/BlockNode.java

@@ -63,7 +63,7 @@ public abstract class BlockNode extends BlockBase {
                 TileEntity tile = world.getTileEntity(pos.offset(facing));
 
                 if (tile instanceof TileNode && ((TileNode) tile).isConnected()) {
-                    ((TileNode) tile).getNetwork().rebuildNodes();
+                    ((TileNode) tile).getNetwork().getNodeGraph().rebuild(((TileNode) tile).getNetwork().getPosition());
 
                     break;
                 }
@@ -86,7 +86,7 @@ public abstract class BlockNode extends BlockBase {
         super.breakBlock(world, pos, state);
 
         if (network != null) {
-            network.rebuildNodes();
+            network.getNodeGraph().rebuild(network.getPosition());
         }
     }
 }

src/main/java/refinedstorage/gui/GuiNetworkTransmitter.java

@@ -39,8 +39,6 @@ public class GuiNetworkTransmitter extends GuiBase {
             distance = t("gui.refinedstorage:network_transmitter.different_dimension");
         } else if (networkTransmitter.getDistance() == -1) {
             distance = t("gui.refinedstorage:network_transmitter.missing_card");
-        } else if (!networkTransmitter.isReceiverValid()) {
-            distance = t("gui.refinedstorage:network_transmitter.missing_receiver");
         } else {
             distance = t("gui.refinedstorage:network_transmitter.distance", networkTransmitter.getDistance());
         }

src/main/java/refinedstorage/tile/TileNetworkTransmitter.java

@@ -28,7 +28,7 @@ public class TileNetworkTransmitter extends TileNode {
             }
 
             if (network != null) {
-                network.rebuildNodes();
+                network.getNodeGraph().rebuild(network.getPosition());
             }
         }
     };
@@ -39,7 +39,6 @@ public class TileNetworkTransmitter extends TileNode {
     // Used clientside
     private int distance;
     private boolean inSameDimension;
-    private boolean receiverValid;
 
     public TileNetworkTransmitter() {
         rebuildOnUpdateChange = true;
@@ -50,10 +49,7 @@ public class TileNetworkTransmitter extends TileNode {
     }
 
     public boolean canTransmit() {
-        return canUpdate()
+        return canUpdate() && receiver != null;
-            && receiver != null
-            && isInSameDimension()
-            && isReceiverValid();
     }
 
     @Override
@@ -78,7 +74,6 @@ public class TileNetworkTransmitter extends TileNode {
 
         buf.writeInt((receiver != null && isInSameDimension()) ? getDistance() : -1);
         buf.writeBoolean(isInSameDimension());
-        buf.writeBoolean(isReceiverValid());
     }
 
     @Override
@@ -87,7 +82,6 @@ public class TileNetworkTransmitter extends TileNode {
 
         distance = buf.readInt();
         inSameDimension = buf.readBoolean();
-        receiverValid = buf.readBoolean();
     }
 
     @Override
@@ -108,6 +102,10 @@ public class TileNetworkTransmitter extends TileNode {
         return receiver;
     }
 
+    public int getReceiverDimension() {
+        return receiverDimension;
+    }
+
     public int getDistance() {
         if (worldObj.isRemote) {
             return distance;
@@ -123,8 +121,4 @@ public class TileNetworkTransmitter extends TileNode {
     public boolean isInSameDimension() {
         return worldObj.isRemote ? inSameDimension : worldObj.provider.getDimension() == receiverDimension;
     }
-
-    public boolean isReceiverValid() {
-        return worldObj.isRemote ? receiverValid : (receiver != null && isInSameDimension() && worldObj.getTileEntity(receiver) instanceof TileNetworkReceiver);
-    }
 }

src/main/java/refinedstorage/tile/TileNode.java

@@ -45,7 +45,7 @@ public abstract class TileNode extends TileBase implements INetworkNode, ISynchr
                 onConnectionChange(network, update);
 
                 if (rebuildOnUpdateChange) {
-                    network.rebuildNodes();
+                    network.getNodeGraph().rebuild(network.getPosition());
                 }
             }
 

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

@@ -13,7 +13,6 @@ import net.minecraft.inventory.Container;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.nbt.NBTTagList;
-import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
 import net.minecraftforge.common.capabilities.Capability;
@@ -26,10 +25,7 @@ import refinedstorage.RefinedStorageBlocks;
 import refinedstorage.api.autocrafting.ICraftingPattern;
 import refinedstorage.api.autocrafting.ICraftingPatternContainer;
 import refinedstorage.api.autocrafting.ICraftingTask;
-import refinedstorage.api.network.IGridHandler;
+import refinedstorage.api.network.*;
-import refinedstorage.api.network.INetworkMaster;
-import refinedstorage.api.network.INetworkNode;
-import refinedstorage.api.network.IWirelessGridHandler;
 import refinedstorage.api.storage.CompareUtils;
 import refinedstorage.api.storage.IGroupedStorage;
 import refinedstorage.api.storage.IStorage;
@@ -37,6 +33,7 @@ import refinedstorage.apiimpl.autocrafting.BasicCraftingTask;
 import refinedstorage.apiimpl.autocrafting.CraftingPattern;
 import refinedstorage.apiimpl.autocrafting.ProcessingCraftingTask;
 import refinedstorage.apiimpl.network.GridHandler;
+import refinedstorage.apiimpl.network.NetworkNodeGraph;
 import refinedstorage.apiimpl.network.WirelessGridHandler;
 import refinedstorage.apiimpl.storage.GroupedStorage;
 import refinedstorage.block.BlockController;
@@ -49,7 +46,6 @@ import refinedstorage.network.MessageGridUpdate;
 import refinedstorage.tile.ISynchronizedContainer;
 import refinedstorage.tile.TileBase;
 import refinedstorage.tile.TileCrafter;
-import refinedstorage.tile.TileNetworkTransmitter;
 import refinedstorage.tile.config.IRedstoneModeConfig;
 import refinedstorage.tile.config.RedstoneMode;
 import refinedstorage.tile.externalstorage.ExternalStorage;
@@ -93,8 +89,7 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
         }
     };
 
-    private List<INetworkNode> nodes = new ArrayList<INetworkNode>();
+    private INetworkNodeGraph nodeGraph = new NetworkNodeGraph(this);
-    private Set<BlockPos> nodesPos = new HashSet<BlockPos>();
 
     private List<ICraftingPattern> patterns = new ArrayList<ICraftingPattern>();
 
@@ -139,6 +134,11 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
         return energy.getEnergyStored() > 0 && redstoneMode.isEnabled(worldObj, pos);
     }
 
+    @Override
+    public INetworkNodeGraph getNodeGraph() {
+        return nodeGraph;
+    }
+
     @Override
     public void update() {
         if (!worldObj.isRemote) {
@@ -189,7 +189,7 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
             if (couldRun != canRun()) {
                 couldRun = canRun();
 
-                rebuildNodes();
+                nodeGraph.rebuild(pos);
             }
 
             if (getEnergyScaledForDisplay() != lastEnergyDisplay) {
@@ -224,17 +224,6 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
         }
     }
 
-    public void disconnectAll() {
-        for (INetworkNode node : nodes) {
-            if (node.isConnected()) {
-                node.onDisconnected(this);
-            }
-        }
-
-        nodes.clear();
-        nodesPos.clear();
-    }
-
     @Override
     public void invalidate() {
         super.invalidate();
@@ -244,11 +233,6 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
         }
     }
 
-    @Override
-    public List<INetworkNode> getNodes() {
-        return nodes;
-    }
-
     public List<ClientNode> getClientNodes() {
         return clientNodes;
     }
@@ -364,7 +348,7 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
     public void rebuildPatterns() {
         patterns.clear();
 
-        for (INetworkNode node : nodes) {
+        for (INetworkNode node : nodeGraph.all()) {
             if (node instanceof TileCrafter && node.canUpdate()) {
                 TileCrafter crafter = (TileCrafter) node;
 
@@ -387,84 +371,6 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
         storage.rebuild();
     }
 
-    @Override
-    public void rebuildNodes() {
-        if (!canRun()) {
-            if (!nodes.isEmpty()) {
-                disconnectAll();
-            }
-
-            return;
-        }
-
-        List<INetworkNode> newNodes = new ArrayList<INetworkNode>();
-        Set<BlockPos> newNodesPos = new HashSet<BlockPos>();
-
-        Set<BlockPos> checked = new HashSet<BlockPos>();
-        Queue<BlockPos> toCheck = new ArrayDeque<BlockPos>();
-
-        for (EnumFacing facing : EnumFacing.VALUES) {
-            BlockPos pos = this.pos.offset(facing);
-
-            checked.add(pos);
-            toCheck.add(pos);
-        }
-
-        BlockPos currentPos;
-        while ((currentPos = toCheck.poll()) != null) {
-            TileEntity tile = worldObj.getTileEntity(currentPos);
-
-            if (tile instanceof TileController && !pos.equals(tile.getPos())) {
-                worldObj.createExplosion(null, tile.getPos().getX(), tile.getPos().getY(), tile.getPos().getZ(), 4.5f, true);
-            }
-
-            if (!(tile instanceof INetworkNode)) {
-                continue;
-            }
-
-            INetworkNode node = (INetworkNode) tile;
-
-            newNodes.add(node);
-            newNodesPos.add(node.getPosition());
-
-            if (tile instanceof TileNetworkTransmitter) {
-                BlockPos receiver = ((TileNetworkTransmitter) tile).getReceiver();
-
-                if (((TileNetworkTransmitter) tile).canTransmit() && checked.add(receiver)) {
-                    toCheck.add(receiver);
-                }
-            }
-
-            if (node.canConduct()) {
-                for (EnumFacing facing : EnumFacing.VALUES) {
-                    BlockPos pos = currentPos.offset(facing);
-
-                    if (checked.add(pos)) {
-                        toCheck.add(pos);
-                    }
-                }
-            }
-        }
-
-        List<INetworkNode> oldNodes = new ArrayList<INetworkNode>(nodes);
-        Set<BlockPos> oldNodesPos = new HashSet<BlockPos>(nodesPos);
-
-        this.nodes = newNodes;
-        this.nodesPos = newNodesPos;
-
-        for (INetworkNode newNode : nodes) {
-            if (!oldNodesPos.contains(newNode.getPosition())) {
-                newNode.onConnected(this);
-            }
-        }
-
-        for (INetworkNode oldNode : oldNodes) {
-            if (!nodesPos.contains(oldNode.getPosition())) {
-                oldNode.onDisconnected(this);
-            }
-        }
-    }
-
     @Override
     public void sendStorageToClient() {
         for (EntityPlayer player : worldObj.playerEntities) {
@@ -707,7 +613,7 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
         if (!worldObj.isRemote) {
             int usage = RefinedStorage.INSTANCE.controllerBaseUsage;
 
-            for (INetworkNode node : nodes) {
+            for (INetworkNode node : nodeGraph.all()) {
                 if (node.canUpdate()) {
                     usage += node.getEnergyUsage();
                 }
@@ -759,7 +665,7 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
 
         List<ClientNode> clientNodes = new ArrayList<ClientNode>();
 
-        for (INetworkNode node : nodes) {
+        for (INetworkNode node : nodeGraph.all()) {
             if (node.canUpdate()) {
                 IBlockState state = worldObj.getBlockState(node.getPosition());