A little work on the mixer

src/main/java/resonantinduction/archaic/firebox/BlockHotPlate.java

@@ -28,7 +28,7 @@ public class BlockHotPlate extends BlockRI
 	{
 		super("hotPlate", Material.wood);
 		setBlockBounds(0, 0, 0, 1, 0.2f, 1);
-		this.setTickRandomly(true);
+		setTickRandomly(true);
 	}
 
 	@Override

src/main/java/resonantinduction/electrical/Electrical.java

@@ -41,7 +41,7 @@ import resonantinduction.electrical.wire.EnumWireMaterial;
 import resonantinduction.electrical.wire.ItemWire;
 import resonantinduction.mechanical.process.BlockGrinderWheel;
 import resonantinduction.mechanical.process.TileGrinderWheel;
-import resonantinduction.mechanical.process.TilePurifier;
+import resonantinduction.mechanical.process.TileMixer;
 import calclavia.lib.content.ContentRegistry;
 import calclavia.lib.network.PacketHandler;
 import calclavia.lib.recipe.UniversalRecipe;

src/main/java/resonantinduction/electrical/purifier/BlockMixer.java

@@ -6,7 +6,7 @@ import net.minecraft.world.World;
 import net.minecraftforge.common.ForgeDirection;
 import resonantinduction.core.Settings;
 import resonantinduction.core.prefab.block.BlockRIRotatable;
-import resonantinduction.mechanical.process.TilePurifier;
+import resonantinduction.mechanical.process.TileMixer;
 import universalelectricity.api.vector.VectorWorld;
 
 /**
@@ -22,44 +22,6 @@ public class BlockMixer extends BlockRIRotatable implements ITileEntityProvider
 		super("mixer", Settings.getNextBlockID());
 	}
 
-	@Override
-	public void onBlockAdded(World world, int x, int y, int z)
-	{
-		this.checkConflicts(world, x, y, z);
-	}
-
-	@Override
-	public void onNeighborBlockChange(World world, int x, int y, int z, int par5)
-	{
-		this.checkConflicts(world, x, y, z);
-	}
-
-	/**
-	 * Checks for any conflicting directions with other grinders.
-	 */
-	private void checkConflicts(World world, int x, int y, int z)
-	{
-		ForgeDirection facing = this.getDirection(world, x, y, z);
-
-		for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS)
-		{
-			if (dir != facing && dir != facing.getOpposite())
-			{
-				VectorWorld checkPos = (VectorWorld) new VectorWorld(world, x, y, z).modifyPositionFromSide(dir);
-				TileEntity tileEntity = checkPos.getTileEntity();
-
-				if (tileEntity instanceof TilePurifier)
-				{
-					if (this.getDirection(world, checkPos.intX(), checkPos.intY(), checkPos.intZ()) == facing)
-					{
-						this.dropBlockAsItem(world, x, y, z, 0, 0);
-						world.setBlockToAir(x, y, z);
-					}
-				}
-			}
-		}
-	}
-
 	@Override
 	public boolean isOpaqueCube()
 	{
@@ -75,6 +37,6 @@ public class BlockMixer extends BlockRIRotatable implements ITileEntityProvider
 	@Override
 	public TileEntity createNewTileEntity(World world)
 	{
-		return new TilePurifier();
+		return new TileMixer();
 	}
 }

src/main/java/resonantinduction/mechanical/Mechanical.java

@@ -29,7 +29,7 @@ import resonantinduction.mechanical.network.IMechanical;
 import resonantinduction.mechanical.network.PacketNetwork;
 import resonantinduction.mechanical.process.BlockGrinderWheel;
 import resonantinduction.mechanical.process.TileGrinderWheel;
-import resonantinduction.mechanical.process.TilePurifier;
+import resonantinduction.mechanical.process.TileMixer;
 import calclavia.lib.content.ContentRegistry;
 import calclavia.lib.network.PacketHandler;
 import cpw.mods.fml.common.Mod;
@@ -112,7 +112,7 @@ public class Mechanical
 
 		// Machines
 		blockGrinderWheel = contentRegistry.createTile(BlockGrinderWheel.class, TileGrinderWheel.class);
-		blockPurifier = contentRegistry.createTile(BlockMixer.class, TilePurifier.class);
+		blockPurifier = contentRegistry.createTile(BlockMixer.class, TileMixer.class);
 
 		OreDictionary.registerOre("gear", itemGear);
 

src/main/java/resonantinduction/mechanical/process/BlockGrinderWheel.java

@@ -56,9 +56,9 @@ public class BlockGrinderWheel extends BlockRIRotatable implements ITileEntityPr
 							tile.grindingItem = (EntityItem) entity;
 						}
 
-						if (!TileGrinderWheel.getTimer().containsKey(entity))
+						if (!TileGrinderWheel.timer.containsKey((EntityItem) entity))
 						{
-							TileGrinderWheel.getTimer().put((EntityItem) entity, TileGrinderWheel.DEFAULT_TIME);
+							TileGrinderWheel.timer.put((EntityItem) entity, TileGrinderWheel.DEFAULT_TIME);
 						}
 					}
 					else

src/main/java/resonantinduction/mechanical/process/TileGrinderWheel.java

@@ -28,9 +28,8 @@ public class TileGrinderWheel extends TileMechanical implements IRotatable
 	public static final long POWER = 500000;
 	public static final int DEFAULT_TIME = 20 * 20;
 	/** A map of ItemStacks and their remaining grind-time left. */
-	private static final HashMap<EntityItem, Integer> clientTimer = new HashMap<EntityItem, Integer>();
+	public static final Timer<EntityItem> timer = new Timer<EntityItem>();
-	private static final HashMap<EntityItem, Integer> serverTimer = new HashMap<EntityItem, Integer>();
+	
-
 	public EntityItem grindingItem = null;
 
 	private final long requiredTorque = 1000;
@@ -62,10 +61,9 @@ public class TileGrinderWheel extends TileMechanical implements IRotatable
 
 			if (grindingItem != null)
 			{
-				if (getTimer().containsKey(grindingItem) && !grindingItem.isDead && new Vector3(this).add(0.5).distance(grindingItem) < 1)
+				if (timer.containsKey(grindingItem) && !grindingItem.isDead && new Vector3(this).add(0.5).distance(grindingItem) < 1)
 				{
-					int timeLeft = getTimer().get(grindingItem) - 1;
+					int timeLeft = timer.decrease(grindingItem);
-					getTimer().put(grindingItem, timeLeft);
 
 					if (timeLeft <= 0)
 					{
@@ -74,14 +72,14 @@ public class TileGrinderWheel extends TileMechanical implements IRotatable
 							if (--grindingItem.getEntityItem().stackSize <= 0)
 							{
 								grindingItem.setDead();
-								getTimer().remove(grindingItem);
+								timer.remove(grindingItem);
 								grindingItem = null;
 							}
 							else
 							{
 								grindingItem.setEntityItemStack(grindingItem.getEntityItem());
 								// Reset timer
-								getTimer().put(grindingItem, DEFAULT_TIME);
+								timer.put(grindingItem, DEFAULT_TIME);
 							}
 						}
 					}
@@ -103,7 +101,7 @@ public class TileGrinderWheel extends TileMechanical implements IRotatable
 				}
 				else
 				{
-					getTimer().remove(grindingItem);
+					timer.remove(grindingItem);
 					grindingItem = null;
 				}
 			}
@@ -152,16 +150,6 @@ public class TileGrinderWheel extends TileMechanical implements IRotatable
 		return false;
 	}
 
-	public static HashMap<EntityItem, Integer> getTimer()
-	{
-		if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER)
-		{
-			return serverTimer;
-		}
-
-		return clientTimer;
-	}
-
 	@Override
 	public ForgeDirection getDirection()
 	{

src/main/java/resonantinduction/mechanical/process/TileMixer.java

@@ -1,38 +1,29 @@
 package resonantinduction.mechanical.process;
 
-import java.util.HashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Set;
 
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.item.EntityItem;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.AxisAlignedBB;
+import net.minecraftforge.common.ForgeDirection;
+import resonantinduction.api.recipe.MachineRecipes;
 import resonantinduction.core.Reference;
 import resonantinduction.core.resource.item.ItemOreResource;
-import universalelectricity.api.energy.EnergyStorageHandler;
+import resonantinduction.mechanical.network.TileMechanical;
 import universalelectricity.api.vector.Vector3;
-import calclavia.lib.prefab.tile.TileElectrical;
-import cpw.mods.fml.common.FMLCommonHandler;
-import cpw.mods.fml.relauncher.Side;
 
 /**
  * @author Calclavia
  * 
  */
-public class TilePurifier extends TileElectrical
+public class TileMixer extends TileMechanical
 {
 	public static final long POWER = 500000;
 	public static final int DEFAULT_TIME = 10 * 20;
-	/** A map of ItemStacks and their remaining grind-time left. */
+	public static final Timer<EntityItem> timer = new Timer<EntityItem>();
-	private static final HashMap<EntityItem, Integer> clientTimer = new HashMap<EntityItem, Integer>();
-	private static final HashMap<EntityItem, Integer> serverTimer = new HashMap<EntityItem, Integer>();
-
-	public EntityItem processingItem = null;
-
-	public TilePurifier()
-	{
-		this.energy = new EnergyStorageHandler(POWER * 2);
-	}
 
 	@Override
 	public void updateEntity()
@@ -52,7 +43,6 @@ public class TilePurifier extends TileElectrical
 	 */
 	public boolean canWork()
 	{
-		// TODO: Add electricity support.
 		return true;
 	}
 
@@ -61,37 +51,46 @@ public class TilePurifier extends TileElectrical
 		boolean didWork = false;
 
 		// Search for an item to "process"
-		AxisAlignedBB aabb = AxisAlignedBB.getBoundingBox(this.xCoord - 1, this.yCoord, this.zCoord - 1, this.xCoord + 1, this.yCoord, this.zCoord + 1);
+		AxisAlignedBB aabb = AxisAlignedBB.getAABBPool().getAABB(this.xCoord - 1, this.yCoord, this.zCoord - 1, this.xCoord + 2, this.yCoord + 1, this.zCoord + 2);
 		List<Entity> entities = this.worldObj.getEntitiesWithinAABB(Entity.class, aabb);
+		Set<EntityItem> processItems = new LinkedHashSet<EntityItem>();
 
 		for (Entity entity : entities)
 		{
 			/**
-			 * Rotate entities around purifier
+			 * Rotate entities around the mixer
 			 */
-			double speed = 0.1;
+			double speed = 1;
 
-			Vector3 originalPosition = new Vector3(this);
+			Vector3 originalPosition = new Vector3(entity);
-			Vector3 relativePosition = originalPosition.clone().subtract(new Vector3(this));
+			Vector3 relativePosition = originalPosition.clone().subtract(new Vector3(this).add(0.5));
 			relativePosition.rotate(speed, 0, 0);
-			Vector3 newPosition = new Vector3(this).add(relativePosition);
+			Vector3 newPosition = new Vector3(this).add(0.5).add(relativePosition);
+			Vector3 difference = newPosition.difference(originalPosition).scale(0.5);
 
-			if (this.processingItem == null && entity instanceof EntityItem)
+			entity.addVelocity(difference.x, difference.y, difference.z);
+
+			if (entity instanceof EntityItem)
 			{
+				// TODO: Use machine recipe
 				if (((EntityItem) entity).getEntityItem().getItem() instanceof ItemOreResource)
 				{
-					this.processingItem = (EntityItem) entity;
+					processItems.add((EntityItem) entity);
 				}
 			}
 		}
 
-		if (processingItem != null)
+		for (EntityItem processingItem : processItems)
 		{
-			if (getTimer().containsKey(processingItem) && !processingItem.isDead && new Vector3(this).add(0.5).distance(processingItem) < 1)
+			if (!timer.containsKey(processingItem))
 			{
-				int timeLeft = getTimer().get(processingItem) - 1;
+				timer.put(processingItem, DEFAULT_TIME);
-				getTimer().put(processingItem, timeLeft);
+			}
-
+			
+			if (!processingItem.isDead && new Vector3(this).add(0.5).distance(processingItem) < 2)
+			{
+				int timeLeft = timer.decrease(processingItem);
+				
 				if (timeLeft <= 0)
 				{
 					if (this.doneWork(processingItem))
@@ -99,14 +98,14 @@ public class TilePurifier extends TileElectrical
 						if (--processingItem.getEntityItem().stackSize <= 0)
 						{
 							processingItem.setDead();
-							getTimer().remove(processingItem);
+							timer.remove(processingItem);
 							processingItem = null;
 						}
 						else
 						{
 							processingItem.setEntityItemStack(processingItem.getEntityItem());
 							// Reset timer
-							getTimer().put(processingItem, DEFAULT_TIME);
+							timer.put(processingItem, DEFAULT_TIME);
 						}
 					}
 				}
@@ -120,7 +119,7 @@ public class TilePurifier extends TileElectrical
 			}
 			else
 			{
-				getTimer().remove(processingItem);
+				timer.remove(processingItem);
 				processingItem = null;
 			}
 		}
@@ -129,10 +128,8 @@ public class TilePurifier extends TileElectrical
 		{
 			if (this.ticks % 20 == 0)
 			{
-				this.worldObj.playSoundEffect(this.xCoord + 0.5, this.yCoord + 0.5, this.zCoord + 0.5, Reference.PREFIX + "grinder", 0.5f, 1);
+				this.worldObj.playSoundEffect(this.xCoord + 0.5, this.yCoord + 0.5, this.zCoord + 0.5, Reference.PREFIX + "mixer", 0.5f, 1);
 			}
-
-			this.energy.extractEnergy(POWER / 20, true);
 		}
 	}
 
@@ -143,13 +140,9 @@ public class TilePurifier extends TileElectrical
 		return false;
 	}
 
-	public static HashMap<EntityItem, Integer> getTimer()
+	@Override
+	public boolean canConnect(ForgeDirection direction)
 	{
-		if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER)
+		return direction == ForgeDirection.UP || direction == ForgeDirection.DOWN;
-		{
-			return serverTimer;
-		}
-
-		return clientTimer;
 	}
 }

src/main/java/resonantinduction/mechanical/process/Timer.java

@@ -0,0 +1,51 @@
+package resonantinduction.mechanical.process;
+
+import java.util.HashMap;
+
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.relauncher.Side;
+import net.minecraft.entity.item.EntityItem;
+
+public class Timer<K>
+{
+	private final HashMap<K, Integer> clientTimer = new HashMap<K, Integer>();
+	private final HashMap<K, Integer> serverTimer = new HashMap<K, Integer>();
+
+	public void put(K key, int defaultTime)
+	{
+		getTimeMap().put(key, defaultTime);
+	}
+
+	public boolean containsKey(K key)
+	{
+		return getTimeMap().containsKey(key);
+	}
+
+	public void remove(K key)
+	{
+		getTimeMap().remove(key);
+	}
+
+	public int decrease(K key)
+	{
+		return decrease(key, 1);
+	}
+
+	public int decrease(K key, int amount)
+	{
+		int timeLeft = getTimeMap().get(key) - amount;
+		getTimeMap().put(key, timeLeft);
+		return timeLeft;
+	}
+
+	public HashMap<K, Integer> getTimeMap()
+	{
+		if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER)
+		{
+			return serverTimer;
+		}
+
+		return clientTimer;
+	}
+
+}