AE2 First Commit, the dawn of 1.7 hast arrived.

util/inv/AdaptorBCPipe.java

@@ -0,0 +1,89 @@
+package appeng.util.inv;
+
+import java.util.Iterator;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.config.FuzzyMode;
+import appeng.integration.modules.BC;
+import appeng.util.InventoryAdaptor;
+import appeng.util.iterators.NullIterator;
+
+public class AdaptorBCPipe extends InventoryAdaptor
+{
+
+	private TileEntity i;
+	private ForgeDirection d;
+
+	public AdaptorBCPipe(TileEntity s, ForgeDirection dd) {
+		if ( BC.instance != null )
+		{
+			if ( BC.instance.isPipe( s, dd ) )
+			{
+				i = s;
+				d = dd;
+			}
+		}
+	}
+
+	@Override
+	public ItemStack removeSimilarItems(int amount, ItemStack filter, FuzzyMode fuzzyMode, IInventoryDestination destination)
+	{
+		return null;
+	}
+
+	@Override
+	public ItemStack simulateSimilarRemove(int how_many, ItemStack filter, FuzzyMode fuzzyMode, IInventoryDestination destination)
+	{
+		return null;
+	}
+
+	@Override
+	public ItemStack removeItems(int how_many, ItemStack filter, IInventoryDestination destination)
+	{
+		return null;
+	}
+
+	@Override
+	public ItemStack simulateRemove(int how_many, ItemStack filter, IInventoryDestination destination)
+	{
+		return null;
+	}
+
+	@Override
+	public ItemStack addItems(ItemStack A)
+	{
+		if ( i == null )
+			return A;
+		if ( A == null )
+			return null;
+		if ( A.stackSize == 0 )
+			return null;
+
+		if ( BC.instance.addItemsToPipe( i, A, d ) )
+			return null;
+		return A;
+	}
+
+	@Override
+	public ItemStack simulateAdd(ItemStack A)
+	{
+		if ( i == null )
+			return A;
+		return null;
+	}
+
+	@Override
+	public boolean containsItems()
+	{
+		return false;
+	}
+
+	@Override
+	public Iterator<ItemSlot> iterator()
+	{
+		return new NullIterator();
+	}
+
+}

util/inv/AdaptorIInventory.java

@@ -0,0 +1,353 @@
+package appeng.util.inv;
+
+import java.util.Iterator;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import appeng.api.config.FuzzyMode;
+import appeng.util.InventoryAdaptor;
+import appeng.util.Platform;
+
+public class AdaptorIInventory extends InventoryAdaptor
+{
+
+	private IInventory i;
+	private boolean wrapperEnabled;
+
+	public AdaptorIInventory(IInventory s) {
+		i = s;
+		wrapperEnabled = s instanceof IInventoryWrapper;
+	}
+
+	boolean canRemoveStackFromSlot(int x, ItemStack is)
+	{
+		if ( wrapperEnabled )
+			return ((IInventoryWrapper) i).canRemoveItemFromSlot( x, is );
+		return true;
+	}
+
+	@Override
+	public boolean containsItems()
+	{
+		int s = i.getSizeInventory();
+		for (int x = 0; x < s; x++)
+		{
+			if ( i.getStackInSlot( x ) != null )
+				return true;
+		}
+		return false;
+	}
+
+	@Override
+	public ItemStack removeSimilarItems(int how_many, ItemStack filter, FuzzyMode fuzzyMode, IInventoryDestination destination)
+	{
+		int s = i.getSizeInventory();
+		for (int x = 0; x < s; x++)
+		{
+			ItemStack is = i.getStackInSlot( x );
+			if ( is != null && canRemoveStackFromSlot( x, is ) && (filter == null || Platform.isSameItemFuzzy( is, filter, fuzzyMode )) )
+			{
+				int lhow_many = how_many;
+				if ( lhow_many > is.stackSize )
+					lhow_many = is.stackSize;
+				if ( destination != null && !destination.canInsert( is ) )
+					lhow_many = 0;
+
+				ItemStack rv = null;
+				if ( lhow_many > 0 )
+				{
+					rv = is.copy();
+					rv.stackSize = lhow_many;
+
+					if ( is.stackSize == rv.stackSize )
+						i.setInventorySlotContents( x, null );
+					else
+					{
+						ItemStack po = is.copy();
+						po.stackSize -= rv.stackSize;
+						i.setInventorySlotContents( x, po );
+					}
+				}
+
+				if ( rv != null )
+				{
+					i.onInventoryChanged();
+					return rv;
+				}
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public ItemStack simulateSimilarRemove(int how_many, ItemStack filter, FuzzyMode fuzzyMode, IInventoryDestination destination)
+	{
+		int s = i.getSizeInventory();
+		for (int x = 0; x < s; x++)
+		{
+			ItemStack is = i.getStackInSlot( x );
+
+			if ( is != null && canRemoveStackFromSlot( x, is ) && (filter == null || Platform.isSameItemFuzzy( is, filter, fuzzyMode )) )
+			{
+				int lhow_many = how_many;
+				if ( lhow_many > is.stackSize )
+					lhow_many = is.stackSize;
+				if ( destination != null && !destination.canInsert( is ) )
+					lhow_many = 0;
+
+				if ( lhow_many > 0 )
+				{
+					ItemStack rv = is.copy();
+					rv.stackSize = lhow_many;
+					return rv;
+				}
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public ItemStack removeItems(int how_many, ItemStack filter, IInventoryDestination destination)
+	{
+		int s = i.getSizeInventory();
+		ItemStack rv = null;
+
+		for (int x = 0; x < s && how_many > 0; x++)
+		{
+			ItemStack is = i.getStackInSlot( x );
+			if ( is != null && canRemoveStackFromSlot( x, is ) && (filter == null || Platform.isSameItemPrecise( is, filter )) )
+			{
+				int lhow_many = how_many;
+				if ( lhow_many > is.stackSize )
+					lhow_many = is.stackSize;
+				if ( destination != null && !destination.canInsert( is ) )
+					lhow_many = 0;
+
+				if ( lhow_many > 0 )
+				{
+					if ( rv == null )
+					{
+						rv = is.copy();
+						rv.stackSize = lhow_many;
+						how_many -= lhow_many;
+					}
+					else
+					{
+						rv.stackSize += lhow_many;
+						how_many -= lhow_many;
+					}
+
+					if ( is.stackSize == lhow_many )
+						i.setInventorySlotContents( x, null );
+					else
+					{
+						ItemStack po = is.copy();
+						po.stackSize -= lhow_many;
+						i.setInventorySlotContents( x, po );
+					}
+				}
+			}
+		}
+
+		if ( rv != null )
+			i.onInventoryChanged();
+
+		return rv;
+	}
+
+	@Override
+	public ItemStack simulateRemove(int how_many, ItemStack filter, IInventoryDestination destination)
+	{
+		int s = i.getSizeInventory();
+		ItemStack rv = null;
+
+		for (int x = 0; x < s && how_many > 0; x++)
+		{
+			ItemStack is = i.getStackInSlot( x );
+			if ( is != null && canRemoveStackFromSlot( x, is ) && (filter == null || Platform.isSameItemPrecise( is, filter )) )
+			{
+				int lhow_many = how_many;
+				if ( lhow_many > is.stackSize )
+					lhow_many = is.stackSize;
+				if ( destination != null && !destination.canInsert( is ) )
+					lhow_many = 0;
+
+				if ( lhow_many > 0 )
+				{
+					if ( rv == null )
+					{
+						rv = is.copy();
+						rv.stackSize = lhow_many;
+						how_many -= lhow_many;
+					}
+					else
+					{
+						rv.stackSize += lhow_many;
+						how_many -= lhow_many;
+					}
+				}
+			}
+		}
+
+		return rv;
+	}
+
+	@Override
+	public ItemStack addItems(ItemStack A)
+	{
+		if ( A == null )
+			return null;
+		if ( A.stackSize == 0 )
+			return null;
+
+		ItemStack left = A.copy();
+
+		int stack_limit = A.getMaxStackSize();
+		if ( stack_limit > i.getInventoryStackLimit() )
+			stack_limit = i.getInventoryStackLimit();
+
+		int s = i.getSizeInventory();
+		for (int pass = 0; pass < 2; pass++)
+		{
+			for (int x = 0; x < s; x++)
+			{
+				if ( i.isItemValidForSlot( x, A ) )
+				{
+					ItemStack is = i.getStackInSlot( x );
+					if ( is == null && pass != 0 )
+					{
+						ItemStack thisSlot = left.copy();
+						if ( thisSlot.stackSize > stack_limit )
+							thisSlot.stackSize = stack_limit;
+						left.stackSize -= thisSlot.stackSize;
+
+						i.setInventorySlotContents( x, thisSlot );
+
+						if ( left.stackSize <= 0 )
+						{
+							i.onInventoryChanged();
+							return null;
+						}
+					}
+					else if ( is != null )
+					{
+						if ( Platform.isSameItem( is, left ) )
+						{
+							if ( is.stackSize < stack_limit )
+							{
+								int room = stack_limit - is.stackSize;
+								int used = left.stackSize;
+								if ( used > room )
+									used = room;
+
+								is.stackSize += used;
+								i.setInventorySlotContents( x, is );
+
+								left.stackSize -= used;
+								if ( left.stackSize <= 0 )
+								{
+									i.onInventoryChanged();
+									return null;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+
+		if ( left.stackSize != A.stackSize )
+			i.onInventoryChanged();
+
+		return left;
+	}
+
+	@Override
+	public ItemStack simulateAdd(ItemStack A)
+	{
+		if ( A == null )
+			return A;
+		ItemStack left = A.copy();
+
+		int stack_limit = A.getMaxStackSize();
+		if ( stack_limit > i.getInventoryStackLimit() )
+			stack_limit = i.getInventoryStackLimit();
+
+		int s = i.getSizeInventory();
+		for (int x = 0; x < s; x++)
+		{
+			if ( i.isItemValidForSlot( x, A ) )
+			{
+				ItemStack is = i.getStackInSlot( x );
+				if ( is == null )
+				{
+					ItemStack thisSlot = left.copy();
+					if ( thisSlot.stackSize > stack_limit )
+						thisSlot.stackSize = stack_limit;
+					left.stackSize -= thisSlot.stackSize;
+
+					if ( left.stackSize <= 0 )
+					{
+						return null;
+					}
+				}
+				else
+				{
+					if ( Platform.isSameItem( is, left ) )
+					{
+						if ( is.stackSize < stack_limit )
+						{
+							int room = stack_limit - is.stackSize;
+							int used = left.stackSize;
+							if ( used > room )
+								used = room;
+
+							left.stackSize -= used;
+							if ( left.stackSize <= 0 )
+							{
+								return null;
+							}
+						}
+					}
+				}
+			}
+		}
+
+		return left;
+	}
+
+	class InvIterator implements Iterator<ItemSlot>
+	{
+
+		final ItemSlot is = new ItemSlot();
+		int x = 0;
+
+		@Override
+		public boolean hasNext()
+		{
+			return x < i.getSizeInventory();
+		}
+
+		@Override
+		public ItemSlot next()
+		{
+			is.slot = x;
+			is.itemStack = i.getStackInSlot( x++ );
+			return is;
+		}
+
+		@Override
+		public void remove()
+		{
+			// nothing!
+		}
+
+	};
+
+	@Override
+	public Iterator<ItemSlot> iterator()
+	{
+		return new InvIterator();
+	}
+
+}

util/inv/AdaptorISpecialInventory.java

@@ -0,0 +1,112 @@
+package appeng.util.inv;
+
+import java.util.Iterator;
+
+import net.minecraft.inventory.ISidedInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.config.FuzzyMode;
+import appeng.util.InventoryAdaptor;
+import buildcraft.api.inventory.ISpecialInventory;
+
+public class AdaptorISpecialInventory extends InventoryAdaptor
+{
+
+	private AdaptorIInventory remover;
+
+	private ISpecialInventory i;
+	private ForgeDirection d;
+
+	public AdaptorISpecialInventory(ISpecialInventory s, ForgeDirection dd) {
+		i = s;
+		d = dd;
+
+		if ( s instanceof ISidedInventory )
+			remover = new AdaptorIInventory( new WrapperMCISidedInventory( (ISidedInventory) s, d ) );
+		else
+			remover = new AdaptorIInventory( s );
+	}
+
+	@Override
+	public ItemStack removeSimilarItems(int how_many, ItemStack filter, FuzzyMode fuzzyMode, IInventoryDestination destination)
+	{
+		return remover.removeSimilarItems( how_many, filter, fuzzyMode, destination );
+	}
+
+	@Override
+	public ItemStack simulateSimilarRemove(int how_many, ItemStack filter, FuzzyMode fuzzyMode, IInventoryDestination destination)
+	{
+		return remover.simulateSimilarRemove( how_many, filter, fuzzyMode, destination );
+	}
+
+	@Override
+	public ItemStack removeItems(int how_many, ItemStack filter, IInventoryDestination destination)
+	{
+		return remover.removeItems( how_many, filter, destination );
+	}
+
+	@Override
+	public ItemStack simulateRemove(int how_many, ItemStack filter, IInventoryDestination destination)
+	{
+		return remover.simulateRemove( how_many, filter, destination );
+	}
+
+	@Override
+	public ItemStack addItems(ItemStack A)
+	{
+		if ( A == null )
+			return null;
+		if ( A.stackSize == 0 )
+			return null;
+
+		int used = i.addItem( A, true, d );
+		ItemStack out = A.copy();
+		out.stackSize -= used;
+		if ( out.stackSize > 0 )
+			return out;
+		return null;
+	}
+
+	@Override
+	public ItemStack simulateAdd(ItemStack A)
+	{
+		int used = i.addItem( A, false, d );
+		ItemStack out = A.copy();
+		out.stackSize -= used;
+		if ( out.stackSize > 0 )
+			return out;
+		return null;
+	}
+
+	@Override
+	public boolean containsItems()
+	{
+		if ( i instanceof ISidedInventory )
+		{
+			ISidedInventory sided = (ISidedInventory) i;
+			int slots[] = sided.getAccessibleSlotsFromSide( d.ordinal() );
+			if ( slots == null )
+				return false;
+
+			int s = slots.length;
+			for (int x = 0; x < s; x++)
+				if ( i.getStackInSlot( slots[x] ) != null )
+					return true;
+
+			return false;
+		}
+
+		int s = i.getSizeInventory();
+		for (int x = 0; x < s; x++)
+			if ( i.getStackInSlot( x ) != null )
+				return true;
+		return false;
+	}
+
+	@Override
+	public Iterator<ItemSlot> iterator()
+	{
+		return remover.iterator();
+	}
+
+}

util/inv/AdaptorList.java

@@ -0,0 +1,186 @@
+package appeng.util.inv;
+
+import java.util.Iterator;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+import appeng.api.config.FuzzyMode;
+import appeng.util.InventoryAdaptor;
+import appeng.util.Platform;
+import appeng.util.iterators.StackToSlotIterator;
+
+public class AdaptorList extends InventoryAdaptor
+{
+
+	private List<ItemStack> i;
+
+	public AdaptorList(List<ItemStack> s) {
+		i = s;
+	}
+
+	@Override
+	public ItemStack removeSimilarItems(int how_many, ItemStack filter, FuzzyMode fuzzyMode, IInventoryDestination dest)
+	{
+		int s = i.size();
+		for (int x = 0; x < s; x++)
+		{
+			ItemStack is = i.get( x );
+			if ( is != null && (filter == null || Platform.isSameItemFuzzy( is, filter, fuzzyMode )) )
+			{
+				if ( how_many > is.stackSize )
+					how_many = is.stackSize;
+				if ( dest != null && !dest.canInsert( is ) )
+					how_many = 0;
+
+				if ( how_many > 0 )
+				{
+					ItemStack rv = is.copy();
+					rv.stackSize = how_many;
+					is.stackSize -= how_many;
+
+					// remove it..
+					if ( is.stackSize <= 0 )
+						i.remove( x );
+
+					return rv;
+				}
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public ItemStack simulateSimilarRemove(int how_many, ItemStack filter, FuzzyMode fuzzyMode, IInventoryDestination dest)
+	{
+		int s = i.size();
+		for (int x = 0; x < s; x++)
+		{
+			ItemStack is = i.get( x );
+			if ( is != null && (filter == null || Platform.isSameItemFuzzy( is, filter, fuzzyMode )) )
+			{
+				if ( how_many > is.stackSize )
+					how_many = is.stackSize;
+				if ( dest != null && !dest.canInsert( is ) )
+					how_many = 0;
+
+				if ( how_many > 0 )
+				{
+					ItemStack rv = is.copy();
+					rv.stackSize = how_many;
+					return rv;
+				}
+			}
+		}
+		return null;
+
+	}
+
+	@Override
+	public ItemStack removeItems(int how_many, ItemStack filter, IInventoryDestination dest)
+	{
+		int s = i.size();
+		for (int x = 0; x < s; x++)
+		{
+			ItemStack is = i.get( x );
+			if ( is != null && (filter == null || Platform.isSameItemPrecise( is, filter )) )
+			{
+				if ( how_many > is.stackSize )
+					how_many = is.stackSize;
+				if ( dest != null && !dest.canInsert( is ) )
+					how_many = 0;
+
+				if ( how_many > 0 )
+				{
+					ItemStack rv = is.copy();
+					rv.stackSize = how_many;
+					is.stackSize -= how_many;
+
+					// remove it..
+					if ( is.stackSize <= 0 )
+						i.remove( x );
+
+					return rv;
+				}
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public ItemStack simulateRemove(int how_many, ItemStack filter, IInventoryDestination dest)
+	{
+		int s = i.size();
+		for (int x = 0; x < s; x++)
+		{
+			ItemStack is = i.get( x );
+			if ( is != null && (filter == null || Platform.isSameItemPrecise( is, filter )) )
+			{
+				if ( how_many > is.stackSize )
+					how_many = is.stackSize;
+				if ( dest != null && !dest.canInsert( is ) )
+					how_many = 0;
+
+				if ( how_many > 0 )
+				{
+					ItemStack rv = is.copy();
+					rv.stackSize = how_many;
+					return rv;
+				}
+			}
+		}
+		return null;
+
+	}
+
+	@Override
+	public ItemStack addItems(ItemStack A)
+	{
+		if ( A == null )
+			return null;
+		if ( A.stackSize == 0 )
+			return null;
+
+		ItemStack left = A.copy();
+
+		int s = i.size();
+		for (int x = 0; x < s; x++)
+		{
+			ItemStack is = i.get( x );
+			if ( Platform.isSameItem( is, left ) )
+			{
+				is.stackSize += left.stackSize;
+				return null;
+			}
+		}
+
+		i.add( left );
+		return null;
+	}
+
+	@Override
+	public ItemStack simulateAdd(ItemStack A)
+	{
+		return null;
+	}
+
+	@Override
+	public boolean containsItems()
+	{
+
+		int s = i.size();
+		for (int x = 0; x < s; x++)
+		{
+			ItemStack is = i.get( x );
+			if ( is != null )
+				return true;
+		}
+		return false;
+	}
+
+	@Override
+	public Iterator<ItemSlot> iterator()
+	{
+		return new StackToSlotIterator( i.iterator() );
+	}
+
+}

util/inv/AdaptorPlayerHand.java

@@ -0,0 +1,185 @@
+package appeng.util.inv;
+
+import java.util.Iterator;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import appeng.api.config.FuzzyMode;
+import appeng.util.InventoryAdaptor;
+import appeng.util.Platform;
+import appeng.util.iterators.NullIterator;
+
+/*
+ * Lets you do simply tests with the players cursor, without messing with the specifics.
+ */
+public class AdaptorPlayerHand extends InventoryAdaptor
+{
+
+	private EntityPlayer p;
+
+	public AdaptorPlayerHand(EntityPlayer _p) {
+		p = _p;
+	}
+
+	@Override
+	public ItemStack removeSimilarItems(int how_many, ItemStack Filter, FuzzyMode fuzzyMode, IInventoryDestination dest)
+	{
+		ItemStack hand = p.inventory.getItemStack();
+		if ( hand == null )
+			return null;
+
+		if ( Filter == null || Platform.isSameItemFuzzy( Filter, hand, fuzzyMode ) )
+		{
+			ItemStack result = hand.copy();
+			result.stackSize = hand.stackSize > how_many ? how_many : hand.stackSize;
+			hand.stackSize -= how_many;
+			if ( hand.stackSize <= 0 )
+				p.inventory.setItemStack( null );
+			return result;
+		}
+
+		return null;
+	}
+
+	@Override
+	public ItemStack simulateSimilarRemove(int how_many, ItemStack Filter, FuzzyMode fuzzyMode, IInventoryDestination dest)
+	{
+
+		ItemStack hand = p.inventory.getItemStack();
+		if ( hand == null )
+			return null;
+
+		if ( Filter == null || Platform.isSameItemFuzzy( Filter, hand, fuzzyMode ) )
+		{
+			ItemStack result = hand.copy();
+			result.stackSize = hand.stackSize > how_many ? how_many : hand.stackSize;
+			return result;
+		}
+
+		return null;
+	}
+
+	@Override
+	public ItemStack removeItems(int how_many, ItemStack Filter, IInventoryDestination dest)
+	{
+		ItemStack hand = p.inventory.getItemStack();
+		if ( hand == null )
+			return null;
+
+		if ( Filter == null || Platform.isSameItemPrecise( Filter, hand ) )
+		{
+			ItemStack result = hand.copy();
+			result.stackSize = hand.stackSize > how_many ? how_many : hand.stackSize;
+			hand.stackSize -= how_many;
+			if ( hand.stackSize <= 0 )
+				p.inventory.setItemStack( null );
+			return result;
+		}
+
+		return null;
+	}
+
+	@Override
+	public ItemStack simulateRemove(int how_many, ItemStack Filter, IInventoryDestination dest)
+	{
+
+		ItemStack hand = p.inventory.getItemStack();
+		if ( hand == null )
+			return null;
+
+		if ( Filter == null || Platform.isSameItemPrecise( Filter, hand ) )
+		{
+			ItemStack result = hand.copy();
+			result.stackSize = hand.stackSize > how_many ? how_many : hand.stackSize;
+			return result;
+		}
+
+		return null;
+	}
+
+	@Override
+	public ItemStack addItems(ItemStack A)
+	{
+
+		if ( A == null )
+			return null;
+		if ( A.stackSize == 0 )
+			return null;
+		if ( p == null )
+			return A;
+		if ( p.inventory == null )
+			return A;
+
+		ItemStack hand = p.inventory.getItemStack();
+
+		if ( hand != null && !Platform.isSameItem( A, hand ) )
+			return A;
+
+		int original = 0;
+		ItemStack newHand = null;
+		if ( hand == null )
+			newHand = A.copy();
+		else
+		{
+			newHand = hand;
+			original = hand.stackSize;
+			newHand.stackSize += A.stackSize;
+		}
+
+		if ( newHand.stackSize > newHand.getMaxStackSize() )
+		{
+			newHand.stackSize = newHand.getMaxStackSize();
+			ItemStack B = A.copy();
+			B.stackSize -= newHand.stackSize - original;
+			p.inventory.setItemStack( newHand );
+			return B;
+		}
+
+		p.inventory.setItemStack( newHand );
+		return null;
+	}
+
+	@Override
+	public ItemStack simulateAdd(ItemStack A)
+	{
+		ItemStack hand = p.inventory.getItemStack();
+		if ( A == null )
+			return null;
+
+		if ( hand != null && !Platform.isSameItem( A, hand ) )
+			return A;
+
+		int original = 0;
+		ItemStack newHand = null;
+		if ( hand == null )
+			newHand = A.copy();
+		else
+		{
+			newHand = hand.copy();
+			original = hand.stackSize;
+			newHand.stackSize += A.stackSize;
+		}
+
+		if ( newHand.stackSize > newHand.getMaxStackSize() )
+		{
+			newHand.stackSize = newHand.getMaxStackSize();
+			ItemStack B = A.copy();
+			B.stackSize -= newHand.stackSize - original;
+			return B;
+		}
+
+		return null;
+	}
+
+	@Override
+	public boolean containsItems()
+	{
+		return p.inventory.getItemStack() != null;
+	}
+
+	@Override
+	public Iterator<ItemSlot> iterator()
+	{
+		return new NullIterator();
+	}
+}

util/inv/AdaptorPlayerInventory.java

@@ -0,0 +1,99 @@
+package appeng.util.inv;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+
+public class AdaptorPlayerInventory implements IInventory
+{
+
+	private InventoryPlayer src;
+	private int min;
+	private int size;
+
+	public AdaptorPlayerInventory(InventoryPlayer a) {
+		src = a;
+		min = 0; // a.getStartInventorySide( d );
+		size = 36; // a.getSizeInventorySide( d );
+	}
+
+	@Override
+	public int getSizeInventory()
+	{
+		return size;
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int var1)
+	{
+		return src.getStackInSlot( var1 + min );
+	}
+
+	@Override
+	public ItemStack decrStackSize(int var1, int var2)
+	{
+		return src.decrStackSize( min + var1, var2 );
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(int var1)
+	{
+		return src.getStackInSlotOnClosing( min + var1 );
+	}
+
+	@Override
+	public void setInventorySlotContents(int var1, ItemStack var2)
+	{
+		src.setInventorySlotContents( var1 + min, var2 );
+	}
+
+	@Override
+	public String getInvName()
+	{
+		return src.getInvName();
+	}
+
+	@Override
+	public int getInventoryStackLimit()
+	{
+		return src.getInventoryStackLimit();
+	}
+
+	@Override
+	public void onInventoryChanged()
+	{
+		src.onInventoryChanged();
+	}
+
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer var1)
+	{
+		return src.isUseableByPlayer( var1 );
+	}
+
+	@Override
+	public void openChest()
+	{
+		src.openChest();
+	}
+
+	@Override
+	public void closeChest()
+	{
+		src.closeChest();
+	}
+
+	@Override
+	public boolean isInvNameLocalized()
+	{
+		return false;
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int i, ItemStack itemstack)
+	{
+		return true;
+	}
+
+}

util/inv/IInventoryDestination.java

@@ -0,0 +1,10 @@
+package appeng.util.inv;
+
+import net.minecraft.item.ItemStack;
+
+public interface IInventoryDestination
+{
+
+	public boolean canInsert(ItemStack stack);
+
+}

util/inv/IInventoryWrapper.java

@@ -0,0 +1,10 @@
+package appeng.util.inv;
+
+import net.minecraft.item.ItemStack;
+
+public interface IInventoryWrapper
+{
+
+	boolean canRemoveItemFromSlot(int x, ItemStack is);
+
+}

util/inv/IMEInventoryDestination.java

@@ -0,0 +1,32 @@
+package appeng.util.inv;
+
+import net.minecraft.item.ItemStack;
+import appeng.api.config.Actionable;
+import appeng.api.storage.IMEInventory;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.util.item.AEItemStack;
+
+public class IMEInventoryDestination implements IInventoryDestination
+{
+
+	IMEInventory<IAEItemStack> me;
+
+	public IMEInventoryDestination(IMEInventory<IAEItemStack> o) {
+		me = o;
+	}
+
+	@Override
+	public boolean canInsert(ItemStack stack)
+	{
+
+		if ( stack == null )
+			return false;
+
+		IAEItemStack failed = me.injectItems( AEItemStack.create( stack ), Actionable.SIMULATE );
+
+		if ( failed == null )
+			return true;
+		return failed.getStackSize() != stack.stackSize;
+	}
+
+}

util/inv/ItemSlot.java

@@ -0,0 +1,11 @@
+package appeng.util.inv;
+
+import net.minecraft.item.ItemStack;
+
+public class ItemSlot
+{
+
+	public int slot;
+	public ItemStack itemStack;
+
+}

util/inv/WrapperChainedInventory.java

@@ -0,0 +1,198 @@
+package appeng.util.inv;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+
+public class WrapperChainedInventory implements IInventory
+{
+
+	class InvOffset
+	{
+
+		int offset;
+		int size;
+		IInventory i;
+	};
+
+	int fullSize = 0;
+
+	private List<IInventory> l;
+	private HashMap<Integer, InvOffset> offsets;
+
+	public WrapperChainedInventory(IInventory ilist) {
+		setInventory( ilist );
+	}
+
+	public WrapperChainedInventory(List<IInventory> ilist) {
+		setInventory( ilist );
+	}
+
+	public void calculateSizes()
+	{
+		offsets = new HashMap<Integer, WrapperChainedInventory.InvOffset>();
+
+		int offset = 0;
+		for (IInventory in : l)
+		{
+			InvOffset io = new InvOffset();
+			io.offset = offset;
+			io.size = in.getSizeInventory();
+			io.i = in;
+
+			for (int y = 0; y < io.size; y++)
+			{
+				offsets.put( y + io.offset, io );
+			}
+
+			offset += io.size;
+		}
+
+		fullSize = offset;
+	}
+
+	public void setInventory(IInventory a)
+	{
+		l = new ArrayList();
+		l.add( a );
+		calculateSizes();
+	}
+
+	public void setInventory(List<IInventory> a)
+	{
+		l = a;
+		calculateSizes();
+	}
+
+	public IInventory getInv(int idx)
+	{
+		InvOffset io = offsets.get( idx );
+		if ( io != null )
+		{
+			return io.i;
+		}
+		return null;
+	}
+
+	public int getInvSlot(int idx)
+	{
+		InvOffset io = offsets.get( idx );
+		if ( io != null )
+		{
+			return idx - io.offset;
+		}
+		return 0;
+	}
+
+	@Override
+	public int getSizeInventory()
+	{
+		return fullSize;
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int idx)
+	{
+		InvOffset io = offsets.get( idx );
+		if ( io != null )
+		{
+			return io.i.getStackInSlot( idx - io.offset );
+		}
+		return null;
+	}
+
+	@Override
+	public ItemStack decrStackSize(int idx, int var2)
+	{
+		InvOffset io = offsets.get( idx );
+		if ( io != null )
+		{
+			return io.i.decrStackSize( idx - io.offset, var2 );
+		}
+		return null;
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(int idx)
+	{
+		InvOffset io = offsets.get( idx );
+		if ( io != null )
+		{
+			return io.i.getStackInSlotOnClosing( idx - io.offset );
+		}
+		return null;
+	}
+
+	@Override
+	public void setInventorySlotContents(int idx, ItemStack var2)
+	{
+		InvOffset io = offsets.get( idx );
+		if ( io != null )
+		{
+			io.i.setInventorySlotContents( idx - io.offset, var2 );
+		}
+	}
+
+	@Override
+	public String getInvName()
+	{
+		return "ChainedInv";
+	}
+
+	@Override
+	public int getInventoryStackLimit()
+	{
+		int smallest = 64;
+
+		for (IInventory i : l)
+			smallest = Math.min( smallest, i.getInventoryStackLimit() );
+
+		return smallest;
+	}
+
+	@Override
+	public void onInventoryChanged()
+	{
+		for (IInventory i : l)
+		{
+			i.onInventoryChanged();
+		}
+	}
+
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer var1)
+	{
+		return false;
+	}
+
+	@Override
+	public void openChest()
+	{
+	}
+
+	@Override
+	public void closeChest()
+	{
+	}
+
+	@Override
+	public boolean isInvNameLocalized()
+	{
+		return false;
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int idx, ItemStack itemstack)
+	{
+		InvOffset io = offsets.get( idx );
+		if ( io != null )
+		{
+			return io.i.isItemValidForSlot( idx - io.offset, itemstack );
+		}
+		return false;
+	}
+}

util/inv/WrapperInventoryRange.java

@@ -0,0 +1,128 @@
+package appeng.util.inv;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+
+public class WrapperInventoryRange implements IInventory
+{
+
+	private IInventory src;
+	int[] slots;
+	protected boolean ignoreValidItems = false;
+
+	public static String concateLines(int[] s, String separator)
+	{
+		if ( s.length > 0 )
+		{
+			StringBuilder sb = new StringBuilder();
+			for (int i = 0; i < s.length; i++)
+			{
+				if ( sb.length() > 0 )
+					sb.append( separator );
+				sb.append( s[i] );
+			}
+			return sb.toString();
+		}
+		return "";
+	}
+
+	public WrapperInventoryRange(IInventory a, int[] s, boolean ignoreValid) {
+		src = a;
+		slots = s;
+		if ( slots == null )
+			slots = new int[0];
+
+		ignoreValidItems = ignoreValid;
+	}
+
+	public WrapperInventoryRange(IInventory a, int _min, int _size, boolean ignoreValid) {
+		src = a;
+		slots = new int[_size];
+		for (int x = 0; x < _size; x++)
+			slots[x] = _min + x;
+		ignoreValidItems = ignoreValid;
+	}
+
+	@Override
+	public int getSizeInventory()
+	{
+		return slots.length;
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int var1)
+	{
+		return src.getStackInSlot( slots[var1] );
+	}
+
+	@Override
+	public ItemStack decrStackSize(int var1, int var2)
+	{
+		return src.decrStackSize( slots[var1], var2 );
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(int var1)
+	{
+		return src.getStackInSlotOnClosing( slots[var1] );
+	}
+
+	@Override
+	public void setInventorySlotContents(int var1, ItemStack var2)
+	{
+		src.setInventorySlotContents( slots[var1], var2 );
+	}
+
+	@Override
+	public String getInvName()
+	{
+		return src.getInvName();
+	}
+
+	@Override
+	public int getInventoryStackLimit()
+	{
+		return src.getInventoryStackLimit();
+	}
+
+	@Override
+	public void onInventoryChanged()
+	{
+		src.onInventoryChanged();
+	}
+
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer var1)
+	{
+		return src.isUseableByPlayer( var1 );
+	}
+
+	@Override
+	public void openChest()
+	{
+		src.openChest();
+	}
+
+	@Override
+	public void closeChest()
+	{
+		src.closeChest();
+	}
+
+	@Override
+	public boolean isInvNameLocalized()
+	{
+		return false;
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int i, ItemStack itemstack)
+	{
+		if ( ignoreValidItems )
+			return true;
+
+		return src.isItemValidForSlot( slots[i], itemstack );
+	}
+
+}

util/inv/WrapperMCISidedInventory.java

@@ -0,0 +1,50 @@
+package appeng.util.inv;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.ISidedInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.ForgeDirection;
+
+public class WrapperMCISidedInventory extends WrapperInventoryRange implements IInventory, IInventoryWrapper
+{
+
+	private ForgeDirection dir;
+	ISidedInventory side;
+
+	public WrapperMCISidedInventory(ISidedInventory a, ForgeDirection d) {
+		super( a, a.getAccessibleSlotsFromSide( d.ordinal() ), false );
+		side = a;
+		dir = d;
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int i, ItemStack itemstack)
+	{
+
+		if ( ignoreValidItems )
+			return true;
+
+		if ( side.isItemValidForSlot( slots[i], itemstack ) )
+			return side.canInsertItem( slots[i], itemstack, dir.ordinal() );
+
+		return false;
+	}
+
+	@Override
+	public boolean canRemoveItemFromSlot(int i, ItemStack is)
+	{
+		if ( is == null )
+			return false;
+
+		return side.canExtractItem( slots[i], is, dir.ordinal() );
+	}
+
+	@Override
+	public ItemStack decrStackSize(int var1, int var2)
+	{
+		if ( canRemoveItemFromSlot( var1, getStackInSlot( var1 ) ) )
+			return super.decrStackSize( var1, var2 );
+		return null;
+	}
+
+}

util/inv/WrapperPipe.java

@@ -0,0 +1,99 @@
+package appeng.util.inv;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.integration.modules.BC;
+
+public class WrapperPipe implements IInventory
+{
+
+	TileEntity ad;
+	ForgeDirection dir;
+
+	public WrapperPipe(TileEntity te, ForgeDirection d) {
+		ad = te;
+		dir = d;
+	}
+
+	@Override
+	public int getSizeInventory()
+	{
+		return 1;
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int i)
+	{
+		return null;
+	}
+
+	@Override
+	public ItemStack decrStackSize(int i, int j)
+	{
+		return null;
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(int i)
+	{
+		return null;
+	}
+
+	@Override
+	public void setInventorySlotContents(int i, ItemStack itemstack)
+	{
+		BC.instance.addItemsToPipe( ad, itemstack, dir );
+	}
+
+	@Override
+	public String getInvName()
+	{
+		return null;
+	}
+
+	@Override
+	public boolean isInvNameLocalized()
+	{
+		return false;
+	}
+
+	@Override
+	public int getInventoryStackLimit()
+	{
+		return 64;
+	}
+
+	@Override
+	public void onInventoryChanged()
+	{
+
+	}
+
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer entityplayer)
+	{
+		return false;
+	}
+
+	@Override
+	public void openChest()
+	{
+
+	}
+
+	@Override
+	public void closeChest()
+	{
+
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int i, ItemStack itemstack)
+	{
+		return BC.instance.canAddItemsToPipe( ad, itemstack, dir );
+	}
+
+}