sync before trip to Lucy

7 files changed, 315 insertions, 2 deletions

diff --git a/src/main/java/blocks/Block_FluidConduit.java b/src/main/java/blocks/Block_FluidConduit.java
new file mode 100644
index 0000000000..65d14cf7a3
--- /dev/null
+++ b/src/main/java/blocks/Block_FluidConduit.java
@@ -0,0 +1,40 @@
+package blocks;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import itemBlocks.IB_TFFTMultiHatch;
+import kekztech.KekzCore;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import tileentities.TE_FluidConduit;
+
+public class Block_FluidConduit extends BlockContainer {
+	
+	private static Block_FluidConduit instance = new Block_FluidConduit();
+	
+	private Block_FluidConduit() {
+		super(Material.glass);
+	}
+	
+	public static Block_FluidConduit getInstance() {
+		return instance;
+	}
+	
+	public void registerBlock() {
+		final String blockName = "kekztech_fluidconduit_block";
+		super.setBlockName(blockName);
+		super.setCreativeTab(CreativeTabs.tabMisc);
+		super.setBlockTextureName(KekzCore.MODID + ":" + "FluidConduit");
+		super.setHardness(3.0f);
+		super.setResistance(2.0f);
+		GameRegistry.registerBlock(getInstance(), IB_TFFTMultiHatch.class, blockName);
+	}
+	
+	@Override
+	public TileEntity createNewTileEntity(World world, int p_149915_2_) {
+		return new TE_FluidConduit(1000);
+	}
+
+}
diff --git a/src/main/java/blocks/Block_TFFTMultiHatch.java b/src/main/java/blocks/Block_TFFTMultiHatch.java
index dfceda0474..e8378f39e8 100644
--- a/src/main/java/blocks/Block_TFFTMultiHatch.java
+++ b/src/main/java/blocks/Block_TFFTMultiHatch.java
@@ -33,7 +33,7 @@ public class Block_TFFTMultiHatch extends BlockContainer {
 	}
 
 	@Override
-	public TileEntity createNewTileEntity(World p_149915_1_, int p_149915_2_) {
+	public TileEntity createNewTileEntity(World world, int p_149915_2_) {
 		return new TE_TFFTMultiHatch();
 	}
 	
diff --git a/src/main/java/itemBlocks/IB_FluidConduit.java b/src/main/java/itemBlocks/IB_FluidConduit.java
new file mode 100644
index 0000000000..2d1d9efc73
--- /dev/null
+++ b/src/main/java/itemBlocks/IB_FluidConduit.java
@@ -0,0 +1,21 @@
+package itemBlocks;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+
+public class IB_FluidConduit extends ItemBlock {
+
+	public IB_FluidConduit(Block block) {
+		super(block);
+	}
+	
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	@Override
+	public void addInformation(ItemStack stack, EntityPlayer player, List lines, boolean advancedTooltips) {
+		lines.add("A fluid conduit that properly interacts with multi-tanks");
+	}
+}
diff --git a/src/main/java/kekztech/ConduitNetworkController.java b/src/main/java/kekztech/ConduitNetworkController.java
new file mode 100644
index 0000000000..83f43cd54b
--- /dev/null
+++ b/src/main/java/kekztech/ConduitNetworkController.java
@@ -0,0 +1,152 @@
+package kekztech;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.UUID;
+
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+
+public class ConduitNetworkController implements Comparable<ConduitNetworkController> {
+	
+	private static final HashSet<ConduitNetworkController> instances = new HashSet<>();
+	
+	private final UUID uuid = UUID.randomUUID();
+	private final LinkedList<IConduit> conduits = new LinkedList<>();
+	private final HashMap<String, IConduit> sources = new HashMap<>(); // k = resource name, v = source conduit
+	
+	public ConduitNetworkController() {
+		
+	}
+	
+	/**
+	 * Places a new conduit as it's own network. Merges with adjacent networks automatically.
+	 *  
+	 * @param conduit
+	 * 			The conduit to be placed
+	 */
+	public static void placeConduit(IConduit conduit) {
+		
+		conduit.setNetwork(new ConduitNetworkController());
+		conduit.getNetwork().addConduit(conduit);
+		
+		final TileEntity te = (TileEntity) conduit;
+		final int x = te.xCoord;
+		final int y = te.yCoord;
+		final int z = te.zCoord;
+		
+		// Search for adjacent Networks on all six sides
+		final HashSet<ConduitNetworkController> networks = new HashSet<>();
+		final World world = te.getWorldObj();
+		final TileEntity te1x = world.getTileEntity(x + 1, y, z);
+		final TileEntity te0x = world.getTileEntity(x - 1, y, z);
+		final TileEntity te1y = world.getTileEntity(x, y + 1, z);
+		final TileEntity te0y = world.getTileEntity(x, y - 1, z);
+		final TileEntity te1z = world.getTileEntity(x, y, z + 1);
+		final TileEntity te0z = world.getTileEntity(x, y, z - 1);
+		if(te1x != null && te1x instanceof IConduit) {
+			final IConduit c = (IConduit) te1x;
+			networks.add(c.getNetwork());
+		}
+		if(te0x != null && te0x instanceof IConduit) {
+			final IConduit c = (IConduit) te0x;
+			networks.add(c.getNetwork());
+		}
+		if(te1y != null && te1y instanceof IConduit) {
+			final IConduit c = (IConduit) te1y;
+			networks.add(c.getNetwork());
+		}
+		if(te0y != null && te0y instanceof IConduit) {
+			final IConduit c = (IConduit) te0y;
+			networks.add(c.getNetwork());
+		}
+		if(te1z != null && te1z instanceof IConduit) {
+			final IConduit c = (IConduit) te1z;
+			networks.add(c.getNetwork());
+		}
+		if(te0z != null && te0z instanceof IConduit) {
+			final IConduit c = (IConduit) te0z;
+			networks.add(c.getNetwork());
+		}
+		// Return prematurely if no adjacent network was found
+		if(networks.size() == 0) {
+			return;
+		}
+		// Sort networks by descending size
+		final LinkedList<ConduitNetworkController> networkList = new LinkedList<>();
+		networkList.addAll(networks);
+		Collections.sort(networkList, Collections.reverseOrder());
+		// Larger networks consume smaller networks to reduce copying around data
+		while(networkList.size() > 1) {
+			final ConduitNetworkController l = networkList.get(networkList.size() - 2);
+			final ConduitNetworkController r = networkList.getLast();
+			l.appendNetwork(r);
+			networkList.removeLast();
+		}
+		
+	}
+	
+	/**
+	 * Deletes this conduit and breaks up adjacent networks into separate networks.
+	 * 
+	 * @param conduit
+	 * 			Conduit to be removed.
+	 */
+	public static void destroyConduit(IConduit conduit) {
+		
+	}
+	
+	public void run() {
+		
+	}
+	
+	@Override
+	public boolean equals(Object o) {
+		if(o instanceof ConduitNetworkController) {
+			final ConduitNetworkController network = (ConduitNetworkController) o;
+			return uuid.equals(network.getUUID());
+		} else {
+			return false;
+		}
+	}
+	
+	@Override
+	public int compareTo(ConduitNetworkController o) {
+		return (int) Math.signum(o.getSize() - this.getSize());
+	}
+	
+	public UUID getUUID() {
+		return uuid;
+	}
+	
+	public int getSize() {
+		return conduits.size();
+	}
+	
+	/**
+	 * Register a new conduit to this network.
+	 * 
+	 * @param conduit
+	 * 			New conduit.
+	 */
+	private void addConduit(IConduit conduit) {
+		conduits.add(conduit);
+	}
+	
+	/**
+	 * Merge another network with this one if they have been connected by a new conduit.
+	 * 
+	 * @param network
+	 * 			Network to merge with this one.
+	 */
+	private void appendNetwork(ConduitNetworkController network) {
+		
+	}
+	
+	private void updateSource() {
+		
+	}
+
+}
diff --git a/src/main/java/kekztech/IConduit.java b/src/main/java/kekztech/IConduit.java
new file mode 100644
index 0000000000..d36c590a63
--- /dev/null
+++ b/src/main/java/kekztech/IConduit.java
@@ -0,0 +1,23 @@
+package kekztech;
+
+public interface IConduit {
+	
+	public void setNetwork(ConduitNetworkController network);
+	public ConduitNetworkController getNetwork();
+	
+	/**
+	 * Returns the conduit's throughput capacity.
+	 * 
+	 * @return
+	 * 			The conduit's throughput capacity.
+	 */
+	public Number getCapacity();
+	
+	/**
+	 * Call when the throughput capacity was exceeded while traversing this conduit.
+	 */
+	public void onOverload();
+	
+	public boolean testForInputFilter(Object o);
+	public boolean testForOutputFilter(Object o);
+}
diff --git a/src/main/java/kekztech/KekzCore.java b/src/main/java/kekztech/KekzCore.java
index b9f8e47015..993b984d4a 100644
--- a/src/main/java/kekztech/KekzCore.java
+++ b/src/main/java/kekztech/KekzCore.java
@@ -222,7 +222,6 @@ public class KekzCore {
 				GT_Utility.getIntegratedCircuit(6),

 				GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Master, 2),

 				GT_OreDictUnificator.get(OrePrefixes.pipeTiny, Materials.Titanium, 25),

-				ItemList.Electric_Motor_EV.get(1L, (Object[]) null),

 				ItemList.Field_Generator_HV.get(1L, (Object[]) null)

 			};

 		GT_Values.RA.addAssemblerRecipe(

diff --git a/src/main/java/tileentities/TE_FluidConduit.java b/src/main/java/tileentities/TE_FluidConduit.java
new file mode 100644
index 0000000000..3a8f91b5be
--- /dev/null
+++ b/src/main/java/tileentities/TE_FluidConduit.java
@@ -0,0 +1,78 @@
+package tileentities;
+
+import kekztech.ConduitNetworkController;
+import kekztech.IConduit;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+import net.minecraftforge.fluids.IFluidHandler;
+
+public class TE_FluidConduit extends TileEntity implements IConduit, IFluidHandler {
+	
+	private final Number capacity;
+	
+	private ConduitNetworkController network;
+	
+	public TE_FluidConduit(Number capacity) {
+		this.capacity = capacity;
+	}
+	
+	@Override
+	public void setNetwork(ConduitNetworkController network) {
+		this.network = network;
+	}
+	
+	@Override
+	public ConduitNetworkController getNetwork() {
+		return network;
+	}
+	
+	@Override
+	public Number getCapacity() {
+		return capacity;
+	}
+
+	@Override
+	public void onOverload() {
+		
+	}
+
+	@Override
+	public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public boolean canFill(ForgeDirection from, Fluid fluid) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public boolean canDrain(ForgeDirection from, Fluid fluid) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public FluidTankInfo[] getTankInfo(ForgeDirection from) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+}