Err too much.

tile/grindstone/TileGrinder.java

@@ -105,7 +105,7 @@ public class TileGrinder extends AEBaseInvTile implements ICrankable
 					{
 						i = i.copy();
 						i.setStackSize( r.getInput().stackSize );
-						IAEItemStack ais = input.extractItems( (IAEItemStack) i, Actionable.MODULATE );
+						IAEItemStack ais = input.extractItems( (IAEItemStack) i, Actionable.MODULATE, null );
 						if ( ais != null )
 							this.setInventorySlotContents( 6, ais.getItemStack() );
 						return true;

tile/inventory/AppEngInternalInventory.java

@@ -18,6 +18,7 @@ public class AppEngInternalInventory implements IInventory, Iterable<ItemStack>
 	protected int size;
 	protected int maxStack;
 
+	public boolean enableClientEvents = false;
 	protected ItemStack inv[];
 
 	public IMEInventory getIMEI()
@@ -42,7 +43,7 @@ public class AppEngInternalInventory implements IInventory, Iterable<ItemStack>
 
 	protected boolean eventsEnabled()
 	{
-		return Platform.isServer();
+		return Platform.isServer() || enableClientEvents;
 	}
 
 	public void setMaxStackSize(int s)

tile/inventory/AppEngNullInventory.java

@@ -0,0 +1,94 @@
+package appeng.tile.inventory;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+
+public class AppEngNullInventory implements IInventory
+{
+
+	public AppEngNullInventory() {
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int var1)
+	{
+		return null;
+	}
+
+	@Override
+	public ItemStack decrStackSize(int slot, int qty)
+	{
+		return null;
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(int var1)
+	{
+		return null;
+	}
+
+	@Override
+	public void setInventorySlotContents(int slot, ItemStack newItemStack)
+	{
+
+	}
+
+	@Override
+	public void onInventoryChanged()
+	{
+
+	}
+
+	@Override
+	public int getInventoryStackLimit()
+	{
+		return 0;
+	}
+
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer var1)
+	{
+		return false;
+	}
+
+	@Override
+	public void openChest()
+	{
+	}
+
+	@Override
+	public void closeChest()
+	{
+	}
+
+	public void writeToNBT(NBTTagCompound target)
+	{
+	}
+
+	@Override
+	public int getSizeInventory()
+	{
+		return 0;
+	}
+
+	@Override
+	public String getInvName()
+	{
+		return "appeng-internal";
+	}
+
+	@Override
+	public boolean isInvNameLocalized()
+	{
+		return false;
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int i, ItemStack itemstack)
+	{
+		return false;
+	}
+
+}

tile/misc/TileCellWorkbench.java

@@ -0,0 +1,187 @@
+package appeng.tile.misc;
+
+import java.util.EnumSet;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import appeng.api.config.Upgrades;
+import appeng.api.implementations.IBusCommon;
+import appeng.api.storage.ICellWorkbenchItem;
+import appeng.api.util.IConfigManager;
+import appeng.tile.AEBaseTile;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import appeng.tile.inventory.AppEngInternalAEInventory;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.IAEAppEngInventory;
+import appeng.tile.inventory.InvOperation;
+
+public class TileCellWorkbench extends AEBaseTile implements IBusCommon, IAEAppEngInventory
+{
+
+	AppEngInternalInventory cell = new AppEngInternalInventory( this, 1 );
+	AppEngInternalAEInventory config = new AppEngInternalAEInventory( this, 63 );
+
+	IInventory cacheUpgrades = null;
+	IInventory cacheConfig = null;
+
+	public IInventory getCellUpgradeInventory()
+	{
+		if ( cacheUpgrades == null )
+		{
+			ICellWorkbenchItem cwbi = getCell();
+			if ( cwbi == null )
+				return null;
+
+			ItemStack is = cell.getStackInSlot( 0 );
+			if ( is == null )
+				return null;
+
+			IInventory inv = cwbi.getUpgradesInventory( is );
+			if ( inv == null )
+				return null;
+
+			return cacheUpgrades = inv;
+		}
+		return cacheUpgrades;
+	}
+
+	public IInventory getCellConfigInventory()
+	{
+		if ( cacheConfig == null )
+		{
+			ICellWorkbenchItem cwbi = getCell();
+			if ( cwbi == null )
+				return null;
+
+			ItemStack is = cell.getStackInSlot( 0 );
+			if ( is == null )
+				return null;
+
+			IInventory inv = cwbi.getConfigInventory( is );
+			if ( inv == null )
+				return null;
+
+			return cacheConfig = inv;
+		}
+		return cacheConfig;
+	}
+
+	class TileCellWorkbenchHandler extends AETileEventHandler
+	{
+
+		public TileCellWorkbenchHandler() {
+			super( EnumSet.of( TileEventType.WORLD_NBT ) );
+		}
+
+		@Override
+		public void writeToNBT(NBTTagCompound data)
+		{
+			cell.writeToNBT( data, "cell" );
+			config.writeToNBT( data, "config" );
+		}
+
+		@Override
+		public void readFromNBT(NBTTagCompound data)
+		{
+			cell.readFromNBT( data, "cell" );
+			config.readFromNBT( data, "config" );
+		}
+
+	}
+
+	public TileCellWorkbench() {
+		addNewHandler( new TileCellWorkbenchHandler() );
+		cell.enableClientEvents = true;
+	}
+
+	@Override
+	public IInventory getInventoryByName(String name)
+	{
+		if ( name.equals( "config" ) )
+			return config;
+
+		if ( name.equals( "cell" ) )
+			return cell;
+
+		return null;
+	}
+
+	@Override
+	public int getInstalledUpgrades(Upgrades u)
+	{
+		return 0;
+	}
+
+	private boolean locked = false;
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removedStack, ItemStack newStack)
+	{
+		if ( inv == cell && locked == false )
+		{
+			locked = true;
+
+			cacheUpgrades = null;
+			cacheConfig = null;
+
+			IInventory c = getCellConfigInventory();
+			if ( c != null )
+			{
+				boolean cellHasConfig = false;
+				for (int x = 0; x < c.getSizeInventory(); x++)
+				{
+					if ( c.getStackInSlot( x ) != null )
+					{
+						cellHasConfig = true;
+						break;
+					}
+				}
+
+				if ( cellHasConfig )
+				{
+					for (int x = 0; x < config.getSizeInventory(); x++)
+						config.setInventorySlotContents( x, c.getStackInSlot( x ) );
+				}
+				else
+				{
+					for (int x = 0; x < config.getSizeInventory(); x++)
+						c.setInventorySlotContents( x, config.getStackInSlot( x ) );
+					c.onInventoryChanged();
+				}
+
+			}
+
+			locked = false;
+		}
+		else if ( inv == config && locked == false )
+		{
+			IInventory c = getCellConfigInventory();
+			if ( c != null )
+			{
+				for (int x = 0; x < config.getSizeInventory(); x++)
+					c.setInventorySlotContents( x, config.getStackInSlot( x ) );
+				c.onInventoryChanged();
+			}
+		}
+	}
+
+	public ICellWorkbenchItem getCell()
+	{
+		if ( cell.getStackInSlot( 0 ) == null )
+			return null;
+
+		if ( cell.getStackInSlot( 0 ).getItem() instanceof ICellWorkbenchItem )
+			return ((ICellWorkbenchItem) cell.getStackInSlot( 0 ).getItem());
+
+		return null;
+	}
+
+	@Override
+	public IConfigManager getConfigManager()
+	{
+		return null;
+	}
+
+}

tile/misc/TileCondenser.java

@@ -46,12 +46,14 @@ public class TileCondenser extends AEBaseInvTile implements IAEAppEngInventory,
 		@Override
 		public void writeToNBT(NBTTagCompound data)
 		{
+			cm.writeToNBT( data );
 			data.setDouble( "storedPower", storedPower );
 		}
 
 		@Override
 		public void readFromNBT(NBTTagCompound data)
 		{
+			cm.readFromNBT( data );
 			storedPower = data.getDouble( "storedPower" );
 		}
 

tile/networking/TileCableBus.java

@@ -15,6 +15,7 @@ import net.minecraft.util.AxisAlignedBB;
 import net.minecraft.util.Vec3;
 import net.minecraft.world.World;
 import net.minecraftforge.common.ForgeDirection;
+import powercrystals.minefactoryreloaded.api.rednet.RedNetConnectionType;
 import appeng.api.networking.IGridNode;
 import appeng.api.parts.IFacadeContainer;
 import appeng.api.parts.IPart;
@@ -29,6 +30,7 @@ import appeng.parts.CableBusContainer;
 import appeng.tile.AEBaseTile;
 import appeng.tile.events.AETileEventHandler;
 import appeng.tile.events.TileEventType;
+import cpw.mods.fml.common.Optional.Method;
 
 public class TileCableBus extends AEBaseTile implements AEMultiTile, ICustomCollision
 {
@@ -252,4 +254,41 @@ public class TileCableBus extends AEBaseTile implements AEMultiTile, ICustomColl
 	{
 		return cb.hasRedstone( side );
 	}
+
+	@Override
+	@Method(modid = "MineFactoryReloaded")
+	public RedNetConnectionType getConnectionType(World world, int x, int y, int z, ForgeDirection side)
+	{
+		return cb.canConnectRedstone( EnumSet.of( side ) ) ? RedNetConnectionType.CableSingle : RedNetConnectionType.None;
+	}
+
+	@Override
+	@Method(modid = "MineFactoryReloaded")
+	public int[] getOutputValues(World world, int x, int y, int z, ForgeDirection side)
+	{
+		// never called!
+		return null;
+	}
+
+	@Override
+	@Method(modid = "MineFactoryReloaded")
+	public int getOutputValue(World world, int x, int y, int z, ForgeDirection side, int subnet)
+	{
+		// never called!
+		return 0;
+	}
+
+	@Override
+	@Method(modid = "MineFactoryReloaded")
+	public void onInputsChanged(World world, int x, int y, int z, ForgeDirection side, int[] inputValues)
+	{
+		// never called!
+	}
+
+	@Override
+	@Method(modid = "MineFactoryReloaded")
+	public void onInputChanged(World world, int x, int y, int z, ForgeDirection side, int inputValue)
+	{
+		// never called!
+	}
 }

tile/networking/TileController.java

@@ -14,6 +14,7 @@ import appeng.api.networking.events.MENetworkPowerStatusChange;
 import appeng.api.networking.events.MENetworkPowerStorage;
 import appeng.api.networking.events.MENetworkPowerStorage.PowerEventType;
 import appeng.api.networking.pathing.ControllerState;
+import appeng.api.util.AECableType;
 import appeng.me.GridAccessException;
 import appeng.tile.grid.AENetworkPowerTile;
 import appeng.tile.inventory.AppEngInternalInventory;
@@ -31,6 +32,12 @@ public class TileController extends AENetworkPowerTile implements IAEPowerStorag
 		gridProxy.setFlags( GridFlags.CANNOT_CARRY );
 	}
 
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.DENSE;
+	}
+
 	@Override
 	protected double getFunnelPowerDemand()
 	{

tile/qnb/TileQuantumBridge.java

@@ -1,17 +1,34 @@
 package appeng.tile.qnb;
 
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.EnumSet;
+
 import net.minecraft.inventory.IInventory;
 import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.ForgeDirection;
 import appeng.api.AEApi;
+import appeng.api.networking.GridFlags;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPowerStatusChange;
+import appeng.api.util.AECableType;
+import appeng.api.util.DimensionalCoord;
+import appeng.me.GridAccessException;
 import appeng.me.cluster.IAECluster;
 import appeng.me.cluster.IAEMultiBlock;
+import appeng.me.cluster.implementations.QuantumCalculator;
 import appeng.me.cluster.implementations.QuantumCluster;
-import appeng.tile.grid.AENetworkPowerTile;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import appeng.tile.grid.AENetworkInvTile;
 import appeng.tile.inventory.AppEngInternalInventory;
 import appeng.tile.inventory.InvOperation;
 import appeng.util.Platform;
 
-public class TileQuantumBridge extends AENetworkPowerTile implements IAEMultiBlock
+public class TileQuantumBridge extends AENetworkInvTile implements IAEMultiBlock
 {
 
 	final int sidesRing[] = new int[] {};
@@ -19,28 +36,87 @@ public class TileQuantumBridge extends AENetworkPowerTile implements IAEMultiBlo
 
 	AppEngInternalInventory inv = new AppEngInternalInventory( this, 1 );
 
-	final byte start = 8 + 7;
 	public final byte corner = 16;
 	final byte hasSingularity = 32;
 	final byte powered = 64;
 
-	// private QuantumCalculator calc = new QuantumCalculator( this );
-	int oldxdex = -1;
+	private QuantumCalculator calc = new QuantumCalculator( this );
 	byte xdex = -1;
 
 	QuantumCluster clust;
 	public boolean bridgePowered;
 
-	@Override
+	private boolean updateStatus = false;
+
+	class QBridgeHandler extends AETileEventHandler
+	{
+
+		public QBridgeHandler() {
+			super( EnumSet.of( TileEventType.NETWORK, TileEventType.TICK ) );
+			gridProxy.setValidSides( EnumSet.noneOf( ForgeDirection.class ) );
+			gridProxy.setFlags( GridFlags.TIER_2_CAPACITY );
+			gridProxy.setIdlePowerUsage( 22 );
+			inv.setMaxStackSize( 1 );
+		}
+
+		@Override
+		public void Tick()
+		{
+			if ( updateStatus )
+			{
+				updateStatus = false;
+				if ( clust != null )
+					clust.updateStatus( true );
+				markForUpdate();
+			}
+		}
+
+		@Override
+		public void writeToStream(DataOutputStream data) throws IOException
+		{
+			int out = xdex;
+
+			if ( getStackInSlot( 0 ) != null && xdex != -1 )
+				out = out | hasSingularity;
+
+			if ( gridProxy.isActive() && xdex != -1 )
+				out = out | powered;
+
+			data.writeByte( (byte) out );
+		}
+
+		@Override
+		public boolean readFromStream(DataInputStream data) throws IOException
+		{
+			int oldValue = xdex;
+			xdex = data.readByte();
+			bridgePowered = (xdex | powered) == powered;
+			return xdex != oldValue;
+		}
+
+	};
+
+	public TileQuantumBridge() {
+		addNewHandler( new QBridgeHandler() );
+		gridProxy.setFlags( GridFlags.TIER_2_CAPACITY );
+	}
+
 	public IInventory getInternalInventory()
 	{
 		return inv;
 	}
 
+	@MENetworkEventSubscribe
+	public void PowerSwitch(MENetworkPowerStatusChange c)
+	{
+		updateStatus = true;
+	}
+
 	@Override
 	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
 	{
-
+		if ( clust != null )
+			clust.updateStatus( true );
 	}
 
 	@Override
@@ -54,33 +130,51 @@ public class TileQuantumBridge extends AENetworkPowerTile implements IAEMultiBlo
 	@Override
 	public void disconnect()
 	{
-		// TODO Auto-generated method stub
-
+		if ( clust != null )
+			clust.destroy();
+		clust = null;
+		gridProxy.setValidSides( EnumSet.noneOf( ForgeDirection.class ) );
 	}
 
 	@Override
 	public IAECluster getCluster()
 	{
-		// TODO Auto-generated method stub
-		return null;
+		return clust;
 	}
 
 	@Override
 	public boolean isValid()
 	{
-		// TODO Auto-generated method stub
-		return false;
+		return !isInvalid();
 	}
 
-	public void updateStatus(QuantumCluster c, byte fish)
+	public void updateStatus(QuantumCluster c, byte flags)
 	{
-		// TODO Auto-generated method stub
+		clust = c;
 
+		if ( xdex != flags )
+		{
+			xdex = flags;
+			markForUpdate();
+		}
+
+		if ( isCorner() || isCenter() )
+		{
+			gridProxy.setValidSides( getConnections() );
+		}
+		else
+			gridProxy.setValidSides( EnumSet.allOf( ForgeDirection.class ) );
 	}
 
 	public long getQEDest()
 	{
-		// TODO Auto-generated method stub
+		ItemStack is = inv.getStackInSlot( 0 );
+		if ( is != null )
+		{
+			NBTTagCompound c = is.getTagCompound();
+			if ( c != null )
+				return c.getLong( "freq" );
+		}
 		return 0;
 	}
 
@@ -91,14 +185,22 @@ public class TileQuantumBridge extends AENetworkPowerTile implements IAEMultiBlo
 
 	public boolean isCorner()
 	{
-		// TODO Auto-generated method stub
-		return false;
+		return (xdex & corner) == corner && xdex != -1;
 	}
 
 	public boolean isPowered()
 	{
 		if ( Platform.isClient() )
-			return (xdex & powered) == powered;
+			return (xdex & powered) == powered && xdex != -1;
+
+		try
+		{
+			return gridProxy.getEnergy().isNetworkPowered();
+		}
+		catch (GridAccessException e)
+		{
+			// :P
+		}
 
 		return false;
 	}
@@ -108,4 +210,42 @@ public class TileQuantumBridge extends AENetworkPowerTile implements IAEMultiBlo
 		return xdex != -1;
 	}
 
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.DENSE;
+	}
+
+	@Override
+	public DimensionalCoord getLocation()
+	{
+		return new DimensionalCoord( this );
+	}
+
+	public void neighborUpdate()
+	{
+		calc.calculateMultiblock( worldObj, getLocation() );
+	}
+
+	public EnumSet<ForgeDirection> getConnections()
+	{
+		EnumSet<ForgeDirection> set = EnumSet.noneOf( ForgeDirection.class );
+
+		for (ForgeDirection d : ForgeDirection.VALID_DIRECTIONS)
+		{
+			TileEntity te = worldObj.getBlockTileEntity( xCoord + d.offsetX, yCoord + d.offsetY, zCoord + d.offsetZ );
+			if ( te instanceof TileQuantumBridge )
+				set.add( d );
+		}
+
+		return set;
+	}
+
+	public boolean hasQES()
+	{
+		if ( xdex == -1 )
+			return false;
+		return (xdex & hasSingularity) == hasSingularity;
+	}
+
 }

tile/storage/TileChest.java

@@ -31,6 +31,7 @@ import appeng.api.networking.events.MENetworkPowerStorage;
 import appeng.api.networking.events.MENetworkPowerStorage.PowerEventType;
 import appeng.api.networking.security.BaseActionSource;
 import appeng.api.networking.security.MachineSource;
+import appeng.api.networking.security.PlayerSource;
 import appeng.api.networking.storage.IStorageGrid;
 import appeng.api.storage.ICellHandler;
 import appeng.api.storage.IMEInventory;
@@ -253,14 +254,19 @@ public class TileChest extends AENetworkPowerTile implements IMEChest, IFluidHan
 		@Override
 		public void postChange(IMEMonitor<T> monitor, T change, BaseActionSource source)
 		{
-			try
+			if ( source == mySrc || (source instanceof PlayerSource && ((PlayerSource) source).via == TileChest.this) )
 			{
-				gridProxy.getStorage().postAlterationOfStoredItems( chan, change, mySrc );
-			}
-			catch (GridAccessException e)
-			{
-				// :(
+				try
+				{
+					gridProxy.getStorage().postAlterationOfStoredItems( chan, change, mySrc );
+				}
+				catch (GridAccessException e)
+				{
+					// :(
+				}
 			}
+
+			blinkCell( 0 );
 		}
 
 		@Override
@@ -275,6 +281,23 @@ public class TileChest extends AENetworkPowerTile implements IMEChest, IFluidHan
 
 	};
 
+	class ChestMonitorHandler<T extends IAEStack> extends MEMonitorHandler<T>
+	{
+
+		public ChestMonitorHandler(IMEInventoryHandler<T> t) {
+			super( t );
+		}
+
+		public IMEInventoryHandler<T> getInternalHandler()
+		{
+			IMEInventoryHandler<T> h = getHandler();
+			if ( h instanceof MEInventoryHandler )
+				return (IMEInventoryHandler<T>) ((MEInventoryHandler) h).getInternal();
+			return this.getHandler();
+		}
+
+	};
+
 	private <StackType extends IAEStack> MEMonitorHandler<StackType> wrap(IMEInventoryHandler h)
 	{
 		if ( h == null )
@@ -283,7 +306,7 @@ public class TileChest extends AENetworkPowerTile implements IMEChest, IFluidHan
 		MEInventoryHandler ih = new MEInventoryHandler( h );
 		ih.myPriority = priority;
 
-		MEMonitorHandler<StackType> g = new MEMonitorHandler<StackType>( ih );
+		MEMonitorHandler<StackType> g = new ChestMonitorHandler<StackType>( ih );
 		g.addListener( new ChestNetNotifier( h.getChannel() ), g );
 
 		return g;
@@ -395,7 +418,7 @@ public class TileChest extends AENetworkPowerTile implements IMEChest, IFluidHan
 		try
 		{
 			IMEInventory<IAEItemStack> cell = getHandler( StorageChannel.ITEMS );
-			IAEItemStack returns = cell.injectItems( AEApi.instance().storage().createItemStack( inv.getStackInSlot( 0 ) ), Actionable.SIMULATE );
+			IAEItemStack returns = cell.injectItems( AEApi.instance().storage().createItemStack( inv.getStackInSlot( 0 ) ), Actionable.SIMULATE, mySrc );
 			return returns == null || returns.getStackSize() != itemstack.stackSize;
 		}
 		catch (AENoHandler t)
@@ -447,6 +470,8 @@ public class TileChest extends AENetworkPowerTile implements IMEChest, IFluidHan
 		lastStateChange = now;
 
 		state |= 1 << (slot * 3 + 2);
+
+		recalculateDisplay();
 	}
 
 	@Override
@@ -473,8 +498,8 @@ public class TileChest extends AENetworkPowerTile implements IMEChest, IFluidHan
 			try
 			{
 				IMEInventoryHandler handler = getHandler( StorageChannel.ITEMS );
-				if ( ch != null )
-					return ch.getStatusForCell( cell, handler );
+				if ( ch != null && handler instanceof ChestMonitorHandler )
+					return ch.getStatusForCell( cell, ((ChestMonitorHandler) handler).getInternalHandler() );
 			}
 			catch (AENoHandler e)
 			{
@@ -483,8 +508,8 @@ public class TileChest extends AENetworkPowerTile implements IMEChest, IFluidHan
 			try
 			{
 				IMEInventoryHandler handler = getHandler( StorageChannel.FLUIDS );
-				if ( ch != null )
-					return ch.getStatusForCell( cell, handler );
+				if ( ch != null && handler instanceof ChestMonitorHandler )
+					return ch.getStatusForCell( cell, ((ChestMonitorHandler) handler).getInternalHandler() );
 			}
 			catch (AENoHandler e)
 			{
@@ -506,7 +531,7 @@ public class TileChest extends AENetworkPowerTile implements IMEChest, IFluidHan
 				IMEInventoryHandler h = getHandler( StorageChannel.FLUIDS );
 
 				extractAEPower( req, Actionable.MODULATE, PowerMultiplier.CONFIG );
-				IAEStack results = h.injectItems( AEFluidStack.create( resource ), doFill ? Actionable.MODULATE : Actionable.SIMULATE );
+				IAEStack results = h.injectItems( AEFluidStack.create( resource ), doFill ? Actionable.MODULATE : Actionable.SIMULATE, mySrc );
 
 				if ( results == null )
 					return resource.amount;

tile/storage/TileDrive.java

@@ -24,9 +24,11 @@ import appeng.api.networking.storage.IStorageGrid;
 import appeng.api.storage.ICellHandler;
 import appeng.api.storage.IMEInventoryHandler;
 import appeng.api.storage.StorageChannel;
+import appeng.api.storage.data.IAEItemStack;
 import appeng.api.util.AECableType;
 import appeng.api.util.DimensionalCoord;
 import appeng.me.GridAccessException;
+import appeng.me.storage.DriveWatcher;
 import appeng.me.storage.MEInventoryHandler;
 import appeng.tile.events.AETileEventHandler;
 import appeng.tile.events.TileEventType;
@@ -43,7 +45,7 @@ public class TileDrive extends AENetworkInvTile implements IChestOrDrive
 
 	boolean isCached = false;
 	ICellHandler handlersBySlot[] = new ICellHandler[10];
-	IMEInventoryHandler invBySlot[] = new IMEInventoryHandler[10];
+	DriveWatcher<IAEItemStack> invBySlot[] = new DriveWatcher[10];
 	List<MEInventoryHandler> items = new LinkedList();
 	List<MEInventoryHandler> fluids = new LinkedList();
 
@@ -202,7 +204,7 @@ public class TileDrive extends AENetworkInvTile implements IChestOrDrive
 
 						if ( cell != null )
 						{
-							MEInventoryHandler ih = new MEInventoryHandler( cell );
+							DriveWatcher<IAEItemStack> ih = new DriveWatcher( cell, is, handlersBySlot[x], this );
 							ih.myPriority = priority;
 							invBySlot[x] = ih;
 							items.add( ih );
@@ -213,7 +215,7 @@ public class TileDrive extends AENetworkInvTile implements IChestOrDrive
 
 							if ( cell != null )
 							{
-								MEInventoryHandler ih = new MEInventoryHandler( cell );
+								DriveWatcher<IAEItemStack> ih = new DriveWatcher( cell, is, handlersBySlot[x], this );
 								ih.myPriority = priority;
 								invBySlot[x] = ih;
 								fluids.add( ih );
@@ -255,6 +257,8 @@ public class TileDrive extends AENetworkInvTile implements IChestOrDrive
 		lastStateChange = now;
 
 		state |= 1 << (slot * 3 + 2);
+
+		recalculateDisplay();
 	}
 
 	@Override
@@ -276,20 +280,20 @@ public class TileDrive extends AENetworkInvTile implements IChestOrDrive
 		ItemStack cell = inv.getStackInSlot( 2 );
 		ICellHandler ch = handlersBySlot[slot];
 
-		IMEInventoryHandler handler = invBySlot[slot];
+		MEInventoryHandler handler = invBySlot[slot];
 		if ( handler == null )
 			return 0;
 
 		if ( handler.getChannel() == StorageChannel.ITEMS )
 		{
 			if ( ch != null )
-				return ch.getStatusForCell( cell, handler );
+				return ch.getStatusForCell( cell, handler.getInternal() );
 		}
 
 		if ( handler.getChannel() == StorageChannel.FLUIDS )
 		{
 			if ( ch != null )
-				return ch.getStatusForCell( cell, handler );
+				return ch.getStatusForCell( cell, handler.getInternal() );
 		}
 
 		return 0;

tile/storage/TileIOPort.java

@@ -1,19 +1,95 @@
 package appeng.tile.storage;
 
+import java.util.EnumSet;
+
 import net.minecraft.inventory.IInventory;
 import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
 import net.minecraftforge.common.ForgeDirection;
+import appeng.api.AEApi;
+import appeng.api.config.Actionable;
+import appeng.api.config.FullnessMode;
+import appeng.api.config.OperationMode;
+import appeng.api.config.RedstoneMode;
+import appeng.api.config.Settings;
+import appeng.api.config.Upgrades;
+import appeng.api.implementations.IBusCommon;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.energy.IEnergySource;
+import appeng.api.networking.security.BaseActionSource;
+import appeng.api.networking.security.MachineSource;
+import appeng.api.networking.ticking.IGridTickable;
+import appeng.api.networking.ticking.TickRateModulation;
+import appeng.api.networking.ticking.TickingRequest;
+import appeng.api.storage.IMEInventory;
+import appeng.api.storage.IMEMonitor;
+import appeng.api.storage.StorageChannel;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.api.storage.data.IAEStack;
+import appeng.api.storage.data.IItemList;
 import appeng.api.util.AECableType;
 import appeng.api.util.DimensionalCoord;
+import appeng.api.util.IConfigManager;
+import appeng.me.GridAccessException;
+import appeng.parts.automation.UpgradeInventory;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
 import appeng.tile.grid.AENetworkInvTile;
 import appeng.tile.inventory.AppEngInternalInventory;
 import appeng.tile.inventory.InvOperation;
+import appeng.util.ConfigManager;
+import appeng.util.IConfigManagerHost;
+import appeng.util.InventoryAdaptor;
+import appeng.util.Platform;
+import appeng.util.inv.WrapperInventoryRange;
+import appeng.util.item.ItemList;
 
-public class TileIOPort extends AENetworkInvTile
+public class TileIOPort extends AENetworkInvTile implements IBusCommon, IConfigManagerHost, IGridTickable
 {
 
+	ConfigManager cm = new ConfigManager( this );
+
 	final int sides[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
-	AppEngInternalInventory inv = new AppEngInternalInventory( this, 12 );
+	final int outputSlots[] = { 6, 7, 8, 9, 10, 11 };
+
+	AppEngInternalInventory cells = new AppEngInternalInventory( this, 12 );
+	UpgradeInventory upgrades = new UpgradeInventory( AEApi.instance().blocks().blockIOPort.block(), this, 3 );
+
+	BaseActionSource mySrc = new MachineSource( this );
+
+	boolean lastRedstoneState = false;
+
+	class TileIOPortHandler extends AETileEventHandler
+	{
+
+		public TileIOPortHandler() {
+			super( EnumSet.of( TileEventType.WORLD_NBT ) );
+		}
+
+		@Override
+		public void writeToNBT(NBTTagCompound data)
+		{
+			cm.writeToNBT( data );
+			cells.writeToNBT( data, "cells" );
+			upgrades.writeToNBT( data, "upgrades" );
+		}
+
+		@Override
+		public void readFromNBT(NBTTagCompound data)
+		{
+			cm.readFromNBT( data );
+			cells.readFromNBT( data, "cells" );
+			upgrades.readFromNBT( data, "upgrades" );
+		}
+	};
+
+	public TileIOPort() {
+		addNewHandler( new TileIOPortHandler() );
+		cm.registerSetting( Settings.REDSTONE_CONTROLLED, RedstoneMode.IGNORE );
+		cm.registerSetting( Settings.FULLNESS_MODE, FullnessMode.EMPTY );
+		cm.registerSetting( Settings.OPERATION_MODE, OperationMode.EMPTY );
+	}
 
 	@Override
 	public AECableType getCableConnectionType(ForgeDirection dir)
@@ -30,13 +106,52 @@ public class TileIOPort extends AENetworkInvTile
 	@Override
 	public IInventory getInternalInventory()
 	{
-		return inv;
+		return cells;
 	}
 
 	@Override
 	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
 	{
-		// TODO Auto-generated method stub
+		if ( cells == inv )
+		{
+			updateTask();
+		}
+	}
+
+	private void updateTask()
+	{
+		try
+		{
+			if ( hasWork() )
+				gridProxy.getTick().wakeDevice( gridProxy.getNode() );
+			else
+				gridProxy.getTick().sleepDevice( gridProxy.getNode() );
+		}
+		catch (GridAccessException e)
+		{
+			// :P
+		}
+	}
+
+	public void updateRedstoneState()
+	{
+		boolean currentState = worldObj.isBlockIndirectlyGettingPowered( xCoord, yCoord, zCoord );
+		if ( lastRedstoneState != currentState )
+		{
+			lastRedstoneState = currentState;
+			updateTask();
+		}
+	}
+
+	private boolean isEnabled()
+	{
+		if ( getInstalledUpgrades( Upgrades.REDSTONE ) == 0 )
+			return true;
+
+		RedstoneMode rs = (RedstoneMode) cm.getSetting( Settings.REDSTONE_CONTROLLED );
+		if ( rs == RedstoneMode.HIGH_SIGNAL )
+			return lastRedstoneState;
+		return !lastRedstoneState;
 	}
 
 	@Override
@@ -45,4 +160,248 @@ public class TileIOPort extends AENetworkInvTile
 		return sides;
 	}
 
+	@Override
+	public IConfigManager getConfigManager()
+	{
+		return cm;
+	}
+
+	@Override
+	public IInventory getInventoryByName(String name)
+	{
+		if ( name.equals( "upgrades" ) )
+			return upgrades;
+
+		if ( name.equals( "cells" ) )
+			return cells;
+
+		return null;
+	}
+
+	@Override
+	public int getInstalledUpgrades(Upgrades u)
+	{
+		return upgrades.getInstalledUpgrades( u );
+	}
+
+	@Override
+	public void updateSetting(Enum settingName, Enum newValue)
+	{
+		updateTask();
+	}
+
+	boolean hasWork()
+	{
+		if ( isEnabled() )
+		{
+			for (int x = 0; x < 6; x++)
+				if ( cells.getStackInSlot( x ) != null )
+					return true;
+		}
+
+		return false;
+	}
+
+	@Override
+	public TickingRequest getTickingRequest(IGridNode node)
+	{
+		return new TickingRequest( 1, 5, hasWork(), false );
+	}
+
+	@Override
+	public TickRateModulation tickingRequest(IGridNode node, int TicksSinceLastCall)
+	{
+		if ( !gridProxy.isActive() )
+			return TickRateModulation.IDLE;
+
+		long ItemsToMove = 256;
+
+		switch (getInstalledUpgrades( Upgrades.SPEED ))
+		{
+		case 1:
+			ItemsToMove *= 2;
+			break;
+		case 2:
+			ItemsToMove *= 4;
+			break;
+		case 3:
+			ItemsToMove *= 8;
+			break;
+		}
+
+		try
+		{
+			IMEInventory<IAEItemStack> itemNet = gridProxy.getStorage().getItemInventory();
+			IMEInventory<IAEFluidStack> fluidNet = gridProxy.getStorage().getFluidInventory();
+			IEnergySource energy = gridProxy.getEnergy();
+			for (int x = 0; x < 6; x++)
+			{
+				ItemStack is = cells.getStackInSlot( x );
+				if ( is != null )
+				{
+					if ( ItemsToMove > 0 )
+					{
+						IMEInventory<IAEItemStack> itemInv = getInv( is, StorageChannel.ITEMS );
+						IMEInventory<IAEFluidStack> fluidInv = getInv( is, StorageChannel.FLUIDS );
+
+						if ( cm.getSetting( Settings.OPERATION_MODE ) == OperationMode.EMPTY )
+						{
+							if ( itemInv != null )
+								ItemsToMove = transferContents( energy, itemInv, itemNet, ItemsToMove, StorageChannel.ITEMS );
+							if ( fluidInv != null )
+								ItemsToMove = transferContents( energy, fluidInv, fluidNet, ItemsToMove, StorageChannel.FLUIDS );
+						}
+						else
+						{
+							if ( itemInv != null )
+								ItemsToMove = transferContents( energy, itemNet, itemInv, ItemsToMove, StorageChannel.ITEMS );
+							if ( fluidInv != null )
+								ItemsToMove = transferContents( energy, fluidNet, fluidInv, ItemsToMove, StorageChannel.FLUIDS );
+						}
+
+						if ( ItemsToMove > 0 && shouldMove( itemInv, fluidInv ) && !moveSlot( x ) )
+							return TickRateModulation.IDLE;
+
+						return TickRateModulation.URGENT;
+					}
+					else
+						return TickRateModulation.URGENT;
+				}
+			}
+
+		}
+		catch (GridAccessException e)
+		{
+			return TickRateModulation.IDLE;
+		}
+
+		// nothing left to do...
+		return TickRateModulation.SLEEP;
+	}
+
+	private boolean shouldMove(IMEInventory<IAEItemStack> itemInv, IMEInventory<IAEFluidStack> fluidInv)
+	{
+		FullnessMode fm = (FullnessMode) cm.getSetting( Settings.FULLNESS_MODE );
+
+		if ( itemInv != null && fluidInv != null )
+			return matches( fm, itemInv ) && matches( fm, fluidInv );
+		else if ( itemInv != null )
+			return matches( fm, itemInv );
+		else if ( fluidInv != null )
+			return matches( fm, fluidInv );
+
+		return true;
+	}
+
+	private boolean matches(FullnessMode fm, IMEInventory src)
+	{
+		if ( fm == FullnessMode.HALF )
+			return true;
+
+		IItemList<? extends IAEStack> myList;
+
+		if ( src instanceof IMEMonitor )
+			myList = ((IMEMonitor) src).getStorageList();
+		else
+			myList = src.getAvailableItems( new ItemList() );
+
+		if ( fm == FullnessMode.EMPTY )
+			return myList.isEmpty();
+
+		IAEStack test = myList.getFirstItem();
+		if ( test != null )
+		{
+			test.setStackSize( 1 );
+			return src.injectItems( test, Actionable.SIMULATE, mySrc ) != null;
+		}
+		return false;
+	}
+
+	ItemStack currentCell;
+	IMEInventory<IAEFluidStack> cachedFluid;
+	IMEInventory<IAEItemStack> cachedItem;
+
+	private IMEInventory getInv(ItemStack is, StorageChannel chan)
+	{
+		if ( currentCell != is )
+		{
+			currentCell = is;
+			cachedFluid = AEApi.instance().registries().cell().getCellInventory( is, StorageChannel.FLUIDS );
+			cachedItem = AEApi.instance().registries().cell().getCellInventory( is, StorageChannel.ITEMS );
+		}
+
+		if ( StorageChannel.ITEMS == chan )
+			return cachedItem;
+
+		return cachedFluid;
+	}
+
+	private long transferContents(IEnergySource energy, IMEInventory src, IMEInventory dest, long itemsToMove, StorageChannel chan)
+	{
+		IItemList<? extends IAEStack> myList;
+		if ( src instanceof IMEMonitor )
+			myList = ((IMEMonitor) src).getStorageList();
+		else
+			myList = src.getAvailableItems( new ItemList() );
+
+		boolean didStuff;
+
+		do
+		{
+			didStuff = false;
+
+			for (IAEStack s : myList)
+			{
+				long totalStackSize = s.getStackSize();
+				if ( totalStackSize > 0 )
+				{
+					IAEStack stack = dest.injectItems( s, Actionable.SIMULATE, mySrc );
+
+					long possible = 0;
+					if ( stack == null )
+						possible = totalStackSize;
+					else
+						possible = totalStackSize - stack.getStackSize();
+
+					if ( possible > 0 )
+					{
+						possible = Math.min( possible, itemsToMove );
+						s.setStackSize( possible );
+
+						IAEStack extracted = src.extractItems( s, Actionable.MODULATE, mySrc );
+						if ( extracted != null )
+						{
+							possible = extracted.getStackSize();
+							IAEStack failed = Platform.poweredInsert( energy, dest, extracted, mySrc );
+
+							if ( failed != null )
+							{
+								possible -= failed.getStackSize();
+								src.injectItems( failed, Actionable.MODULATE, mySrc );
+							}
+
+							itemsToMove -= possible;
+						}
+					}
+				}
+			}
+		}
+		while (itemsToMove > 0 && didStuff);
+
+		return itemsToMove;
+	}
+
+	private boolean moveSlot(int x)
+	{
+		WrapperInventoryRange wir = new WrapperInventoryRange( this, outputSlots, true );
+		ItemStack result = InventoryAdaptor.getAdaptor( wir, ForgeDirection.UNKNOWN ).addItems( getStackInSlot( x ) );
+
+		if ( result == null )
+		{
+			setInventorySlotContents( x, null );
+			return true;
+		}
+
+		return false;
+	}
 }