Added APIs to repo

you win @Calclavia

src/minecraft/buildcraft/api/blueprints/BlockSignature.java

@@ -0,0 +1,77 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.blueprints;
+
+public class BlockSignature {
+
+	public String blockClassName;
+	public String tileClassName;
+	public String blockName;
+	public String mod;
+	public String modVersion;
+	public String customField;
+
+	public BlockSignature(String str) {
+		String[] values = str.split("/");
+
+		int i = 0;
+
+		if (values[0].equals("#B")) {
+			i++;
+		}
+
+		blockClassName = values[i];
+		tileClassName = values[i + 1];
+		blockName = values[i + 2];
+		mod = values[i + 3];
+		modVersion = values[i + 4];
+		customField = values[i + 5];
+
+		replaceNullWithStar();
+
+	}
+
+	public BlockSignature() {
+		replaceNullWithStar();
+	}
+
+	@Override
+	public String toString() {
+		replaceNullWithStar();
+
+		return "#B/" + blockClassName + "/" + tileClassName + "/" + blockName + "/" + mod + "/" + modVersion + "/" + customField;
+	}
+
+	public void replaceNullWithStar() {
+		if (blockClassName == null) {
+			blockClassName = "*";
+		}
+
+		if (tileClassName == null) {
+			tileClassName = "*";
+		}
+
+		if (blockName == null) {
+			blockName = "*";
+		}
+
+		if (mod == null) {
+			mod = "*";
+		}
+
+		if (modVersion == null) {
+			modVersion = "*";
+		}
+
+		if (customField == null) {
+			customField = "*";
+		}
+	}
+}

src/minecraft/buildcraft/api/blueprints/BlueprintManager.java

@@ -0,0 +1,35 @@
+package buildcraft.api.blueprints;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import buildcraft.api.core.BuildCraftAPI;
+
+@Deprecated
+public class BlueprintManager {
+
+	public static BptBlock[] blockBptProps = new BptBlock[Block.blocksList.length];
+
+	public static ItemSignature getItemSignature(Item item) {
+		ItemSignature sig = new ItemSignature();
+
+		if (item.itemID >= Block.blocksList.length + BuildCraftAPI.LAST_ORIGINAL_ITEM) {
+			sig.itemClassName = item.getClass().getSimpleName();
+		}
+
+		sig.itemName = item.getUnlocalizedName(new ItemStack(item));
+
+		return sig;
+	}
+
+	public static BlockSignature getBlockSignature(Block block) {
+		return BlueprintManager.blockBptProps[0].getSignature(block);
+	}
+
+	static {
+		// Initialize defaults for block properties.
+		for (int i = 0; i < BlueprintManager.blockBptProps.length; ++i) {
+			new BptBlock(i);
+		}
+	}
+}

src/minecraft/buildcraft/api/blueprints/BptBlock.java

@@ -0,0 +1,235 @@
+/**
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ *
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.blueprints;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import buildcraft.api.core.BuildCraftAPI;
+
+/**
+ * This class allow to specify specific behavior for blocks stored in blueprints:
+ *
+ * - what items needs to be used to create that block - how the block has to be built on the world - how to rotate the block - what extra data to store / load
+ * in the blueprint
+ *
+ * Default implementations of this can be seen in the package buildcraft.api.bptblocks. The class BptBlockUtils provide some additional utilities.
+ *
+ * Blueprints perform "id translation" in case the block ids between a blueprint and the world installation are different. In order to translate block ids,
+ * blocks needs to be uniquely identified. By default, this identification is done by:
+ *
+ * - the block simple class name - the tile simple class name (if any) - the block name
+ *
+ * In certain circumstances, the above is not enough (e.g. if several blocks share the same class and the same name, with no tile). In this case, additional
+ * data may be provided by children of this class:
+ *
+ * - mod name - custom signature
+ *
+ * At blueprint load time, BuildCraft will check that each block id of the blueprint corresponds to the block id in the installation. If not, it will perform a
+ * search through the block list, and upon matching signature, it will translate all blocks ids of the blueprint to the installation ones. If no such block id
+ * is found, BuildCraft will assume that the block is not installed and will not load the blueprint.
+ */
+
+@Deprecated
+public class BptBlock {
+
+	public final int blockId;
+
+	public BptBlock(int blockId) {
+		this.blockId = blockId;
+
+		BlueprintManager.blockBptProps[blockId] = this;
+	}
+
+	/**
+	 * Returns the requirements needed to build this block. When the requirements are met, they will be removed all at once from the builder, before calling
+	 * buildBlock.
+	 */
+	public void addRequirements(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		if (slot.blockId != 0) {
+			if (slot.storedRequirements.size() != 0) {
+				requirements.addAll(slot.storedRequirements);
+			} else {
+				requirements.add(new ItemStack(slot.blockId, 1, slot.meta));
+			}
+		}
+	}
+
+	/**
+	 * This is called each time an item matches a reqquirement, that is: (req id == stack id) for damageable items (req id == stack id && req dmg == stack dmg)
+	 * for other items by default, it will increase damage of damageable items by the amount of damage of the requirement, and remove the intended amount of non
+	 * damageable item.
+	 *
+	 * Client may override this behavior for default items. Note that this subprogram may be called twice with the same parameters, once with a copy of
+	 * requirements and stack to check if the entire requirements can be fullfilled, and once with the real inventory. Implementer is responsible for updating
+	 * req (with the remaining requirements if any) and stack (after usage)
+	 *
+	 * returns: what was used (similer to req, but created from stack, so that any NBT based differences are drawn from the correct source)
+	 */
+	public ItemStack useItem(BptSlotInfo slot, IBptContext context, ItemStack req, ItemStack stack) {
+		ItemStack result = stack.copy();
+		if (stack.isItemStackDamageable()) {
+			if (req.getItemDamage() + stack.getItemDamage() <= stack.getMaxDamage()) {
+				stack.setItemDamage(req.getItemDamage() + stack.getItemDamage());
+				result.setItemDamage(req.getItemDamage());
+				req.stackSize = 0;
+			}
+
+			if (stack.getItemDamage() >= stack.getMaxDamage()) {
+				stack.stackSize = 0;
+			}
+		} else {
+			if (stack.stackSize >= req.stackSize) {
+				result.stackSize = req.stackSize;
+				stack.stackSize -= req.stackSize;
+				req.stackSize = 0;
+			} else {
+				req.stackSize -= stack.stackSize;
+				stack.stackSize = 0;
+			}
+		}
+
+		if (stack.stackSize == 0 && stack.getItem().getContainerItem() != null) {
+			Item container = stack.getItem().getContainerItem();
+
+			stack.itemID = container.itemID;
+			stack.stackSize = 1;
+			stack.setItemDamage(0);
+		}
+		return result;
+	}
+
+	/**
+	 * Return true if the block on the world correspond to the block stored in the blueprint at the location given by the slot. By default, this subprogram is
+	 * permissive and doesn't take into account metadata.
+	 *
+	 * Added metadata sensitivity //Krapht
+	 */
+	public boolean isValid(BptSlotInfo slot, IBptContext context) {
+		return slot.blockId == context.world().getBlockId(slot.x, slot.y, slot.z) && slot.meta == context.world().getBlockMetadata(slot.x, slot.y, slot.z);
+	}
+
+	/**
+	 * Perform a 90 degree rotation to the slot.
+	 */
+	public void rotateLeft(BptSlotInfo slot, IBptContext context) {
+
+	}
+
+	/**
+	 * Places the block in the world, at the location specified in the slot.
+	 */
+	public void buildBlock(BptSlotInfo slot, IBptContext context) {
+		// Meta needs to be specified twice, depending on the block behavior
+		context.world().setBlock(slot.x, slot.y, slot.z, slot.blockId, slot.meta,3);
+		context.world().setBlockMetadataWithNotify(slot.x, slot.y, slot.z, slot.meta,3);
+
+		if (Block.blocksList[slot.blockId] instanceof BlockContainer) {
+			TileEntity tile = context.world().getBlockTileEntity(slot.x, slot.y, slot.z);
+
+			slot.cpt.setInteger("x", slot.x);
+			slot.cpt.setInteger("y", slot.y);
+			slot.cpt.setInteger("z", slot.z);
+
+			if (tile != null) {
+				tile.readFromNBT(slot.cpt);
+			}
+		}
+	}
+
+	/**
+	 * Return true if the block should not be placed to the world. Requirements will not be asked on such a block, and building will not be called.
+	 */
+	public boolean ignoreBuilding(BptSlotInfo slot) {
+		return false;
+	}
+
+	/**
+	 * Initializes a slot from the blueprint according to an objet placed on {x, y, z} on the world. This typically means adding entries in slot.cpt. Note that
+	 * "id" and "meta" will be set automatically, corresponding to the block id and meta.
+	 *
+	 * By default, if the block is a BlockContainer, tile information will be to save / load the block.
+	 */
+	public void initializeFromWorld(BptSlotInfo slot, IBptContext context, int x, int y, int z) {
+		if (Block.blocksList[slot.blockId] instanceof BlockContainer) {
+			TileEntity tile = context.world().getBlockTileEntity(x, y, z);
+
+			if (tile != null) {
+				tile.writeToNBT(slot.cpt);
+			}
+		}
+
+		if (Block.blocksList[slot.blockId] != null) {
+			ArrayList<ItemStack> req = Block.blocksList[slot.blockId].getBlockDropped(context.world(), x, y, z, context.world().getBlockMetadata(x, y, z), 0);
+
+			if (req != null) {
+				slot.storedRequirements.addAll(req);
+			}
+		}
+	}
+
+	/**
+	 * Called on a block when the blueprint has finished to place all the blocks. This may be useful to adjust variable depending on surrounding blocks that may
+	 * not be there already at initial building.
+	 */
+	public void postProcessing(BptSlotInfo slot, IBptContext context) {
+
+	}
+
+	/**
+	 * By default, block class name, block tile name and block name are used to define block signature. Overriding this subprogram may allow to replace some of
+	 * these with stars, specify the mod that this block kind is coming from or add custom data to the signature.
+	 */
+	public BlockSignature getSignature(Block block) {
+		BlockSignature sig = new BlockSignature();
+
+		if (block.blockID > BuildCraftAPI.LAST_ORIGINAL_BLOCK) {
+			sig.blockClassName = block.getClass().getSimpleName();
+
+			if (block instanceof BlockContainer) {
+				// TODO: Try to see if we can get a world instance to call with instead of null
+				TileEntity tile = ((BlockContainer) block).createNewTileEntity(null);
+
+				if (tile != null) {
+					sig.tileClassName = tile.getClass().getSimpleName();
+				}
+			}
+		}
+
+		sig.blockName = block.getUnlocalizedName();
+		sig.replaceNullWithStar();
+
+		return sig;
+	}
+
+	/**
+	 * By default, block name, block and tile classes, mod name and custom signature are matched to verify if a blueprint block corresponds to the installation
+	 * block - except for the default blocks which don't check for classes. For any value, * means match with anything. For compatibilty and evolution reasons,
+	 * mods may want to write a different policy, allowing to migrate one format to the other.
+	 */
+	public boolean match(Block block, BlockSignature sig) {
+		if (block == null)
+			return false;
+
+		BlockSignature inst = BlueprintManager.getBlockSignature(block);
+
+		return starMatch(sig.blockName, inst.blockName) && starMatch(sig.blockClassName, inst.blockClassName)
+				&& starMatch(sig.tileClassName, inst.tileClassName) && starMatch(sig.customField, inst.customField) && starMatch(sig.mod, inst.mod);
+	}
+
+	private boolean starMatch(String s1, String s2) {
+		return s1.equals("*") || s2.equals("*") || s1.equals(s2);
+	}
+}

src/minecraft/buildcraft/api/blueprints/BptBlockUtils.java

@@ -0,0 +1,86 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.blueprints;
+
+import java.util.LinkedList;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+
+@Deprecated
+public class BptBlockUtils {
+
+	public static void requestInventoryContents(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		ItemStack[] stacks = getItemStacks(slot, context);
+
+		for (ItemStack stack : stacks) {
+			if (stack != null) {
+				requirements.add(stack);
+			}
+		}
+	}
+
+	public static void initializeInventoryContents(BptSlotInfo slot, IBptContext context, IInventory inventory) {
+		ItemStack[] stacks = new ItemStack[inventory.getSizeInventory()];
+
+		for (int i = 0; i < inventory.getSizeInventory(); ++i) {
+			stacks[i] = inventory.getStackInSlot(i);
+		}
+
+		setItemStacks(slot, context, stacks);
+	}
+
+	public static void buildInventoryContents(BptSlotInfo slot, IBptContext context, IInventory inventory) {
+		ItemStack[] stacks = getItemStacks(slot, context);
+
+		for (int i = 0; i < stacks.length; ++i) {
+			inventory.setInventorySlotContents(i, stacks[i]);
+		}
+	}
+
+	public static ItemStack[] getItemStacks(BptSlotInfo slot, IBptContext context) {
+		NBTTagList list = (NBTTagList) slot.cpt.getTag("inv");
+
+		if (list == null)
+			return new ItemStack[0];
+
+		ItemStack stacks[] = new ItemStack[list.tagCount()];
+
+		for (int i = 0; i < list.tagCount(); ++i) {
+			ItemStack stack = ItemStack.loadItemStackFromNBT((NBTTagCompound) list.tagAt(i));
+
+			if (stack != null && stack.itemID != 0 && stack.stackSize > 0) {
+				stacks[i] = context.mapItemStack(stack);
+			}
+		}
+
+		return stacks;
+	}
+
+	public static void setItemStacks(BptSlotInfo slot, IBptContext context, ItemStack[] stacks) {
+		NBTTagList nbttaglist = new NBTTagList();
+
+		for (int i = 0; i < stacks.length; ++i) {
+			NBTTagCompound cpt = new NBTTagCompound();
+			nbttaglist.appendTag(cpt);
+			ItemStack stack = stacks[i];
+
+			if (stack != null && stack.stackSize != 0) {
+				stack.writeToNBT(cpt);
+				context.storeId(stack.itemID);
+			}
+		}
+
+		slot.cpt.setTag("inv", nbttaglist);
+	}
+
+}

src/minecraft/buildcraft/api/blueprints/BptSlotInfo.java

@@ -0,0 +1,55 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.blueprints;
+
+import java.util.LinkedList;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+
+/**
+ * This class records a slot, either from a blueprint or from a block placed in the world.
+ */
+
+@Deprecated
+public class BptSlotInfo {
+
+	public int blockId = 0;
+	public int meta = 0;
+	public int x;
+	public int y;
+	public int z;
+
+	/**
+	 * This field contains requirements for a given block when stored in the blueprint. Modders can either rely on this list or compute their own int BptBlock.
+	 */
+	public LinkedList<ItemStack> storedRequirements = new LinkedList<ItemStack>();
+
+	/**
+	 * This tree contains additional data to be stored in the blueprint. By default, it will be initialized from BptBlock.initializeFromWorld with the standard
+	 * readNBT function of the corresponding tile (if any) and will be loaded from BptBlock.buildBlock using the standard writeNBT function.
+	 */
+	public NBTTagCompound cpt = new NBTTagCompound();
+
+	@Override
+	public BptSlotInfo clone() {
+		BptSlotInfo obj = new BptSlotInfo();
+
+		obj.x = x;
+		obj.y = y;
+		obj.z = z;
+		obj.blockId = blockId;
+		obj.meta = meta;
+		obj.cpt = (NBTTagCompound) cpt.copy();
+
+		return obj;
+	}
+
+}

src/minecraft/buildcraft/api/blueprints/IBptContext.java

@@ -0,0 +1,48 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.blueprints;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import buildcraft.api.core.IBox;
+import buildcraft.api.core.Position;
+
+/**
+ * This interface provide contextual information when building or initializing blueprint slots.
+ */
+
+@Deprecated
+public interface IBptContext {
+
+	/**
+	 * If bptItemStack is an ItemStack extracted from the blueprint containing this mapping, this will return an item stack with the id of the current world
+	 */
+	public ItemStack mapItemStack(ItemStack bptItemStack);
+
+	/**
+	 * Blueprints may be created in a world with a given id setting, and then ported to a world with different ids. Heuristics are used to retreive these new
+	 * ids automatically. This interface provide services to map ids from a blueprints to current ids in the world, and should be used whenever storing block
+	 * numbers or item stacks in blueprints..
+	 */
+	public int mapWorldId(int bptWorldId);
+
+	/**
+	 * This asks the id mapping to store a mapping from this Id, which may be either an itemId or a blockId. In effect, the blueprint will record it and make it
+	 * available upon blueprint load. Note that block present in the blueprint are automatically stored upon blueprint save, so this is really only needed when
+	 * writing ids that are e.g. in inventory stacks.
+	 */
+	public void storeId(int worldId);
+
+	public Position rotatePositionLeft(Position pos);
+
+	public IBox surroundingBox();
+
+	public World world();
+}

src/minecraft/buildcraft/api/blueprints/ItemSignature.java

@@ -0,0 +1,48 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.blueprints;
+
+@Deprecated
+public class ItemSignature {
+
+	public String itemClassName;
+	public String itemName;
+
+	public ItemSignature(String str) {
+		String[] values = str.split("/");
+
+		itemClassName = values[1];
+		itemName = values[2];
+
+		replaceNullWithStar();
+
+	}
+
+	public ItemSignature() {
+		replaceNullWithStar();
+	}
+
+	@Override
+	public String toString() {
+		replaceNullWithStar();
+
+		return "#I/" + itemClassName + "/" + itemName;
+	}
+
+	public void replaceNullWithStar() {
+		if (itemClassName == null) {
+			itemClassName = "*";
+		}
+
+		if (itemName == null) {
+			itemName = "*";
+		}
+	}
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockBed.java

@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ *
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.bptblocks;
+
+import java.util.LinkedList;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import buildcraft.api.blueprints.BptBlock;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockBed extends BptBlock {
+
+	public BptBlockBed(int blockId) {
+		super(blockId);
+	}
+
+	@Override
+	public void addRequirements(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		if ((slot.meta & 8) == 0) {
+			requirements.add(new ItemStack(Item.bed));
+		}
+	}
+
+	@Override
+	public void rotateLeft(BptSlotInfo slot, IBptContext context) {
+		int orientation = (slot.meta & 7);
+		int others = slot.meta - orientation;
+
+		switch (orientation) {
+		case 0:
+			slot.meta = 1 + others;
+			break;
+		case 1:
+			slot.meta = 2 + others;
+			break;
+		case 2:
+			slot.meta = 3 + others;
+			break;
+		case 3:
+			slot.meta = 0 + others;
+			break;
+		}
+	}
+
+	@Override
+	public void buildBlock(BptSlotInfo slot, IBptContext context) {
+		if ((slot.meta & 8) != 0)
+			return;
+
+		context.world().setBlock(slot.x, slot.y, slot.z, slot.blockId, slot.meta,1);
+
+		int x2 = slot.x;
+		int z2 = slot.z;
+
+		switch (slot.meta) {
+		case 0:
+			z2++;
+			break;
+		case 1:
+			x2--;
+			break;
+		case 2:
+			z2--;
+			break;
+		case 3:
+			x2++;
+			break;
+		}
+
+		context.world().setBlock(x2, slot.y, z2, slot.blockId, slot.meta + 8,1);
+	}
+
+	@Override
+	public boolean ignoreBuilding(BptSlotInfo slot) {
+		return (slot.meta & 8) != 0;
+	}
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockCustomStack.java

@@ -0,0 +1,35 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.bptblocks;
+
+import java.util.LinkedList;
+
+import net.minecraft.item.ItemStack;
+import buildcraft.api.blueprints.BptBlock;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockCustomStack extends BptBlock {
+
+	final ItemStack customStack;
+
+	public BptBlockCustomStack(int blockId, ItemStack customStack) {
+		super(blockId);
+
+		this.customStack = customStack;
+	}
+
+	@Override
+	public void addRequirements(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		requirements.add(customStack.copy());
+	}
+
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockDelegate.java

@@ -0,0 +1,66 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.bptblocks;
+
+import java.util.LinkedList;
+
+import net.minecraft.item.ItemStack;
+import buildcraft.api.blueprints.BlueprintManager;
+import buildcraft.api.blueprints.BptBlock;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockDelegate extends BptBlock {
+
+	final int delegateTo;
+
+	public BptBlockDelegate(int blockId, int delegateTo) {
+		super(blockId);
+
+		this.delegateTo = delegateTo;
+	}
+
+	@Override
+	public void addRequirements(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		BptSlotInfo newSlot = slot.clone();
+		slot.blockId = delegateTo;
+
+		if (BlueprintManager.blockBptProps[delegateTo] != null) {
+			BlueprintManager.blockBptProps[delegateTo].addRequirements(newSlot, context, requirements);
+		} else {
+			super.addRequirements(newSlot, context, requirements);
+		}
+	}
+
+	@Override
+	public boolean isValid(BptSlotInfo slot, IBptContext context) {
+		BptSlotInfo newSlot = slot.clone();
+		slot.blockId = delegateTo;
+
+		if (BlueprintManager.blockBptProps[delegateTo] != null)
+			return BlueprintManager.blockBptProps[delegateTo].isValid(newSlot, context);
+		else
+			return super.isValid(newSlot, context);
+	}
+
+	@Override
+	public void rotateLeft(BptSlotInfo slot, IBptContext context) {
+		BptSlotInfo newSlot = slot.clone();
+		slot.blockId = delegateTo;
+
+		if (BlueprintManager.blockBptProps[delegateTo] != null) {
+			BlueprintManager.blockBptProps[delegateTo].rotateLeft(newSlot, context);
+		} else {
+			super.rotateLeft(newSlot, context);
+		}
+	}
+
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockDirt.java

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ *
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.bptblocks;
+
+import java.util.LinkedList;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import buildcraft.api.blueprints.BptBlock;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockDirt extends BptBlock {
+
+	public BptBlockDirt(int blockId) {
+		super(blockId);
+	}
+
+	@Override
+	public void addRequirements(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		requirements.add(new ItemStack(Block.dirt));
+	}
+
+	@Override
+	public void buildBlock(BptSlotInfo slot, IBptContext context) {
+		context.world().setBlock(slot.x, slot.y, slot.z, Block.dirt.blockID, slot.meta,1);
+	}
+
+	@Override
+	public boolean isValid(BptSlotInfo slot, IBptContext context) {
+		int id = context.world().getBlockId(slot.x, slot.y, slot.z);
+
+		return id == Block.dirt.blockID || id == Block.grass.blockID || id == Block.tilledField.blockID;
+	}
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockDoor.java

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ *
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.bptblocks;
+
+import java.util.LinkedList;
+
+import net.minecraft.item.ItemStack;
+import buildcraft.api.blueprints.BptBlock;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockDoor extends BptBlock {
+
+	final ItemStack stack;
+
+	public BptBlockDoor(int blockId, ItemStack stack) {
+		super(blockId);
+
+		this.stack = stack;
+	}
+
+	@Override
+	public void addRequirements(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		if ((slot.meta & 8) == 0) {
+			requirements.add(stack.copy());
+		}
+	}
+
+	@Override
+	public void rotateLeft(BptSlotInfo slot, IBptContext context) {
+		int orientation = (slot.meta & 3);
+		int others = slot.meta - orientation;
+
+		switch (orientation) {
+		case 0:
+			slot.meta = 1 + others;
+			break;
+		case 1:
+			slot.meta = 2 + others;
+			break;
+		case 2:
+			slot.meta = 3 + others;
+			break;
+		case 3:
+			slot.meta = 0 + others;
+			break;
+		}
+	}
+
+	@Override
+	public boolean ignoreBuilding(BptSlotInfo slot) {
+		return (slot.meta & 8) != 0;
+	}
+
+	@Override
+	public void buildBlock(BptSlotInfo slot, IBptContext context) {
+		context.world().setBlock(slot.x, slot.y, slot.z, slot.blockId, slot.meta,1);
+		context.world().setBlock(slot.x, slot.y + 1, slot.z, slot.blockId, slot.meta + 8,1);
+
+		context.world().setBlockMetadataWithNotify(slot.x, slot.y + 1, slot.z, slot.meta + 8,1);
+		context.world().setBlockMetadataWithNotify(slot.x, slot.y, slot.z, slot.meta,1);
+
+	}
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockIgnore.java

@@ -0,0 +1,46 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.bptblocks;
+
+import java.util.LinkedList;
+
+import net.minecraft.item.ItemStack;
+import buildcraft.api.blueprints.BptBlock;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockIgnore extends BptBlock {
+
+	public BptBlockIgnore(int blockId) {
+		super(blockId);
+	}
+
+	@Override
+	public void addRequirements(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		requirements.add(new ItemStack(slot.blockId, 0, 0));
+	}
+
+	@Override
+	public boolean isValid(BptSlotInfo slot, IBptContext context) {
+		return true;
+	}
+
+	@Override
+	public void rotateLeft(BptSlotInfo slot, IBptContext context) {
+
+	}
+
+	@Override
+	public boolean ignoreBuilding(BptSlotInfo slot) {
+		return true;
+	}
+
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockIgnoreMeta.java

@@ -0,0 +1,35 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.bptblocks;
+
+import java.util.LinkedList;
+
+import net.minecraft.item.ItemStack;
+import buildcraft.api.blueprints.BptBlock;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockIgnoreMeta extends BptBlock {
+
+	public BptBlockIgnoreMeta(int blockId) {
+		super(blockId);
+	}
+
+	@Override
+	public void addRequirements(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		requirements.add(new ItemStack(slot.blockId, 1, 0));
+	}
+
+	@Override
+	public boolean isValid(BptSlotInfo slot, IBptContext context) {
+		return slot.blockId == context.world().getBlockId(slot.x, slot.y, slot.z);
+	}
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockInventory.java

@@ -0,0 +1,28 @@
+package buildcraft.api.bptblocks;
+
+import net.minecraft.inventory.IInventory;
+import buildcraft.api.blueprints.BptBlock;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockInventory extends BptBlock {
+
+	public BptBlockInventory(int blockId) {
+		super(blockId);
+
+	}
+
+	@Override
+	public void buildBlock(BptSlotInfo slot, IBptContext context) {
+		super.buildBlock(slot, context);
+
+		IInventory inv = (IInventory) context.world().getBlockTileEntity(slot.x, slot.y, slot.z);
+
+		for (int i = 0; i < inv.getSizeInventory(); ++i) {
+			inv.setInventorySlotContents(i, null);
+		}
+
+	}
+
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockLever.java

@@ -0,0 +1,39 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.bptblocks;
+
+import java.util.LinkedList;
+
+import net.minecraft.item.ItemStack;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockLever extends BptBlockWallSide {
+
+	public BptBlockLever(int blockId) {
+		super(blockId);
+	}
+
+	@Override
+	public void addRequirements(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		requirements.add(new ItemStack(slot.blockId, 1, 0));
+	}
+
+	@Override
+	public void rotateLeft(BptSlotInfo slot, IBptContext context) {
+		int status = slot.meta - (slot.meta & 7);
+
+		slot.meta -= status;
+		super.rotateLeft(slot, context);
+		slot.meta += status;
+
+	}
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockLiquid.java

@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ *
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.bptblocks;
+
+import java.util.LinkedList;
+
+import net.minecraft.item.ItemStack;
+import buildcraft.api.blueprints.BptBlock;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockLiquid extends BptBlock {
+
+	private final ItemStack bucketStack;
+
+	public BptBlockLiquid(int blockId, ItemStack bucketStack) {
+		super(blockId);
+
+		this.bucketStack = bucketStack;
+	}
+
+	@Override
+	public void addRequirements(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		if (slot.meta == 0) {
+			requirements.add(bucketStack.copy());
+		}
+	}
+
+	@Override
+	public boolean isValid(BptSlotInfo slot, IBptContext context) {
+		if (slot.meta == 0)
+			return slot.blockId == context.world().getBlockId(slot.x, slot.y, slot.z) && context.world().getBlockMetadata(slot.x, slot.y, slot.z) == 0;
+		else
+			return true;
+	}
+
+	@Override
+	public void rotateLeft(BptSlotInfo slot, IBptContext context) {
+
+	}
+
+	@Override
+	public boolean ignoreBuilding(BptSlotInfo slot) {
+		return slot.meta != 0;
+	}
+
+	@Override
+	public void buildBlock(BptSlotInfo slot, IBptContext context) {
+		if (slot.meta == 0) {
+			context.world().setBlock(slot.x, slot.y, slot.z, slot.blockId, 0,1);
+		}
+	}
+
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockPiston.java

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ *
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.bptblocks;
+
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockPiston extends BptBlockRotateMeta {
+
+	public BptBlockPiston(int blockId) {
+		super(blockId, new int[] { 2, 5, 3, 4 }, true);
+	}
+
+	@Override
+	public void buildBlock(BptSlotInfo slot, IBptContext context) {
+		int meta = slot.meta & 7;
+
+		context.world().setBlock(slot.x, slot.y, slot.z, slot.blockId, meta,1);
+	}
+
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockPumpkin.java

@@ -0,0 +1,54 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.bptblocks;
+
+import java.util.LinkedList;
+
+import net.minecraft.item.ItemStack;
+import buildcraft.api.blueprints.BptBlock;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockPumpkin extends BptBlock {
+
+	public BptBlockPumpkin(int blockId) {
+		super(blockId);
+	}
+
+	@Override
+	public void addRequirements(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		requirements.add(new ItemStack(slot.blockId, 1, 0));
+	}
+
+	@Override
+	public boolean isValid(BptSlotInfo slot, IBptContext context) {
+		return slot.blockId == context.world().getBlockId(slot.x, slot.y, slot.z);
+	}
+
+	@Override
+	public void rotateLeft(BptSlotInfo slot, IBptContext context) {
+		switch (slot.meta) {
+		case 0:
+			slot.meta = 1;
+			break;
+		case 1:
+			slot.meta = 2;
+			break;
+		case 2:
+			slot.meta = 3;
+			break;
+		case 3:
+			slot.meta = 0;
+			break;
+		}
+	}
+
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockRedstoneRepeater.java

@@ -0,0 +1,51 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.bptblocks;
+
+import java.util.LinkedList;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import buildcraft.api.blueprints.BptBlock;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockRedstoneRepeater extends BptBlock {
+
+	public BptBlockRedstoneRepeater(int blockId) {
+		super(blockId);
+	}
+
+	@Override
+	public void addRequirements(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		requirements.add(new ItemStack(Item.redstoneRepeater));
+	}
+
+	@Override
+	public void rotateLeft(BptSlotInfo slot, IBptContext context) {
+		int step = slot.meta - (slot.meta & 3);
+
+		switch (slot.meta - step) {
+		case 0:
+			slot.meta = 1 + step;
+			break;
+		case 1:
+			slot.meta = 2 + step;
+			break;
+		case 2:
+			slot.meta = 3 + step;
+			break;
+		case 3:
+			slot.meta = 0 + step;
+			break;
+		}
+	}
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockRotateInventory.java

@@ -0,0 +1,27 @@
+package buildcraft.api.bptblocks;
+
+import net.minecraft.inventory.IInventory;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockRotateInventory extends BptBlockRotateMeta {
+
+	public BptBlockRotateInventory(int blockId, int[] rotations, boolean rotateForward) {
+		super(blockId, rotations, rotateForward);
+
+	}
+
+	@Override
+	public void buildBlock(BptSlotInfo slot, IBptContext context) {
+		super.buildBlock(slot, context);
+
+		IInventory inv = (IInventory) context.world().getBlockTileEntity(slot.x, slot.y, slot.z);
+
+		for (int i = 0; i < inv.getSizeInventory(); ++i) {
+			inv.setInventorySlotContents(i, null);
+		}
+
+	}
+
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockRotateMeta.java

@@ -0,0 +1,85 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.bptblocks;
+
+import java.util.LinkedList;
+
+import net.minecraft.item.ItemStack;
+import buildcraft.api.blueprints.BptBlock;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockRotateMeta extends BptBlock {
+
+	int[] rot;
+	boolean rotateForward;
+
+	int infoMask = 0;
+
+	public BptBlockRotateMeta(int blockId, int[] rotations, boolean rotateForward) {
+		super(blockId);
+
+		rot = rotations;
+
+		for (int i = 0; i < rot.length; ++i) {
+			if (rot[i] < 4) {
+				infoMask = (infoMask < 3 ? 3 : infoMask);
+			} else if (rot[i] < 8) {
+				infoMask = (infoMask < 7 ? 7 : infoMask);
+			} else if (rot[i] < 16) {
+				infoMask = (infoMask < 15 ? 15 : infoMask);
+			}
+		}
+
+		this.rotateForward = rotateForward;
+	}
+
+	@Override
+	public void addRequirements(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		requirements.add(new ItemStack(slot.blockId, 1, 0));
+	}
+
+	@Override
+	public boolean isValid(BptSlotInfo slot, IBptContext context) {
+		return slot.blockId == context.world().getBlockId(slot.x, slot.y, slot.z);
+	}
+
+	@Override
+	public void rotateLeft(BptSlotInfo slot, IBptContext context) {
+		int pos = slot.meta & infoMask;
+		int others = slot.meta - pos;
+
+		if (rotateForward) {
+			if (pos == rot[0]) {
+				pos = rot[1];
+			} else if (pos == rot[1]) {
+				pos = rot[2];
+			} else if (pos == rot[2]) {
+				pos = rot[3];
+			} else if (pos == rot[3]) {
+				pos = rot[0];
+			}
+		} else {
+			if (pos == rot[0]) {
+				pos = rot[3];
+			} else if (pos == rot[1]) {
+				pos = rot[2];
+			} else if (pos == rot[2]) {
+				pos = rot[0];
+			} else if (pos == rot[3]) {
+				pos = rot[1];
+			}
+		}
+
+		slot.meta = pos + others;
+	}
+
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockSign.java

@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ *
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.bptblocks;
+
+import java.util.LinkedList;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import buildcraft.api.blueprints.BlockSignature;
+import buildcraft.api.blueprints.BptBlock;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockSign extends BptBlock {
+
+	boolean isWall;
+
+	public BptBlockSign(int blockId, boolean isWall) {
+		super(blockId);
+
+		this.isWall = isWall;
+	}
+
+	@Override
+	public void addRequirements(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		requirements.add(new ItemStack(Item.sign));
+	}
+
+	@Override
+	public void rotateLeft(BptSlotInfo slot, IBptContext context) {
+		if (!isWall) {
+			double angle = ((slot.meta) * 360.0) / 16.0;
+			angle += 90.0;
+			if (angle >= 360) {
+				angle -= 360;
+			}
+			slot.meta = (int) (angle / 360.0 * 16.0);
+		} else {
+			// slot.meta = ForgeDirection.values()[slot.meta].rotateLeft().ordinal();
+		}
+	}
+
+	@Override
+	public BlockSignature getSignature(Block block) {
+		BlockSignature sig = super.getSignature(block);
+
+		if (isWall) {
+			sig.customField = "wall";
+		} else {
+			sig.customField = "floor";
+		}
+
+		return sig;
+	}
+
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockStairs.java

@@ -0,0 +1,54 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.bptblocks;
+
+import java.util.LinkedList;
+
+import net.minecraft.item.ItemStack;
+import buildcraft.api.blueprints.BptBlock;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockStairs extends BptBlock {
+
+	public BptBlockStairs(int blockId) {
+		super(blockId);
+	}
+
+	@Override
+	public void addRequirements(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		requirements.add(new ItemStack(slot.blockId, 1, 0));
+	}
+
+	@Override
+	public boolean isValid(BptSlotInfo slot, IBptContext context) {
+		return slot.blockId == context.world().getBlockId(slot.x, slot.y, slot.z);
+	}
+
+	@Override
+	public void rotateLeft(BptSlotInfo slot, IBptContext context) {
+		switch (slot.meta) {
+		case 0:
+			slot.meta = 2;
+			break;
+		case 1:
+			slot.meta = 3;
+			break;
+		case 2:
+			slot.meta = 1;
+			break;
+		case 3:
+			slot.meta = 0;
+			break;
+		}
+	}
+
+}

src/minecraft/buildcraft/api/bptblocks/BptBlockWallSide.java

@@ -0,0 +1,53 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.bptblocks;
+
+import java.util.LinkedList;
+
+import net.minecraft.item.ItemStack;
+import buildcraft.api.blueprints.BptBlock;
+import buildcraft.api.blueprints.BptSlotInfo;
+import buildcraft.api.blueprints.IBptContext;
+
+@Deprecated
+public class BptBlockWallSide extends BptBlock {
+
+	public BptBlockWallSide(int blockId) {
+		super(blockId);
+	}
+
+	@Override
+	public void addRequirements(BptSlotInfo slot, IBptContext context, LinkedList<ItemStack> requirements) {
+		requirements.add(new ItemStack(slot.blockId, 1, 0));
+	}
+
+	@Override
+	public void rotateLeft(BptSlotInfo slot, IBptContext context) {
+		final int XPos = 2;
+		final int XNeg = 1;
+		final int ZPos = 4;
+		final int ZNeg = 3;
+
+		switch (slot.meta) {
+		case XPos:
+			slot.meta = ZPos;
+			break;
+		case ZNeg:
+			slot.meta = XPos;
+			break;
+		case XNeg:
+			slot.meta = ZNeg;
+			break;
+		case ZPos:
+			slot.meta = XNeg;
+			break;
+		}
+	}
+}

src/minecraft/buildcraft/api/core/BuildCraftAPI.java

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ *
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.core;
+
+import net.minecraft.block.Block;
+
+public class BuildCraftAPI {
+
+	public static final int LAST_ORIGINAL_BLOCK = 122;
+	public static final int LAST_ORIGINAL_ITEM = 126;
+
+	public static final boolean[] softBlocks = new boolean[Block.blocksList.length];
+}

src/minecraft/buildcraft/api/core/IAreaProvider.java

@@ -0,0 +1,34 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.core;
+
+/**
+ * To be implemented by TileEntities able to provide a square area on the world, typically BuildCraft markers.
+ */
+public interface IAreaProvider {
+
+	public int xMin();
+
+	public int yMin();
+
+	public int zMin();
+
+	public int xMax();
+
+	public int yMax();
+
+	public int zMax();
+
+	/**
+	 * Remove from the world all objects used to define the area.
+	 */
+	public void removeFromWorld();
+
+}

src/minecraft/buildcraft/api/core/IBox.java

@@ -0,0 +1,30 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.core;
+
+import net.minecraft.world.World;
+
+public interface IBox {
+
+	public void expand(int amount);
+
+	public void contract(int amount);
+
+	public boolean contains(int x, int y, int z);
+
+	public Position pMin();
+
+	public Position pMax();
+
+	public void createLasers(World world, LaserKind kind);
+
+	public void deleteLasers();
+
+}

src/minecraft/buildcraft/api/core/IIconProvider.java

@@ -0,0 +1,24 @@
+package buildcraft.api.core;
+
+import net.minecraft.client.renderer.texture.IconRegister;
+import net.minecraft.util.Icon;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public interface IIconProvider {
+	
+	/**
+	 * @param iconIndex
+	 * @return
+	 */
+	@SideOnly(Side.CLIENT)
+	public Icon getIcon(int iconIndex);
+
+	/**
+	 * A call for the provider to register its Icons. This may be called multiple times but should only be executed once per provider
+	 * @param iconRegister
+	 */
+	@SideOnly(Side.CLIENT)
+	public void registerIcons(IconRegister iconRegister);
+
+}

src/minecraft/buildcraft/api/core/LaserKind.java

@@ -0,0 +1,14 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.core;
+
+public enum LaserKind {
+	Red, Blue, Stripes
+}

src/minecraft/buildcraft/api/core/Position.java

@@ -0,0 +1,142 @@
+/**
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ *
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.core;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.ForgeDirection;
+
+public class Position {
+
+	public double x, y, z;
+	public ForgeDirection orientation;
+
+	public Position(double ci, double cj, double ck) {
+		x = ci;
+		y = cj;
+		z = ck;
+		orientation = ForgeDirection.UNKNOWN;
+	}
+
+	public Position(double ci, double cj, double ck, ForgeDirection corientation) {
+		x = ci;
+		y = cj;
+		z = ck;
+		orientation = corientation;
+	}
+
+	public Position(Position p) {
+		x = p.x;
+		y = p.y;
+		z = p.z;
+		orientation = p.orientation;
+	}
+
+	public Position(NBTTagCompound nbttagcompound) {
+		x = nbttagcompound.getDouble("i");
+		y = nbttagcompound.getDouble("j");
+		z = nbttagcompound.getDouble("k");
+
+		orientation = ForgeDirection.UNKNOWN;
+	}
+
+	public Position(TileEntity tile) {
+		x = tile.xCoord;
+		y = tile.yCoord;
+		z = tile.zCoord;
+	}
+
+	public void moveRight(double step) {
+		switch (orientation) {
+		case SOUTH:
+			x = x - step;
+			break;
+		case NORTH:
+			x = x + step;
+			break;
+		case EAST:
+			z = z + step;
+			break;
+		case WEST:
+			z = z - step;
+			break;
+		default:
+		}
+	}
+
+	public void moveLeft(double step) {
+		moveRight(-step);
+	}
+
+	public void moveForwards(double step) {
+		switch (orientation) {
+		case UP:
+			y = y + step;
+			break;
+		case DOWN:
+			y = y - step;
+			break;
+		case SOUTH:
+			z = z + step;
+			break;
+		case NORTH:
+			z = z - step;
+			break;
+		case EAST:
+			x = x + step;
+			break;
+		case WEST:
+			x = x - step;
+			break;
+		default:
+		}
+	}
+
+	public void moveBackwards(double step) {
+		moveForwards(-step);
+	}
+
+	public void moveUp(double step) {
+		switch (orientation) {
+		case SOUTH:
+		case NORTH:
+		case EAST:
+		case WEST:
+			y = y + step;
+			break;
+		default:
+		}
+
+	}
+
+	public void moveDown(double step) {
+		moveUp(-step);
+	}
+
+	public void writeToNBT(NBTTagCompound nbttagcompound) {
+		nbttagcompound.setDouble("i", x);
+		nbttagcompound.setDouble("j", y);
+		nbttagcompound.setDouble("k", z);
+	}
+
+	@Override
+	public String toString() {
+		return "{" + x + ", " + y + ", " + z + "}";
+	}
+
+	public Position min(Position p) {
+		return new Position(p.x > x ? x : p.x, p.y > y ? y : p.y, p.z > z ? z : p.z);
+	}
+
+	public Position max(Position p) {
+		return new Position(p.x < x ? x : p.x, p.y < y ? y : p.y, p.z < z ? z : p.z);
+	}
+
+}

src/minecraft/buildcraft/api/core/SafeTimeTracker.java

@@ -0,0 +1,41 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.core;
+
+import net.minecraft.world.World;
+
+public class SafeTimeTracker {
+
+	private long lastMark = 0;
+
+	/**
+	 * Return true if a given delay has passed since last time marked was called successfully.
+	 */
+	public boolean markTimeIfDelay(World world, long delay) {
+		if (world == null)
+			return false;
+
+		long currentTime = world.getWorldTime();
+
+		if (currentTime < lastMark) {
+			lastMark = currentTime;
+			return false;
+		} else if (lastMark + delay <= currentTime) {
+			lastMark = world.getWorldTime();
+			return true;
+		} else
+			return false;
+
+	}
+
+	public void markTime(World world) {
+		lastMark = world.getWorldTime();
+	}
+}

src/minecraft/buildcraft/api/filler/FillerManager.java

@@ -0,0 +1,7 @@
+package buildcraft.api.filler;
+
+public class FillerManager {
+
+	public static IFillerRegistry registry;
+
+}

src/minecraft/buildcraft/api/filler/IFillerPattern.java

@@ -0,0 +1,23 @@
+package buildcraft.api.filler;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.Icon;
+import buildcraft.api.core.IBox;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public interface IFillerPattern {
+
+	public int getId();
+
+	public void setId(int id);
+
+	public boolean iteratePattern(TileEntity tile, IBox box, ItemStack stackToPlace);
+
+	@SideOnly(Side.CLIENT)
+	public Icon getTexture();
+
+	public String getName();
+
+}

src/minecraft/buildcraft/api/filler/IFillerRegistry.java

@@ -0,0 +1,15 @@
+package buildcraft.api.filler;
+
+import net.minecraft.inventory.IInventory;
+
+public interface IFillerRegistry {
+
+	public void addRecipe(IFillerPattern pattern, Object aobj[]);
+
+	public IFillerPattern findMatchingRecipe(IInventory inventorycrafting);
+
+	public int getPatternNumber(IFillerPattern pattern);
+
+	public IFillerPattern getPattern(int n);
+
+}

src/minecraft/buildcraft/api/fuels/IronEngineCoolant.java

@@ -0,0 +1,32 @@
+package buildcraft.api.fuels;
+
+import java.util.LinkedList;
+
+import net.minecraftforge.liquids.LiquidStack;
+
+public class IronEngineCoolant {
+
+	public static LinkedList<IronEngineCoolant> coolants = new LinkedList<IronEngineCoolant>();
+
+	public static IronEngineCoolant getCoolantForLiquid(LiquidStack liquid) {
+		if (liquid == null)
+			return null;
+		if (liquid.itemID <= 0)
+			return null;
+
+		for (IronEngineCoolant coolant : coolants)
+			if (coolant.liquid.isLiquidEqual(liquid))
+				return coolant;
+
+		return null;
+	}
+
+	public final LiquidStack liquid;
+	public final float coolingPerUnit;
+
+	public IronEngineCoolant(LiquidStack liquid, float coolingPerUnit) {
+		this.liquid = liquid;
+		this.coolingPerUnit = coolingPerUnit;
+	}
+
+}

src/minecraft/buildcraft/api/fuels/IronEngineFuel.java

@@ -0,0 +1,47 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.fuels;
+
+import java.util.LinkedList;
+
+import net.minecraftforge.liquids.LiquidContainerRegistry;
+import net.minecraftforge.liquids.LiquidStack;
+
+public class IronEngineFuel {
+
+	public static LinkedList<IronEngineFuel> fuels = new LinkedList<IronEngineFuel>();
+
+	public static IronEngineFuel getFuelForLiquid(LiquidStack liquid) {
+		if (liquid == null)
+			return null;
+		if (liquid.itemID <= 0)
+			return null;
+
+		for (IronEngineFuel fuel : fuels)
+			if (fuel.liquid.isLiquidEqual(liquid))
+				return fuel;
+
+		return null;
+	}
+
+	public final LiquidStack liquid;
+	public final float powerPerCycle;
+	public final int totalBurningTime;
+
+	public IronEngineFuel(int liquidId, float powerPerCycle, int totalBurningTime) {
+		this(new LiquidStack(liquidId, LiquidContainerRegistry.BUCKET_VOLUME, 0), powerPerCycle, totalBurningTime);
+	}
+
+	public IronEngineFuel(LiquidStack liquid, float powerPerCycle, int totalBurningTime) {
+		this.liquid = liquid;
+		this.powerPerCycle = powerPerCycle;
+		this.totalBurningTime = totalBurningTime;
+	}
+}

src/minecraft/buildcraft/api/gates/ActionManager.java

@@ -0,0 +1,83 @@
+package buildcraft.api.gates;
+
+import java.util.LinkedList;
+
+import net.minecraft.block.Block;
+import net.minecraft.tileentity.TileEntity;
+import buildcraft.api.transport.IPipe;
+
+public class ActionManager {
+
+	public static ITrigger[] triggers = new ITrigger[1024];
+	public static IAction[] actions = new IAction[1024];
+
+	private static LinkedList<ITriggerProvider> triggerProviders = new LinkedList<ITriggerProvider>();
+	private static LinkedList<IActionProvider> actionProviders = new LinkedList<IActionProvider>();
+
+	public static void registerTriggerProvider(ITriggerProvider provider) {
+		if (provider != null && !triggerProviders.contains(provider)) {
+			triggerProviders.add(provider);
+		}
+	}
+
+	public static LinkedList<ITrigger> getNeighborTriggers(Block block, TileEntity entity) {
+		LinkedList<ITrigger> triggers = new LinkedList<ITrigger>();
+
+		for (ITriggerProvider provider : triggerProviders) {
+			LinkedList<ITrigger> toAdd = provider.getNeighborTriggers(block, entity);
+
+			if (toAdd != null) {
+				for (ITrigger t : toAdd) {
+					if (!triggers.contains(t)) {
+						triggers.add(t);
+					}
+				}
+			}
+		}
+
+		return triggers;
+	}
+
+	public static void registerActionProvider(IActionProvider provider) {
+		if (provider != null && !actionProviders.contains(provider)) {
+			actionProviders.add(provider);
+		}
+	}
+
+	public static LinkedList<IAction> getNeighborActions(Block block, TileEntity entity) {
+		LinkedList<IAction> actions = new LinkedList<IAction>();
+
+		for (IActionProvider provider : actionProviders) {
+			LinkedList<IAction> toAdd = provider.getNeighborActions(block, entity);
+
+			if (toAdd != null) {
+				for (IAction t : toAdd) {
+					if (!actions.contains(t)) {
+						actions.add(t);
+					}
+				}
+			}
+		}
+
+		return actions;
+	}
+
+	public static LinkedList<ITrigger> getPipeTriggers(IPipe pipe) {
+		LinkedList<ITrigger> triggers = new LinkedList<ITrigger>();
+
+		for (ITriggerProvider provider : triggerProviders) {
+			LinkedList<ITrigger> toAdd = provider.getPipeTriggers(pipe);
+
+			if (toAdd != null) {
+				for (ITrigger t : toAdd) {
+					if (!triggers.contains(t)) {
+						triggers.add(t);
+					}
+				}
+			}
+		}
+
+		return triggers;
+	}
+
+}

src/minecraft/buildcraft/api/gates/IAction.java

@@ -0,0 +1,20 @@
+package buildcraft.api.gates;
+
+import buildcraft.api.core.IIconProvider;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public interface IAction {
+
+	int getId();
+
+    int getIconIndex();
+    
+    @SideOnly(Side.CLIENT)
+    IIconProvider getIconProvider();
+    
+	boolean hasParameter();
+
+	String getDescription();
+
+}

src/minecraft/buildcraft/api/gates/IActionProvider.java

@@ -0,0 +1,24 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.gates;
+
+import java.util.LinkedList;
+
+import net.minecraft.block.Block;
+import net.minecraft.tileentity.TileEntity;
+
+public interface IActionProvider {
+
+	/**
+	 * Returns the list of actions available to a gate next to the given block.
+	 */
+	public abstract LinkedList<IAction> getNeighborActions(Block block, TileEntity tile);
+
+}

src/minecraft/buildcraft/api/gates/IActionReceptor.java

@@ -0,0 +1,16 @@
+/** 
+ * Copyright (c) SpaceToad, 2012
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.gates;
+
+public interface IActionReceptor {
+
+	public void actionActivated(IAction action);
+
+}

src/minecraft/buildcraft/api/gates/IOverrideDefaultTriggers.java

@@ -0,0 +1,21 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.gates;
+
+import java.util.LinkedList;
+
+/**
+ * This interface has to be implemented by a TileEntity or a Pipe that wants to provide triggers different from the ones installed by default with BuildCraft.
+ */
+public interface IOverrideDefaultTriggers {
+
+	LinkedList<ITrigger> getTriggers();
+
+}

src/minecraft/buildcraft/api/gates/ITrigger.java

@@ -0,0 +1,38 @@
+package buildcraft.api.gates;
+
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.ForgeDirection;
+import buildcraft.api.core.IIconProvider;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public interface ITrigger {
+
+	public abstract int getId();
+
+	public int getIconIndex();
+    
+    @SideOnly(Side.CLIENT)
+    public IIconProvider getIconProvider();
+
+	/**
+	 * Return true if this trigger can accept parameters
+	 */
+	public boolean hasParameter();
+
+	/**
+	 * Return the trigger description in the UI
+	 */
+	public String getDescription();
+
+	/**
+	 * Return true if the tile given in parameter activates the trigger, given the parameters.
+	 */
+	public abstract boolean isTriggerActive(ForgeDirection side, TileEntity tile, ITriggerParameter parameter);
+
+	/**
+	 * Create parameters for the trigger. As for now, there is only one kind of trigger parameter available so this subprogram is final.
+	 */
+	public ITriggerParameter createParameter();
+
+}

src/minecraft/buildcraft/api/gates/ITriggerParameter.java

@@ -0,0 +1,18 @@
+package buildcraft.api.gates;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+
+public interface ITriggerParameter {
+
+	public abstract ItemStack getItemStack();
+
+	public abstract void set(ItemStack stack);
+
+	public abstract void writeToNBT(NBTTagCompound compound);
+
+	public abstract void readFromNBT(NBTTagCompound compound);
+
+	public abstract ItemStack getItem();
+
+}

src/minecraft/buildcraft/api/gates/ITriggerProvider.java

@@ -0,0 +1,30 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.gates;
+
+import java.util.LinkedList;
+
+import net.minecraft.block.Block;
+import net.minecraft.tileentity.TileEntity;
+import buildcraft.api.transport.IPipe;
+
+public interface ITriggerProvider {
+
+	/**
+	 * Returns the list of triggers that are available from the pipe holding the gate.
+	 */
+	public abstract LinkedList<ITrigger> getPipeTriggers(IPipe pipe);
+
+	/**
+	 * Returns the list of triggers available to a gate next to the given block.
+	 */
+	public abstract LinkedList<ITrigger> getNeighborTriggers(Block block, TileEntity tile);
+
+}

src/minecraft/buildcraft/api/gates/TriggerParameter.java

@@ -0,0 +1,79 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.gates;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+
+public class TriggerParameter implements ITriggerParameter {
+
+	protected ItemStack stack;
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see net.minecraft.src.buildcraft.api.gates.ITriggerParameter#getItemStack()
+	 */
+	@Override
+	public ItemStack getItemStack() {
+		return stack;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see net.minecraft.src.buildcraft.api.gates.ITriggerParameter#set(net.minecraft.src.ItemStack)
+	 */
+	@Override
+	public void set(ItemStack stack) {
+		if (stack != null) {
+			this.stack = stack.copy();
+			this.stack.stackSize = 1;
+		}
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see net.minecraft.src.buildcraft.api.gates.ITriggerParameter#writeToNBT(net.minecraft.src.NBTTagCompound)
+	 */
+	@Override
+	public void writeToNBT(NBTTagCompound compound) {
+		if (stack != null) {
+			compound.setInteger("itemID", stack.itemID);
+			compound.setInteger("itemDMG", stack.getItemDamage());
+		}
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see net.minecraft.src.buildcraft.api.gates.ITriggerParameter#readFromNBT(net.minecraft.src.NBTTagCompound)
+	 */
+	@Override
+	public void readFromNBT(NBTTagCompound compound) {
+		int itemID = compound.getInteger("itemID");
+
+		if (itemID != 0) {
+			stack = new ItemStack(itemID, 1, compound.getInteger("itemDMG"));
+		}
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see net.minecraft.src.buildcraft.api.gates.ITriggerParameter#getItem()
+	 */
+	@Override
+	public ItemStack getItem() {
+		return stack;
+	}
+
+}

src/minecraft/buildcraft/api/inventory/ISecuredInventory.java

@@ -0,0 +1,23 @@
+package buildcraft.api.inventory;
+
+import net.minecraftforge.common.ForgeDirection;
+
+public interface ISecuredInventory {
+
+	/**
+	 * @param name
+	 * @return true if the user/player with the given name has access permissions on this machine.
+	 */
+	boolean canAccess(String name);
+
+	/**
+	 * Informs the inventory with whose permissions the next item or liquid transaction will be performed. It is up to the inventory to determine the effect.
+	 * 
+	 * @param orientation
+	 *            Orientation the transaction will be performed from.
+	 * @param name
+	 *            Name of the user/player who owns the transaction.
+	 */
+	void prepareTransaction(ForgeDirection orientation, String name);
+
+}

src/minecraft/buildcraft/api/inventory/ISelectiveInventory.java

@@ -0,0 +1,23 @@
+package buildcraft.api.inventory;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.ForgeDirection;
+
+public interface ISelectiveInventory extends ISpecialInventory {
+	/**
+	 * Requests specified items to be extracted from the inventory
+	 * 
+	 * @param desired
+	 *            Array which can contain ItemStacks, Items, or classes describing the type of item accepted or excluded.
+	 * @param exclusion
+	 *            If true desired items are not eligible for returning.
+	 * @param doRemove
+	 *            If false no actual extraction may occur.
+	 * @param from
+	 *            Orientation the ItemStack is requested from.
+	 * @param maxItemCount
+	 *            Maximum amount of items to extract (spread over all returned item stacks)
+	 * @return Array of item stacks extracted from the inventory
+	 */
+	ItemStack[] extractItem(Object[] desired, boolean exclusion, boolean doRemove, ForgeDirection from, int maxItemCount);
+}

src/minecraft/buildcraft/api/inventory/ISpecialInventory.java

@@ -0,0 +1,36 @@
+package buildcraft.api.inventory;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.ForgeDirection;
+
+public interface ISpecialInventory extends IInventory {
+
+	/**
+	 * Offers an ItemStack for addition to the inventory.
+	 * 
+	 * @param stack
+	 *            ItemStack offered for addition. Do not manipulate this!
+	 * @param doAdd
+	 *            If false no actual addition should take place. Implementors should simulate.
+	 * @param from
+	 *            Orientation the ItemStack is offered from.
+	 * @return Amount of items used from the passed stack.
+	 */
+	int addItem(ItemStack stack, boolean doAdd, ForgeDirection from);
+
+	/**
+	 * Requests items to be extracted from the inventory
+	 * 
+	 * @param doRemove
+	 *            If false no actual extraction may occur. Implementors should simulate.
+	 *            Can be used to "peek" at what the result would be 
+	 * @param from
+	 *            Orientation the ItemStack is requested from.
+	 * @param maxItemCount
+	 *            Maximum amount of items to extract (spread over all returned item stacks)
+	 * @return Array of item stacks that were/would be extracted from the inventory 
+	 */
+	ItemStack[] extractItem(boolean doRemove, ForgeDirection from, int maxItemCount);
+
+}

src/minecraft/buildcraft/api/power/IPowerProvider.java

@@ -0,0 +1,41 @@
+package buildcraft.api.power;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.ForgeDirection;
+import buildcraft.api.core.SafeTimeTracker;
+
+public interface IPowerProvider {
+
+	int getLatency();
+
+	int getMinEnergyReceived();
+
+	int getMaxEnergyReceived();
+
+	int getMaxEnergyStored();
+
+	int getActivationEnergy();
+
+	float getEnergyStored();
+
+	void configure(int latency, int minEnergyReceived, int maxEnergyReceived, int minActivationEnergy, int maxStoredEnergy);
+
+	void configurePowerPerdition(int powerLoss, int powerLossRegularity);
+
+	boolean update(IPowerReceptor receptor);
+
+	boolean preConditions(IPowerReceptor receptor);
+
+	float useEnergy(float min, float max, boolean doUse);
+
+	void readFromNBT(NBTTagCompound nbttagcompound);
+
+	void writeToNBT(NBTTagCompound nbttagcompound);
+
+	void receiveEnergy(float quantity, ForgeDirection from);
+
+	boolean isPowerSource(ForgeDirection from);
+
+	SafeTimeTracker getTimeTracker();
+
+}

src/minecraft/buildcraft/api/power/IPowerReceptor.java

@@ -0,0 +1,24 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.power;
+
+import net.minecraftforge.common.ForgeDirection;
+
+public interface IPowerReceptor {
+
+	public void setPowerProvider(IPowerProvider provider);
+
+	public IPowerProvider getPowerProvider();
+
+	public void doWork();
+
+	public int powerRequest(ForgeDirection from);
+
+}

src/minecraft/buildcraft/api/power/PowerFramework.java

@@ -0,0 +1,55 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.power;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+public abstract class PowerFramework {
+
+	static private String baseNBTName = "net.minecraft.src.buildcarft.Power";
+
+	public static PowerFramework currentFramework;
+
+	public abstract IPowerProvider createPowerProvider();
+
+	public void loadPowerProvider(IPowerReceptor receptor, NBTTagCompound compound) {
+
+		IPowerProvider provider = createPowerProvider();
+
+		if (compound.hasKey(baseNBTName)) {
+			NBTTagCompound cpt = compound.getCompoundTag(baseNBTName);
+			if (cpt.getString("class").equals(this.getClass().getName())) {
+				provider.readFromNBT(cpt.getCompoundTag("contents"));
+			}
+		}
+
+		receptor.setPowerProvider(provider);
+	}
+
+	public void savePowerProvider(IPowerReceptor receptor, NBTTagCompound compound) {
+
+		IPowerProvider provider = receptor.getPowerProvider();
+
+		if (provider == null)
+			return;
+
+		NBTTagCompound cpt = new NBTTagCompound();
+
+		cpt.setString("class", this.getClass().getName());
+
+		NBTTagCompound contents = new NBTTagCompound();
+
+		provider.writeToNBT(contents);
+
+		cpt.setTag("contents", contents);
+		compound.setTag(baseNBTName, cpt);
+	}
+
+}

src/minecraft/buildcraft/api/power/PowerProvider.java

@@ -0,0 +1,187 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.power;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.ForgeDirection;
+import buildcraft.api.core.SafeTimeTracker;
+
+public abstract class PowerProvider implements IPowerProvider {
+
+	protected int latency;
+	protected int minEnergyReceived;
+	protected int maxEnergyReceived;
+	protected int maxEnergyStored;
+	protected int minActivationEnergy;
+	protected float energyStored = 0;
+
+	protected int powerLoss = 1;
+	protected int powerLossRegularity = 100;
+
+	public SafeTimeTracker timeTracker = new SafeTimeTracker();
+	public SafeTimeTracker energyLossTracker = new SafeTimeTracker();
+
+	public int[] powerSources = { 0, 0, 0, 0, 0, 0 };
+
+	@Override
+	public SafeTimeTracker getTimeTracker() {
+		return this.timeTracker;
+	}
+
+	@Override
+	public int getLatency() {
+		return this.latency;
+	}
+
+	@Override
+	public int getMinEnergyReceived() {
+		return this.minEnergyReceived;
+	}
+
+	@Override
+	public int getMaxEnergyReceived() {
+		return this.maxEnergyReceived;
+	}
+
+	@Override
+	public int getMaxEnergyStored() {
+		return this.maxEnergyStored;
+	}
+
+	@Override
+	public int getActivationEnergy() {
+		return this.minActivationEnergy;
+	}
+
+	@Override
+	public float getEnergyStored() {
+		return this.energyStored;
+	}
+
+	@Override
+	public void configure(int latency, int minEnergyReceived, int maxEnergyReceived, int minActivationEnergy, int maxStoredEnergy) {
+		this.latency = latency;
+		this.minEnergyReceived = minEnergyReceived;
+		this.maxEnergyReceived = maxEnergyReceived;
+		this.maxEnergyStored = maxStoredEnergy;
+		this.minActivationEnergy = minActivationEnergy;
+	}
+
+	@Override
+	public void configurePowerPerdition(int powerLoss, int powerLossRegularity) {
+		this.powerLoss = powerLoss;
+		this.powerLossRegularity = powerLossRegularity;
+	}
+
+	@Override
+	public boolean update(IPowerReceptor receptor) {
+		if (!preConditions(receptor))
+			return false;
+
+		TileEntity tile = (TileEntity) receptor;
+		boolean result = false;
+
+		if (energyStored >= minActivationEnergy) {
+			if (latency == 0) {
+				receptor.doWork();
+				result = true;
+			} else {
+				if (timeTracker.markTimeIfDelay(tile.worldObj, latency)) {
+					receptor.doWork();
+					result = true;
+				}
+			}
+		}
+
+		if (powerLoss > 0 && energyLossTracker.markTimeIfDelay(tile.worldObj, powerLossRegularity)) {
+
+			energyStored -= powerLoss;
+			if (energyStored < 0) {
+				energyStored = 0;
+			}
+		}
+
+		for (int i = 0; i < 6; ++i) {
+			if (powerSources[i] > 0) {
+				powerSources[i]--;
+			}
+		}
+
+		return result;
+	}
+
+	@Override
+	public boolean preConditions(IPowerReceptor receptor) {
+		return true;
+	}
+
+	@Override
+	public float useEnergy(float min, float max, boolean doUse) {
+		float result = 0;
+
+		if (energyStored >= min) {
+			if (energyStored <= max) {
+				result = energyStored;
+				if (doUse) {
+					energyStored = 0;
+				}
+			} else {
+				result = max;
+				if (doUse) {
+					energyStored -= max;
+				}
+			}
+		}
+
+		return result;
+	}
+
+	@Override
+	public void readFromNBT(NBTTagCompound nbttagcompound) {
+		latency = nbttagcompound.getInteger("latency");
+		minEnergyReceived = nbttagcompound.getInteger("minEnergyReceived");
+		maxEnergyReceived = nbttagcompound.getInteger("maxEnergyReceived");
+		maxEnergyStored = nbttagcompound.getInteger("maxStoreEnergy");
+		minActivationEnergy = nbttagcompound.getInteger("minActivationEnergy");
+
+		try {
+			energyStored = nbttagcompound.getFloat("storedEnergy");
+		} catch (Throwable c) {
+			energyStored = 0;
+		}
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound nbttagcompound) {
+		nbttagcompound.setInteger("latency", latency);
+		nbttagcompound.setInteger("minEnergyReceived", minEnergyReceived);
+		nbttagcompound.setInteger("maxEnergyReceived", maxEnergyReceived);
+		nbttagcompound.setInteger("maxStoreEnergy", maxEnergyStored);
+		nbttagcompound.setInteger("minActivationEnergy", minActivationEnergy);
+		nbttagcompound.setFloat("storedEnergy", energyStored);
+	}
+
+	@Override
+	public void receiveEnergy(float quantity, ForgeDirection from) {
+		powerSources[from.ordinal()] = 2;
+
+		energyStored += quantity;
+
+		if (energyStored > maxEnergyStored) {
+			energyStored = maxEnergyStored;
+		}
+	}
+
+	@Override
+	public boolean isPowerSource(ForgeDirection from) {
+		return powerSources[from.ordinal()] != 0;
+	}
+}

src/minecraft/buildcraft/api/recipes/AssemblyRecipe.java

@@ -0,0 +1,49 @@
+package buildcraft.api.recipes;
+
+import java.util.LinkedList;
+
+import net.minecraft.item.ItemStack;
+
+public class AssemblyRecipe {
+
+	public static LinkedList<AssemblyRecipe> assemblyRecipes = new LinkedList<AssemblyRecipe>();
+
+	public final ItemStack[] input;
+	public final ItemStack output;
+	public final float energy;
+
+	public AssemblyRecipe(ItemStack[] input, int energy, ItemStack output) {
+		this.input = input;
+		this.output = output;
+		this.energy = energy;
+	}
+
+	public boolean canBeDone(ItemStack[] items) {
+
+		for (ItemStack in : input) {
+
+			if (in == null) {
+				continue;
+			}
+
+			int found = 0; // Amount of ingredient found in inventory
+
+			for (ItemStack item : items) {
+				if (item == null) {
+					continue;
+				}
+
+				if (item.isItemEqual(in)) {
+					found += item.stackSize; // Adds quantity of stack to amount
+												// found
+				}
+			}
+
+			if (found < in.stackSize)
+				return false; // Return false if the amount of ingredient found
+								// is not enough
+		}
+
+		return true;
+	}
+}

src/minecraft/buildcraft/api/recipes/RefineryRecipe.java

@@ -0,0 +1,153 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.recipes;
+
+import java.util.Collections;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+import net.minecraftforge.liquids.LiquidStack;
+
+public class RefineryRecipe implements Comparable<RefineryRecipe> {
+
+	private static SortedSet<RefineryRecipe> recipes = new TreeSet<RefineryRecipe>();
+
+	public static void registerRefineryRecipe(RefineryRecipe recipe) {
+		if (!recipes.contains(recipe)) {
+			recipes.add(recipe);
+		}
+	}
+
+	public static SortedSet<RefineryRecipe> getRecipes() {
+		return Collections.unmodifiableSortedSet(recipes);
+	}
+
+	public static RefineryRecipe findRefineryRecipe(LiquidStack liquid1, LiquidStack liquid2) {
+		for (RefineryRecipe recipe : recipes)
+			if (recipe.matches(liquid1, liquid2))
+				return recipe;
+
+		return null;
+	}
+
+	public final LiquidStack ingredient1;
+	public final LiquidStack ingredient2;
+	public final LiquidStack result;
+
+	public final int energy;
+	public final int delay;
+
+	public RefineryRecipe(int ingredientId1, int ingredientQty1, int ingredientId2, int ingredientQty2, int resultId, int resultQty, int energy, int delay) {
+		this(new LiquidStack(ingredientId1, ingredientQty1, 0), new LiquidStack(ingredientId2, ingredientQty2, 0), new LiquidStack(resultId, resultQty, 0),
+				energy, delay);
+	}
+
+	public RefineryRecipe(LiquidStack ingredient1, LiquidStack ingredient2, LiquidStack result, int energy, int delay) {
+
+		// Sort starting materials.
+		if (ingredient1 != null && ingredient2 != null) {
+			if ((ingredient1.itemID > ingredient2.itemID) || (ingredient1.itemID == ingredient2.itemID && ingredient1.itemMeta > ingredient2.itemMeta)) {
+				this.ingredient1 = ingredient2;
+				this.ingredient2 = ingredient1;
+			} else {
+				this.ingredient1 = ingredient1;
+				this.ingredient2 = ingredient2;
+			}
+		} else if (ingredient2 != null) {
+			this.ingredient1 = ingredient2;
+			this.ingredient2 = ingredient1;
+		} else {
+			this.ingredient1 = ingredient1;
+			this.ingredient2 = ingredient2;
+		}
+
+		this.result = result;
+		this.energy = energy;
+		this.delay = delay;
+	}
+
+	public boolean matches(LiquidStack liquid1, LiquidStack liquid2) {
+
+		// No inputs, return.
+		if (liquid1 == null && liquid2 == null)
+			return false;
+
+		// Return if two ingredients are required but only one was supplied.
+		if ((ingredient1 != null && ingredient2 != null) && (liquid1 == null || liquid2 == null))
+			return false;
+
+		if (ingredient1 != null) {
+
+			if (ingredient2 == null)
+				return ingredient1.isLiquidEqual(liquid1) || ingredient1.isLiquidEqual(liquid2);
+			else
+				return (ingredient1.isLiquidEqual(liquid1) && ingredient2.isLiquidEqual(liquid2))
+						|| (ingredient2.isLiquidEqual(liquid1) && ingredient1.isLiquidEqual(liquid2));
+
+		} else if (ingredient2 != null)
+			return ingredient2.isLiquidEqual(liquid1) || ingredient2.isLiquidEqual(liquid2);
+		else
+			return false;
+
+	}
+
+	// Compares to only the types of source materials.
+	// We consider non-null < null in order that one-ingredient recipe is checked after
+	// the failure of matching two-ingredient recipes which include that liquid.
+	@Override
+	public int compareTo(RefineryRecipe other) {
+
+		if (other == null)
+			return -1;
+		else if (ingredient1 == null) {
+			if (other.ingredient1 == null)
+				return 0;
+			else
+				return 1;
+		} else if (other.ingredient1 == null)
+			return -1;
+		else if (ingredient1.itemID != other.ingredient1.itemID)
+			return ingredient1.itemID - other.ingredient1.itemID;
+		else if (ingredient1.itemMeta != other.ingredient1.itemMeta)
+			return ingredient1.itemMeta - other.ingredient1.itemMeta;
+		else if (ingredient2 == null) {
+			if (other.ingredient2 == null)
+				return 0;
+			else
+				return 1;
+		} else if (other.ingredient2 == null)
+			return -1;
+		else if (ingredient2.itemID != other.ingredient2.itemID)
+			return ingredient2.itemID - other.ingredient2.itemID;
+		else if (ingredient2.itemMeta != other.ingredient2.itemMeta)
+			return ingredient2.itemMeta - other.ingredient2.itemMeta;
+
+		return 0;
+	}
+
+	// equals() should be consistent with compareTo().
+	@Override
+	public boolean equals(Object obj) {
+		if (obj != null && obj instanceof RefineryRecipe)
+			return this.compareTo((RefineryRecipe) obj) == 0;
+		return false;
+	}
+
+	// hashCode() should be overridden because equals() was overridden.
+	@Override
+	public int hashCode() {
+		if (ingredient1 == null)
+			return 0;
+		else if (ingredient2 == null)
+			return ingredient1.itemID ^ ingredient1.itemMeta;
+
+		return ingredient1.itemID ^ ingredient1.itemMeta ^ ingredient2.itemID ^ ingredient2.itemMeta;
+	}
+}

src/minecraft/buildcraft/api/tools/IToolPipette.java

@@ -0,0 +1,40 @@
+package buildcraft.api.tools;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.liquids.LiquidStack;
+
+public interface IToolPipette {
+
+	/**
+	 * @param pipette
+	 *            ItemStack of the pipette.
+	 * @return Capacity of the pipette.
+	 */
+	int getCapacity(ItemStack pipette);
+
+	/**
+	 * @param pipette
+	 * @return true if the pipette can pipette.
+	 */
+	boolean canPipette(ItemStack pipette);
+
+	/**
+	 * Fills the pipette with the given liquid stack.
+	 * 
+	 * @param pipette
+	 * @param liquid
+	 * @param doFill
+	 * @return Amount of liquid used in filling the pipette.
+	 */
+	int fill(ItemStack pipette, LiquidStack liquid, boolean doFill);
+
+	/**
+	 * Drains liquid from the pipette
+	 * 
+	 * @param pipette
+	 * @param maxDrain
+	 * @param doDrain
+	 * @return Liquid stack representing the liquid and amount drained from the pipette.
+	 */
+	LiquidStack drain(ItemStack pipette, int maxDrain, boolean doDrain);
+}

src/minecraft/buildcraft/api/tools/IToolWrench.java

@@ -0,0 +1,32 @@
+package buildcraft.api.tools;
+
+import net.minecraft.entity.player.EntityPlayer;
+
+/***
+ * Implement this interface on subclasses of Item to have that item work as a wrench for buildcraft
+ */
+public interface IToolWrench {
+
+	/***
+	 * Called to ensure that the wrench can be used. To get the ItemStack that is used, check player.inventory.getCurrentItem()
+	 * 
+	 * @param player
+	 *            - The player doing the wrenching
+	 * @param x
+	 *            ,y,z - The coordinates for the block being wrenched
+	 * 
+	 * @return true if wrenching is allowed, false if not
+	 */
+	public boolean canWrench(EntityPlayer player, int x, int y, int z);
+
+	/***
+	 * Callback after the wrench has been used. This can be used to decrease durability or for other purposes. To get the ItemStack that was used, check
+	 * player.inventory.getCurrentItem()
+	 * 
+	 * @param player
+	 *            - The player doing the wrenching
+	 * @param x
+	 *            ,y,z - The coordinates of the block being wrenched
+	 */
+	public void wrenchUsed(EntityPlayer player, int x, int y, int z);
+}

src/minecraft/buildcraft/api/transport/FacadeManager.java

@@ -0,0 +1,26 @@
+package buildcraft.api.transport;
+
+import java.lang.reflect.Method;
+
+import net.minecraft.item.ItemStack;
+
+/**
+ * You can use this if you wish, but FML InterModComms are recommended.
+ *
+ * SYNTAX: add-facade:id@meta
+ */
+public class FacadeManager {
+	private static Method addFacade;
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public static void addFacade(ItemStack is) {
+		try {
+			if (addFacade == null) {
+				Class facade = Class.forName("buildcraft.transport.ItemFacade");
+				addFacade = facade.getMethod("addFacade", ItemStack.class);
+			}
+			addFacade.invoke(null, is);
+		} catch (Exception ex) {
+		}
+	}
+}

src/minecraft/buildcraft/api/transport/IExtractionHandler.java

@@ -0,0 +1,21 @@
+package buildcraft.api.transport;
+
+import net.minecraft.world.World;
+
+/**
+ * Implement and register with the PipeManager if you want to suppress connections from wooden pipes.
+ */
+public interface IExtractionHandler {
+
+	/**
+	 * Can this pipe extract items from the block located at these coordinates?
+	 * param extractor can be null
+	 */
+	boolean canExtractItems(Object extractor, World world, int i, int j, int k);
+
+	/**
+	 * Can this pipe extract liquids from the block located at these coordinates?
+	 * param extractor can be null
+	 */
+	boolean canExtractLiquids(Object extractor, World world, int i, int j, int k);
+}

src/minecraft/buildcraft/api/transport/IPassiveItemContribution.java

@@ -0,0 +1,20 @@
+/** 
+ * Copyright (c) SpaceToad, 2012
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.transport;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+public interface IPassiveItemContribution {
+
+	public void readFromNBT(NBTTagCompound nbttagcompound);
+
+	public void writeToNBT(NBTTagCompound nbttagcompound);
+
+}

src/minecraft/buildcraft/api/transport/IPipe.java

@@ -0,0 +1,45 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.transport;
+
+import net.minecraft.tileentity.TileEntity;
+
+public interface IPipe {
+
+	enum DrawingState {
+		DrawingPipe, DrawingRedWire, DrawingBlueWire, DrawingGreenWire, DrawingYellowWire, DrawingGate
+	}
+
+	enum WireColor {
+		Red, Blue, Green, Yellow;
+
+		public WireColor reverse() {
+			switch (this) {
+			case Red:
+				return Yellow;
+			case Blue:
+				return Green;
+			case Green:
+				return Blue;
+			default:
+				return Red;
+			}
+		}
+	}
+
+	public boolean isWired(WireColor color);
+
+	public boolean hasInterface();
+
+	public TileEntity getContainer();
+
+	public boolean isWireConnectedTo(TileEntity tile, WireColor color);
+
+}

src/minecraft/buildcraft/api/transport/IPipeConnection.java

@@ -0,0 +1,17 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.transport;
+
+import net.minecraftforge.common.ForgeDirection;
+
+public interface IPipeConnection {
+
+	public boolean isPipeConnected(ForgeDirection with);
+}

src/minecraft/buildcraft/api/transport/IPipeEntry.java

@@ -0,0 +1,26 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.transport;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.ForgeDirection;
+
+/**
+ * Interface used to put objects into pipes, implemented by pipe tile entities.
+ */
+public interface IPipeEntry {
+
+	void entityEntering(ItemStack payload, ForgeDirection orientation);
+
+	void entityEntering(IPipedItem item, ForgeDirection orientation);
+
+	boolean acceptItems();
+
+}

src/minecraft/buildcraft/api/transport/IPipeTile.java

@@ -0,0 +1,17 @@
+/** 
+ * Copyright (c) SpaceToad, 2011
+ * http://www.mod-buildcraft.com
+ * 
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public 
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+
+package buildcraft.api.transport;
+
+public interface IPipeTile {
+
+	IPipe getPipe();
+
+	boolean isInitialized();
+}

src/minecraft/buildcraft/api/transport/IPipedItem.java

@@ -0,0 +1,83 @@
+package buildcraft.api.transport;
+
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ForgeDirection;
+import buildcraft.api.core.Position;
+
+public interface IPipedItem {
+
+	public abstract void remove();
+
+	/* GETTING & SETTING */
+	public abstract void setWorld(World world);
+
+	public abstract Position getPosition();
+
+	public abstract void setPosition(double x, double y, double z);
+
+	/**
+	 * @return the speed
+	 */
+	public abstract float getSpeed();
+
+	/**
+	 * @param speed
+	 *            the speed to set
+	 */
+	public abstract void setSpeed(float speed);
+
+	/**
+	 * @return the item
+	 */
+	public abstract ItemStack getItemStack();
+
+	/**
+	 * @param item
+	 *            the item to set
+	 */
+	public abstract void setItemStack(ItemStack item);
+
+	/**
+	 * @return the container
+	 */
+	public abstract TileEntity getContainer();
+
+	/**
+	 * @param container
+	 *            the container to set
+	 */
+	public abstract void setContainer(TileEntity container);
+
+	/**
+	 * @return the entityId
+	 */
+	public abstract int getEntityId();
+
+	/**
+	 * @param entityId
+	 *            the entityId to set
+	 */
+	public abstract void setEntityId(int entityId);
+
+	/* SAVING & LOADING */
+	public abstract void readFromNBT(NBTTagCompound nbttagcompound);
+
+	public abstract void writeToNBT(NBTTagCompound nbttagcompound);
+
+	public abstract EntityItem toEntityItem(ForgeDirection dir);
+
+	public abstract float getEntityBrightness(float f);
+
+	public abstract boolean isCorrupted();
+
+	public abstract void addContribution(String key, IPassiveItemContribution contribution);
+
+	public abstract IPassiveItemContribution getContribution(String key);
+
+	public abstract boolean hasContributions();
+
+}

src/minecraft/buildcraft/api/transport/ISolidSideTile.java

@@ -0,0 +1,7 @@
+package buildcraft.api.transport;
+
+import net.minecraftforge.common.ForgeDirection;
+
+public interface ISolidSideTile {
+	public boolean isSolidOnSide(ForgeDirection side);
+}

src/minecraft/buildcraft/api/transport/PipeManager.java

@@ -0,0 +1,37 @@
+package buildcraft.api.transport;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.world.World;
+
+public abstract class PipeManager {
+
+	public static List<IExtractionHandler> extractionHandlers = new ArrayList<IExtractionHandler>();
+
+	public static void registerExtractionHandler(IExtractionHandler handler) {
+		extractionHandlers.add(handler);
+	}
+
+	/**
+	 * param extractor can be null
+	 */
+	public static boolean canExtractItems(Object extractor, World world, int i, int j, int k) {
+		for (IExtractionHandler handler : extractionHandlers)
+			if (!handler.canExtractItems(extractor, world, i, j, k))
+				return false;
+
+		return true;
+	}
+	
+	/**
+	 * param extractor can be null
+	 */
+	public static boolean canExtractLiquids(Object extractor, World world, int i, int j, int k) {
+		for (IExtractionHandler handler : extractionHandlers)
+			if (!handler.canExtractLiquids(extractor, world, i, j, k))
+				return false;
+
+		return true;
+	}
+}

src/minecraft/dan200/computer/api/ComputerCraftAPI.java

@@ -0,0 +1,91 @@
+/**
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+
+package dan200.computer.api;
+import java.lang.reflect.Method;
+
+/**
+ * The static entry point to the ComputerCraft API.
+ * Members in this class must be called after mod_ComputerCraft has been initialised,
+ * but may be called before it is fully loaded.
+ */
+public class ComputerCraftAPI 
+{
+	/**
+	 * Get the creative mode tab that ComputerCraft items can be found on.
+	 * Use this to add your peripherals to ComputerCraft's tab.
+	 */
+	public static net.minecraft.creativetab.CreativeTabs getCreativeTab()
+	{
+		findCC();
+		if (computerCraft_getCreativeTab != null)
+		{
+			try {
+				return (net.minecraft.creativetab.CreativeTabs)( computerCraft_getCreativeTab.invoke(null) );
+			} catch (Exception e){
+				// It failed
+			}
+		}
+		return null;	
+	}
+	
+	/**
+	 * Registers a peripheral handler for a TileEntity that you do not have access to. Only
+	 * use this if you want to expose IPeripheral on a TileEntity from another mod. For your own
+	 * mod, just implement IPeripheral on the TileEntity directly.
+	 * @see IPeripheral
+	 * @see IPeripheralHandler
+	 */
+	public static void registerExternalPeripheral( Class <? extends net.minecraft.tileentity.TileEntity> clazz, IPeripheralHandler handler )
+	{
+		findCC();
+		if (computerCraft_registerExternalPeripheral != null)
+		{
+			try {
+				computerCraft_registerExternalPeripheral.invoke(null, clazz, handler);
+			} catch (Exception e){
+				// It failed
+			}
+		}
+	}
+
+	// The functions below here are private, and are used to interface with the non-API ComputerCraft classes.
+	// Reflection is used here so you can develop your mod in MCP without decompiling ComputerCraft and including
+	// it in your solution.
+	
+	private static void findCC()
+	{
+		if( !ccSearched ) {
+			try {
+				computerCraft = Class.forName( "dan200.ComputerCraft" );
+				computerCraft_getCreativeTab = findCCMethod( "getCreativeTab", new Class[] { } );
+				computerCraft_registerExternalPeripheral = findCCMethod( "registerExternalPeripheral", new Class[] { 
+					Class.class, IPeripheralHandler.class 
+				} );
+			} catch( Exception e ) {
+				System.out.println("ComputerCraftAPI: ComputerCraft not found.");
+			} finally {
+				ccSearched = true;
+			}
+		}
+	}
+
+	private static Method findCCMethod( String name, Class[] args )
+	{
+		try {
+			return computerCraft.getMethod( name, args );
+			
+		} catch( NoSuchMethodException e ) {
+			System.out.println("ComputerCraftAPI: ComputerCraft method " + name + " not found.");
+			return null;
+		}
+	}	
+	
+	private static boolean ccSearched = false;	
+	private static Class computerCraft = null;
+	private static Method computerCraft_registerExternalPeripheral = null;
+	private static Method computerCraft_getCreativeTab = null;
+}

src/minecraft/dan200/computer/api/IComputerAccess.java

@@ -0,0 +1,126 @@
+/**
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+
+package dan200.computer.api;
+
+/**
+ * The interface passed to peripherals by computers or turtles, providing methods
+ * that they can call. This should not be implemented by your classes. Do not interact
+ * with computers except via this interface.
+ */
+public interface IComputerAccess
+{
+	/**
+	 * Creates a new numbered directory in a subPath of the users game save, and return that number. To be used with mountSaveDir.<br>
+	 * For example: n = createNewSaveDir( "computer/cdrom" ), will create a new
+	 * numbered folder in the "computer/cdrom" subdirectory of the users save file, and return that number.
+	 * mountSaveDir( "computer/rom", n ) could then be used to mount that folder onto the computers directory
+	 * structure, and the value n could be saved out and used again in future to give the peripheral
+	 * persistant storage.
+	 * @param 	subPath		A relative file path from the users world save, where the directory should be located.
+	 * @return	The numeric represenation of the name of the folder created. Will be positive.
+	 * @see 	#mountSaveDir(String, String, int, boolean, long)
+	 */
+	public int createNewSaveDir( String subPath );
+	
+	/**
+	 * Mounts a directory into the computers file system, from a real directory a subPath of the users game save,
+	 * with a numerical name. To be used with createNewSaveDir.<br>
+	 * For example: n = createNewSaveDir( "computer/cdrom" ), will create a new
+	 * numbered folder in the "computer/cdrom" subdirectory of the users save file, and return that number.
+	 * mountSaveDir( "computer/rom", n ) could then be used to mount that folder onto the computers directory
+	 * structure, and the value n can be saved out by the peripheral and used again, to give the peripheral
+	 * persistant storage.<br>
+	 * When a directory is mounted, it will appear in the computers file system, and the user will be
+	 * able to use file operation to read from and write to the directory (unless readOnly, then only writes will be allowed).
+	 * @param desiredLocation	The desired location in the computers file system where you would like the directory to appear.
+	 *							If this location already exists, a number will be appended until a free name is found, and the
+	 *							actual location will be returned. eg: "cdrom" can become "cdrom2" if two peripherals attempt to
+	 *							mount "cdrom", or a "cdrom" folder already exists.
+	 * @param subPath			The real relative file path from the users world save, where the directory to mount can be located.
+	 * @param id				The numerical name of the folder to mount from the subPath: ex: mountSaveDir( "cdrom", "computer/cdrom", 7 )
+	 *							will mount the directory "computer/cdrom/7". Use createNewSaveDir to obtain a unique directory id.
+	 * @param readOnly			Whether the computer will be disallowed from making changes to the mounted directory and modifing or creating files therin.
+	 * @param spaceLimit		The size limit of the mount, in bytes. Specify 0 to have unlimited capacity.
+	 * @return					The location in the computers file system where the directory was mounted. This may differ from "desiredLocation", so the
+	 *							return value should be kept track of so the folder can be unmounted later.
+	 * @see	#createNewSaveDir(String)
+	 * @see	#mountFixedDir(String, String, boolean, long)
+	 * @see	#unmount(String)
+	 */
+	public String mountSaveDir( String desiredLocation, String subPath, int id, boolean readOnly, long spaceLimit );
+	
+	/**
+	 * Mounts a directory into the computers file system, from a real directory in the Minecraft install folder.<br>
+	 * For example: mountFixedDir( "stuff", "mods/mymod/lua/stuff", true ), will mount the "lua/stuff" folder from
+	 * your mod's directory into the computers filesystem at the location "stuff", with readonly permission, giving the
+	 * computer access to those files.<br>
+	 * When a directory is mounted, it will appear in the computers file system, and the user will be
+	 * able to use file operation to read from and write to the directory (unless readOnly, then only writes will be allowed).<br>
+	 * mountFixedDir can also be used to mount files, for example: mountFixedDir( "rom/apis/myapi", "mods/mymod/lua/myapi.lua", true ) can
+	 * be used to have the peripheral install an API onto the computer it attaches to.
+	 * @param desiredLocation	The desired location in the computers file system where you would like the directory to appear.
+	 *							If this location already exists, a number will be appended until a free name is found, and the
+	 *							actual location will be returned. eg: "cdrom" can become "cdrom2" if two peripherals attempt to
+	 *							mount "cdrom", or a "cdrom" folder already exists.
+	 * @param subPath			The real relative file path from the minecraft install root, where the directory to mount can be located.
+	 * @param readOnly			Whether the computer will be disallowed from making changes to the mounted directory and modifing or creating files therin.
+	 * @param spaceLimit		The size limit of the mount, in bytes. Specify 0 to have unlimited capacity.
+	 * @return					The location in the computers file system where the directory was mounted. This may differ from "desiredLocation", so the
+	 *							return value should be kept track of so the folder can be unmounted later.
+	 * @see	#mountSaveDir(String, String, int, boolean, long)
+	 * @see	#unmount(String)
+	 */
+	public String mountFixedDir( String desiredLocation, String path, boolean readOnly, long spaceLimit );
+
+	/**
+	 * Unmounts a directory previously mounted onto the computers file system by mountSaveDir or mountFixedDir.<br>
+	 * When a directory is unmounted, it will disappear from the computers file system, and the user will no longer be able to
+	 * access it. All directories mounted by a mountFixedDir or mountSaveDir are automatically unmounted when the peripheral
+	 * is attached if they have not been explicitly unmounted.
+	 * @param location	The desired location in the computers file system of the directory to unmount.
+	 *					This must be the location of a directory previously mounted by mountFixedDir() or mountSaveDir(), as
+	 *					indicated by their return value.
+	 * @see	#mountSaveDir(String, String, int, boolean, long)
+	 * @see	#mountFixedDir(String, String, boolean, long)
+	 */
+	public void unmount( String location );
+	
+	/**
+	 * Returns the numerical ID of this computer.<br>
+	 * This is the same number obtained by calling os.getComputerID() or running the "id" program from lua,
+	 * and is guarunteed unique. This number will be positive.
+	 * @return	The identifier.
+	 */
+	public int getID();	
+
+	/**
+	 * Causes an event to be raised on this computer, which the computer can respond to by calling
+	 * os.pullEvent(). This can be used to notify the computer when things happen in the world or to
+	 * this peripheral.
+	 * @param event		A string identifying the type of event that has occurred, this will be
+	 *					returned as the first value from os.pullEvent(). It is recommended that you
+	 *					you choose a name that is unique, and recognisable as originating from your 
+	 *					peripheral. eg: If your peripheral type is "button", a suitable event would be
+	 *					"button_pressed".
+	 * @param arguments	In addition to a name, you may pass an array of extra arguments to the event, that will
+	 *					be supplied as extra return values to os.pullEvent(). Objects in the array will be converted
+	 *					to lua data types in the same fashion as the return values of IPeripheral.callMethod().<br>
+	 *					You may supply null to indicate that no arguments are to be supplied.
+	 * @see IPeripheral#callMethod
+	 */
+	public void queueEvent( String event, Object[] arguments );
+
+	/**
+	 * Get a string, unique to the computer, by which the computer refers to this peripheral.
+	 * For directly attached peripherals this will be "left","right","front","back",etc, but
+	 * for peripherals attached remotely it will be different. It is good practice to supply
+	 * this string when raising events to the computer, so that the computer knows from
+	 * which peripheral the event came.
+	 * @return A string unique to the computer, but not globally.
+	 */
+	public String getAttachmentName();
+}

src/minecraft/dan200/computer/api/IHostedPeripheral.java

@@ -0,0 +1,44 @@
+/**
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+
+package dan200.computer.api;
+import dan200.computer.api.IPeripheral;
+
+/**
+ * A subclass of IPeripheral specifically for peripherals
+ * created by ITurtleUpgrade's of type Peripheral. When an
+ * IHostedPeripheral is created, its IPeripheral methods will be called
+ * just as if the peripheral was a seperate adjacent block in the world,
+ * and update() will be called once per tick.
+ * @see ITurtleUpgrade
+ */
+public interface IHostedPeripheral extends IPeripheral
+{
+	/**
+	 * A method called on each hosted peripheral once per tick, on the main thread
+	 * over the lifetime of the turtle or block. May be used to update the state 
+	 * of the peripheral, and may interact with IComputerAccess or ITurtleAccess
+	 * however it likes at this time.
+	 */
+	public void update();
+	
+	/**
+	 * A method called whenever data is read from the Turtle's NBTTag,
+	 * over the lifetime of the turtle. You should only use this for 
+	 * reading data you want to stay with the peripheral.
+	 * @param nbttagcompound	The peripheral's NBTTag
+	 */
+	public void readFromNBT( net.minecraft.nbt.NBTTagCompound nbttagcompound );
+	
+	/**
+	 * A method called whenever data is written to the Turtle's NBTTag,
+	 * over the lifetime of the turtle. You should only use this for 
+	 * writing data you want to stay with the peripheral.
+	 * @param nbttagcompound	The peripheral's NBTTag.
+	 * @param ID				The turtle's ID.
+	 */
+	public void writeToNBT( net.minecraft.nbt.NBTTagCompound nbttagcompound );
+}

src/minecraft/dan200/computer/api/IMedia.java

@@ -0,0 +1,21 @@
+/**
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+
+package dan200.computer.api;
+
+/**
+ * TODO: Document me
+ */
+public interface IMedia
+{
+	public String getLabel( net.minecraft.item.ItemStack stack );
+	public boolean setLabel( net.minecraft.item.ItemStack stack, String label );
+	
+	public String getAudioTitle( net.minecraft.item.ItemStack stack );
+	public String getAudioRecordName( net.minecraft.item.ItemStack stack );	
+    
+    public String mountData( net.minecraft.item.ItemStack stack, IComputerAccess computer );
+}

src/minecraft/dan200/computer/api/IPeripheral.java

@@ -0,0 +1,104 @@
+/**
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+
+package dan200.computer.api;
+
+/**
+ * The interface that defines a peripheral. This should be implemented by the
+ * TileEntity of any block that you wish to be interacted with by
+ * computer or turtle.
+ */
+public interface IPeripheral
+{
+	/**
+	 * Should return a string that uniquely identifies this type of peripheral.
+	 * This can be queried from lua by calling peripheral.getType()
+	 * @return 	A string identifying the type of peripheral.
+	 */
+    public String getType();
+    
+	/**
+	 * Should return an array of strings that identify the methods that this 
+	 * peripheral exposes to Lua. This will be called once before each attachment,
+	 * and should not change when called multiple times.
+	 * @return 	An array of strings representing method names.
+	 * @see 	#callMethod
+	 */
+    public String[] getMethodNames();
+    
+	/**
+	 * This is called when a lua program on an attached computer calls peripheral.call() with
+	 * one of the methods exposed by getMethodNames().<br>
+	 * <br>
+	 * Be aware that this will be called from the ComputerCraft Lua thread, and must be thread-safe
+	 * when interacting with minecraft objects.
+	 * @param 	computer	The interface to the computer that is making the call. Remember that multiple
+	 *						computers can be attached to a peripheral at once.
+	 * @param	method		An integer identifying which of the methods from getMethodNames() the computer
+	 *						wishes to call. The integer indicates the index into the getMethodNames() table
+	 *						that corresponds to the string passed into peripheral.call()
+	 * @param	arguments	An array of objects, representing the arguments passed into peripheral.call().<br>
+	 *						Lua values of type "string" will be represented by Object type String.<br>
+	 *						Lua values of type "number" will be represented by Object type Double.<br>
+	 *						Lua values of type "boolean" will be represented by Object type Boolean.<br>
+	 *						Lua values of any other type will be represented by a null object.<br>
+	 *						This array will be empty if no arguments are passed.
+	 * @return 	An array of objects, representing values you wish to return to the lua program.<br>
+	 *			Integers, Doubles, Floats, Strings, Booleans and null be converted to their corresponding lua type.<br>
+	 *			All other types will be converted to nil.<br>
+	 *			You may return null to indicate no values should be returned.
+	 * @throws	Exception	If you throw any exception from this function, a lua error will be raised with the
+	 *						same message as your exception. Use this to throw appropriate errors if the wrong
+	 *						arguments are supplied to your method.
+	 * @see 	#getMethodNames
+	 */
+    public Object[] callMethod( IComputerAccess computer, int method, Object[] arguments ) throws Exception;
+    
+	/**
+	 * Is called before the computer attempts to attach to the peripheral, and should return whether to allow
+	 * the attachment. Use this to restrict the number of computers that can attach, or to limit attachments to
+	 * certain world directions.<br>
+	 * If true is returned, attach() will be called shortly afterwards, and the computer will be able to make method calls.
+	 * If false is returned, attach() will not be called, and the peripheral will be invisible to the computer.
+	 * @param 	side		The world direction (0=bottom, 1=top, etc) that the computer lies relative to the peripheral.
+	 * @return	Whether to allow the attachment, as a boolean.
+	 * @see 	#attach
+	 */
+    public boolean canAttachToSide( int side );
+
+	/**
+	 * Is called when canAttachToSide has returned true, and a computer is attaching to the peripheral.
+	 * This will occur when a peripheral is placed next to an active computer, when a computer is turned on next to a peripheral,
+	 * or when a turtle travels into a square next to a peripheral.
+	 * Between calls to attach() and detach(), the attached computer can make method calls on the peripheral using peripheral.call().
+	 * This method can be used to keep track of which computers are attached to the peripheral, or to take action when attachment
+	 * occurs.<br>
+	 * <br>
+	 * Be aware that this will be called from the ComputerCraft Lua thread, and must be thread-safe
+	 * when interacting with minecraft objects.
+	 * @param 	computer		The interface to the computer that is being attached. Remember that multiple
+	 *							computers can be attached to a peripheral at once.
+	 * @see		#canAttachToSide
+	 * @see		#detach
+	 */
+    public void attach( IComputerAccess computer );
+
+	/**
+	 * Is called when a computer is detaching from the peripheral.
+	 * This will occur when a computer shuts down, when the peripheral is removed while attached to computers,
+	 * or when a turtle moves away from a square attached to a peripheral.
+	 * This method can be used to keep track of which computers are attached to the peripheral, or to take action when detachment
+	 * occurs.<br>
+	 * <br>
+	 * Be aware that this will be called from the ComputerCraft Lua thread, and must be thread-safe
+	 * when interacting with minecraft objects.
+	 * @param 	computer		The interface to the computer that is being detached. Remember that multiple
+	 *							computers can be attached to a peripheral at once.
+	 * @see		#canAttachToSide
+	 * @see		#detach
+	 */
+    public void detach( IComputerAccess computer );
+}

src/minecraft/dan200/computer/api/IPeripheralHandler.java

@@ -0,0 +1,15 @@
+/**
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+
+package dan200.computer.api;
+
+/**
+ * TODO: Document me
+ */
+public interface IPeripheralHandler 
+{
+	public IHostedPeripheral getPeripheral( net.minecraft.tileentity.TileEntity tile );
+}

src/minecraft/dan200/turtle/api/ITurtleAccess.java

@@ -0,0 +1,158 @@
+/**
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+
+package dan200.turtle.api;
+import dan200.computer.api.*;
+
+/**
+ * The interface passed to upgrades by turtles, providing methods that they can call.
+ * This should not be implemented by your classes. Do not interact with turtles except via this interface and ITurtleUpgrade.
+ */
+public interface ITurtleAccess
+{
+	/**
+	 * Returns the world in which the turtle resides.
+	 * @return the world in which the turtle resides.
+	 */
+	public net.minecraft.world.World getWorld();
+
+	/**
+	 * Returns a vector containing the integer block co-ordinates at which the turtle resides.
+	 * @return a vector containing the integer block co-ordinates at which the turtle resides.
+	 */
+	public net.minecraft.util.Vec3 getPosition();
+
+	/**
+	 * Returns a vector containing the co-ordinates at which the turtle is rendered.
+	 * This will shift when the turtle is moving.
+	 * @param f The subframe fraction
+	 * @return a vector containing the integer block co-ordinates at which the turtle resides.
+	 */
+	public net.minecraft.util.Vec3 getVisualPosition( float f );
+
+	/**
+	 * Returns the world direction the turtle is currently facing.
+	 * @return the world direction the turtle is currently facing.
+	 */
+	public int getFacingDir();
+	
+	/**
+	 * Returns the size of the turtles inventory, in number of slots. This will currently always be 16.
+	 * @return the size of the turtles inventory, in number of slots. This will currently always be 16.
+	 */
+	public int getInventorySize();
+
+	/**
+	 * Returns which slot the turtle currently has selected in its inventory using turtle.select().
+	 * Unlike the 1-based lua representation, this will be between 0 and getInventorySize() - 1.
+	 * @return which slot the turtle currently has selected in its inventory
+	 */
+	public int getSelectedSlot();
+	
+	/**
+	 * Returns the item stack that the turtle has in one of its inventory slots.
+	 * @param index which inventory slot to retreive, should be between 0 and getInventorySize() - 1
+	 * @return the item stack that the turtle has in one of its inventory slots. May be null.
+	 */
+	public net.minecraft.item.ItemStack getSlotContents( int index );
+
+	/**
+	 * Changes the item stack that the turtle has in one of its inventory slots.
+	 * @param index which inventory slot to change, should be between 0 and getInventorySize() - 1
+	 * @param stack an item stack to put in the slot. May be null.
+	 */
+	public void setSlotContents( int index, net.minecraft.item.ItemStack stack );
+	
+	/**
+	 * Tries to store an item stack into the turtles current inventory, starting from the turtles
+	 * currently selected inventory slot.
+	 * @param stack The item stack to try and store.
+	 * @return true if the stack was completely stored in the inventory, false if 
+	 * it was only partially stored, or could not fit at all. If false is returned
+	 * and the stack was partially stored, the ItemStack passed into "stack" will now
+	 * represent the stack of items that is left over.
+	 */
+	public boolean storeItemStack( net.minecraft.item.ItemStack stack );
+
+	/**
+	 * Drops an item stack from the turtle onto the floor, or into an inventory is there is one
+	 * adjacent to the turtle in the direction specified.
+	 * @param stack The item stack to drop.
+	 * @param dir The world direction to drop the item
+	 * @return true if the stack was dropped, or completely stored in the adjacent inventory, false if 
+	 * it was only partially stored in the adjacent inventory, or could not fit at all. If false is returned
+	 * and the stack was partially stored, the ItemStack passed into "stack" will now
+	 * represent the stack of items that is left over.
+	 */
+	public boolean dropItemStack( net.minecraft.item.ItemStack stack, int dir );
+	
+	/**
+	 * "Deploys" an item stack in the direction specified. This simulates a player right clicking, and calls onItemUse() on the Item class.
+	 * Will return true if some kind of deployment happened, and may modify the item stack. For block item types, this can be
+	 * used to place blocks. Some kinds of items (such as shears when facing a sheep) may modify the turtles inventory during this call.
+	 * @param stack The item stack to deploy
+	 * @param dir The world direction to deploy the item
+	 * @return true if the stack was deployed, false if it was not.
+	 */
+	public boolean deployWithItemStack( net.minecraft.item.ItemStack stack, int dir );
+
+	/**
+	 * Tries to "attack" entities with an item stack in the direction specified. This simulates a player left clicking, but will
+	 * not affect blocks. If an entity is attacked and killed during this call, its dropped items will end up in the turtles
+	 * inventory.
+	 * @param stack The item stack to attack with
+	 * @param dir The world direction to attack with the item
+	 * @return true if something was attacked, false if it was not
+	 */
+	public boolean attackWithItemStack( net.minecraft.item.ItemStack stack, int dir, float damageMultiplier );
+
+	/**
+	 * Returns the current fuel level of the turtle, this is the same integer returned by turtle.getFuelLevel(),
+	 * that decreases by 1 every time the turtle moves. Can be used to have your tool or peripheral require or supply 
+	 * fuel to the turtle.
+	 * @return the fuel level
+	 */
+	public int getFuelLevel();
+
+	/**
+	 * Tries to increase the fuel level of a turtle by burning an item stack. If the item passed in is a fuel source, fuel
+	 * will increase and true will be returned. Otherwise, nothing will happen and false will be returned.
+	 * @param stack The stack to try to refuel with
+	 * @return Whether the turtle was refueled
+	 */
+	public boolean refuelWithItemStack( net.minecraft.item.ItemStack stack );
+	
+	/**
+	 * Removes some fuel from the turtles fuel supply. Negative numbers can be passed in to INCREASE the fuel level of the turtle.
+	 * @return Whether the turtle was able to consume the ammount of fuel specified. Will return false if you supply a number
+	 * greater than the current fuel level of the turtle.
+	 */
+	public boolean consumeFuel( int fuel );
+	
+	/**
+	 * Adds a custom command to the turtles command queue. Unlike peripheral methods, these custom commands will be executed
+	 * on the main thread, so are guaranteed to be able to access Minecraft objects safely, and will be queued up
+	 * with the turtles standard movement and tool commands. An issued command will return an unique integer, which will
+	 * be supplied as a parameter to a "turtle_response" event issued to the turtle after the command has completed. Look at the 
+	 * lua source code for "rom/apis/turtle" for how to build a lua wrapper around this functionality.
+	 * @param handler an object which will execute the custom command when its point in the queue is reached
+	 * @return the unique command identifier described above
+	 * @see ITurtleCommandHandler
+	 */
+	public int issueCommand( ITurtleCommandHandler handler );
+	
+	/**
+	 * Returns the upgrade on the specified side of the turtle, if there is one.
+	 * @return the upgrade on the specified side of the turtle, if there is one.
+	 */
+	public ITurtleUpgrade getUpgrade( TurtleSide side );
+
+	/**
+	 * Returns the peripheral created by the upgrade on the specified side of the turtle, if there is one.
+	 * @return the peripheral created by the upgrade on the specified side of the turtle, if there is one.
+	 */
+	public IHostedPeripheral getPeripheral( TurtleSide side );
+}

src/minecraft/dan200/turtle/api/ITurtleCommandHandler.java

@@ -0,0 +1,25 @@
+/**
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+
+package dan200.turtle.api;
+
+/**
+ * An interface for objects executing custom turtle commands, used with ITurtleAccess.issueCommand
+ * @see ITurtleAccess#issueCommand( ITurtleCommandHandler )
+ */
+public interface ITurtleCommandHandler
+{
+	/**
+	 * Will be called by the turtle on the main thread when it is time to execute the custom command.
+	 * The handler should either perform the work of the command, and return true for success, or return
+	 * false to indicate failure if the command cannot be executed at this time.
+	 * @param turtle access to the turtle for whom the command was issued
+	 * @return true for success, false for failure. If true is returned, the turtle will wait 0.4 seconds
+	 * before executing the next command in its queue, as it does for the standard turtle commands.
+ 	 * @see ITurtleAccess#issueCommand( ITurtleCommandHandler )
+	 */
+	public boolean handleCommand( ITurtleAccess turtle );
+}

src/minecraft/dan200/turtle/api/ITurtleUpgrade.java

@@ -0,0 +1,92 @@
+/**
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+
+package dan200.turtle.api;
+import net.minecraft.util.Icon;
+import dan200.computer.api.*;
+
+/**
+ * The primary interface for defining an upgrade for Turtles. A turtle upgrade
+ * can either be a new tool, or a new peripheral.
+ * @see TurtleAPI#registerUpgrade( ITurtleUpgrade )
+ */
+public interface ITurtleUpgrade
+{
+	/**
+	 * Gets a unique numerical identifier representing this type of turtle upgrade.
+	 * Like Minecraft block and item IDs, you should strive to make this number unique
+	 * among all turtle upgrades that have been released for ComputerCraft.
+	 * The ID must be in the range 64 to 255, as the ID is stored as an 8-bit value,
+	 * and 0-64 is reserved for future use by ComputerCraft. The upgrade will
+	 * fail registration if an already used ID is specified.
+	 * @see TurtleAPI#registerUpgrade( ITurtleUpgrade )
+	 */
+	public int getUpgradeID();
+	
+	/**
+	 * Return a String to describe this type of upgrade in turtle item names.
+	 * Examples of built-in adjectives are "Wireless", "Mining" and "Crafty".
+	 */	
+	public String getAdjective();
+
+	/**
+	 * Return whether this upgrade adds a tool or a peripheral to the turtle.
+	 * Currently, turtle crafting is restricted to one tool & one peripheral per turtle.
+	 * @see TurtleUpgradeType for the differences between the two.
+	 */	
+	public TurtleUpgradeType getType();
+	
+	/**
+	 * Return an item stack representing the type of item that a turtle must be crafted
+	 * with to create a turtle which holds this upgrade.
+	 * Currently, turtle crafting is restricted to one tool & one peripheral per turtle.
+	 */		
+	public net.minecraft.item.ItemStack getCraftingItem();
+
+	/**
+	 * Return whether this turtle upgrade is an easter egg, and should be attempted to be hidden
+	 * from the creative mode inventory and recipe book plugins.
+	 */		
+	public boolean isSecret();
+	
+	/**
+	 * Will only be called for Peripheral upgrades. Creates a peripheral for a turtle
+	 * being placed using this upgrade. The peripheral created will be stored
+	 * for the lifetime of the turtle, will have update() called once-per-tick, and will be
+	 * attach'd detach'd and have methods called in the same manner as a Computer peripheral.
+	 * @param turtle Access to the turtle that the peripheral is being created for.
+	 * @param side Which side of the turtle (left or right) that the upgrade resides on.
+	 * @returns The newly created peripheral. You may return null if this upgrade is a Tool
+	 * and this method is not expected to be called.
+	 */		
+	public IHostedPeripheral createPeripheral( ITurtleAccess turtle, TurtleSide side );
+
+	/**
+	 * Will only be called for Tool upgrades. Called when turtle.dig() or turtle.attack() is called
+	 * by the turtle, and the tool is required to do some work.
+	 * @param turtle Access to the turtle that the tool resides on.
+	 * @param side Which side of the turtle (left or right) the tool resides on.
+	 * @param verb Which action (dig or attack) the turtle is being called on to perform.
+	 * @param direction Which world direction the action should be performed in, relative to the turtles
+	 * position. This will either be up, down, or the direction the turtle is facing, depending on
+	 * whether dig, digUp or digDown was called.
+	 * @return Whether the turtle was able to perform the action, and hence whether the turtle.dig()
+	 * or turtle.attack() lua method should return true. If true is returned, the tool will perform
+	 * a swinging animation. You may return false if this upgrade is a Peripheral
+	 * and this method is not expected to be called.
+	 */
+	public boolean useTool( ITurtleAccess turtle, TurtleSide side, TurtleVerb verb, int direction );
+
+	/**
+	 * Called to obtain the Icon to be used when rendering a turtle peripheral. Needs to be a "block" 
+	 * type Icon for now, as there is no way to determine which texture sheet an Icon is from by the 
+	 * Icon itself.
+	 * @param turtle Access to the turtle that the peripheral resides on.
+	 * @param side Which side of the turtle (left or right) the peripheral resides on.
+	 * @return The Icon that you wish to be used to render your turtle peripheral.
+	 */
+	public Icon getIcon( ITurtleAccess turtle, TurtleSide side );
+}

src/minecraft/dan200/turtle/api/TurtleAPI.java

@@ -0,0 +1,78 @@
+/**
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+
+package dan200.turtle.api;
+import java.lang.reflect.Method;
+
+/**
+ * The static entry point to the ComputerCraft Turtle Upgrade API.
+ * Members in this class must be called after mod_CCTurtle has been initialised,
+ * but may be called before it is fully loaded.
+ */
+public class TurtleAPI
+{
+	/**
+	 * Registers a new turtle upgrade for use in ComputerCraft. After calling this,
+	 * users should be able to craft Turtles with your new upgrade. It is recommended to call
+	 * this during the load() method of your mod.
+	 * @throws Exception if you try to register an upgrade with an already used or reserved upgradeID
+	 * @see ITurtleUpgrade
+	 */
+	public static void registerUpgrade( ITurtleUpgrade upgrade )
+	{
+		if( upgrade != null )
+		{
+			findCCTurtle();
+			if( ccTurtle_registerTurtleUpgrade != null )
+			{
+				try {
+					ccTurtle_registerTurtleUpgrade.invoke( null, new Object[]{ upgrade } );
+				} catch( Exception e ) {
+					// It failed
+				}
+			}
+		}
+	}
+	
+	// The functions below here are private, and are used to interface with the non-API ComputerCraft classes.
+	// Reflection is used here so you can develop your mod in MCP without decompiling ComputerCraft and including
+	// it in your solution.
+	 
+	private static void findCCTurtle()
+	{
+		if( !ccTurtleSearched ) {
+			// Search for CCTurtle
+			try {
+				ccTurtle = Class.forName( "dan200.CCTurtle" );
+				ccTurtle_registerTurtleUpgrade = findCCTurtleMethod( "registerTurtleUpgrade", new Class[] {
+					ITurtleUpgrade.class
+				} );				
+				
+			} catch( ClassNotFoundException e ) {
+				System.out.println("ComputerCraftAPI: CCTurtle not found.");
+
+			} finally {
+				ccTurtleSearched = true;
+			
+			}
+		}
+	}
+	
+	private static Method findCCTurtleMethod( String name, Class[] args )
+	{
+		try {
+			return ccTurtle.getMethod( name, args );
+			
+		} catch( NoSuchMethodException e ) {
+			System.out.println("ComputerCraftAPI: CCTurtle method " + name + " not found.");
+			return null;
+		}
+	}	
+	
+	private static boolean ccTurtleSearched = false;	
+	private static Class ccTurtle = null;
+	private static Method ccTurtle_registerTurtleUpgrade = null;
+}

src/minecraft/dan200/turtle/api/TurtleSide.java

@@ -0,0 +1,23 @@
+/**
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+
+package dan200.turtle.api;
+
+/**
+ * An enum representing the two sides of the turtle that a turtle upgrade might reside.
+ */
+public enum TurtleSide
+{
+	/**
+	 * The turtles left side (where the pickaxe usually is on a Wireless Mining Turtle)
+	 */
+	Left,
+
+	/**
+	 * The turtles right side (where the modem usually is on a Wireless Mining Turtle)
+	 */
+	Right,
+}

src/minecraft/dan200/turtle/api/TurtleUpgradeType.java

@@ -0,0 +1,27 @@
+/**
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+
+package dan200.turtle.api;
+
+/**
+ * An enum representing the two different types of upgrades that an ITurtleUpgrade
+ * implementation can add to a turtle.
+ * @see ITurtleUpgrade
+ */
+public enum TurtleUpgradeType
+{
+	/**
+	 * A tool is rendered as an item on the side of the turtle, and responds to the turtle.dig()
+	 * and turtle.attack() methods (Such as pickaxe or sword on Mining and Melee turtles).
+	 */
+	Tool,
+	
+	/**
+	 * A peripheral adds a special peripheral which is attached to the side of the turtle,
+	 * and can be interacted with the peripheral API (Such as the modem on Wireless Turtles).
+	 */
+	Peripheral,
+}

src/minecraft/dan200/turtle/api/TurtleVerb.java

@@ -0,0 +1,26 @@
+/**
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+
+package dan200.turtle.api;
+
+/**
+ * An enum representing the two different actions that an ITurtleUpgrade of type
+ * Tool may be called on to perform by a turtle.
+ * @see ITurtleUpgrade
+ * @see ITurtleUpgrade#useTool
+ */
+public enum TurtleVerb
+{
+	/**
+	 * The turtle called turtle.dig(), turtle.digUp() or turtle.digDown()
+	 */
+	Dig,
+	
+	/**
+	 * The turtle called turtle.attack(), turtle.attackUp() or turtle.attackDown()
+	 */
+	Attack,
+}

src/minecraft/ic2/api/BaseSeed.java

@@ -0,0 +1,56 @@
+package ic2.api;
+
+/**
+ * Base agriculture seed. Used to determine the state of a plant once it is planted from an item.
+ */
+public class BaseSeed {
+	/**
+	 * Plant ID.
+	 */
+	public int id;
+	
+	/**
+	 * Plant size.
+	 */
+	public int size;
+	
+	/**
+	 * Plant growth stat.
+	 */
+	public int statGrowth;
+	
+	/**
+	 * Plant gain stat.
+	 */
+	public int statGain;
+	
+	/**
+	 * Plant resistance stat.
+	 */
+	public int statResistance;
+	
+	/**
+	 * For internal usage only.
+	 */
+	public int stackSize;
+	
+	/**
+	 * Create a BaseSeed object.
+	 * 
+	 * @param id plant ID
+	 * @param size plant size
+	 * @param statGrowth plant growth stat
+	 * @param statGain plant gain stat
+	 * @param statResistance plant resistance stat
+	 * @param stackSize for internal usage only
+	 */
+	public BaseSeed(int id, int size, int statGrowth, int statGain, int statResistance, int stackSize) {
+		super();
+		this.id = id;
+		this.size = size;
+		this.statGrowth = statGrowth;
+		this.statGain = statGain;
+		this.statResistance = statResistance;
+		this.stackSize = stackSize;
+	}
+}

src/minecraft/ic2/api/CropCard.java

@@ -0,0 +1,523 @@
+package ic2.api;
+
+import java.util.HashMap;
+
+import net.minecraft.client.renderer.texture.IconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.Icon;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+/**
+ * Base agriculture crop.
+ * 
+ * Any crop extending this can be registered using registerCrop to be added into the game.
+ */
+public abstract class CropCard
+{
+	/**
+	 * Plant name. Will be displayed to the player.
+	 * 
+	 * @return Plant name
+	 */
+	public abstract String name();
+
+	/**
+	 * Your name here, will be shown in "Discovered by:" when analyzing seeds.
+	 * 
+	 * @return Your name
+	 */
+	public String discoveredBy() {return "Alblaka";}
+
+	/**
+	 * Description of your plant. Keep it short, a few characters per line for up to two lines.
+	 * Default is showing attributes of your plant, 2 per line.
+	 * 
+	 * @param i line to get, starting from 0
+	 * @return The line
+	 */
+	public String desc(int i)
+	{
+		String[] att = attributes();
+		if (att == null || att.length==0) return "";
+		if (i == 0)
+		{
+			String s = att[0];
+			if (att.length >= 2)
+			{
+				s+=", "+att[1];
+				if (att.length >= 3) s+=",";
+			}
+			return s;
+		}
+		else
+		{
+			if (att.length < 3) return "";
+			String s = att[2];
+			if (att.length >= 4) s+=", "+att[3];
+			return s;
+		}
+	}
+
+	/**
+	 * Tier of the plant. Ranges from 1 to 16, 0 is Weed.
+	 * Valuable and powerful crops have higher tiers, useless and weak ones have lower tiers.
+	 * 
+	 * @return Tier
+	 */
+	public abstract int tier();
+
+	/**
+	 * Describe the plant through a set of stats, influencing breeding.
+	 * Plants sharing stats and attributes will tend to cross-breed more often.
+	 * 
+	 * Stats:
+	 * - 0: Chemistry (Industrial uses based on chemical plant components)
+	 * - 1: Consumable (Food, potion ingredients, stuff meant to be eaten or similarly used)
+	 * - 2: Defensive (Plants with defense capabilities (damaging, explosive, chemical) or special abilities in general)
+	 * - 3: Colorful (How colorful/aesthetically/beautiful is the plant, like dye-plants or plants without actual effects)
+	 * - 4: Weed (Is this plant weed-like and rather unwanted/quick-spreading? Rare super-breed plants should have low values here)
+	 * 
+	 * @param n index of the requested stat
+	 * @return The requested value of the stats
+	 */
+	public abstract int stat(int n);
+
+	/**
+	 * Additional attributes of the plant, also influencing breeding.
+	 * Plants sharing stats and attributes will tend to cross-breed more often.
+	 * 
+	 * @return Attributes as an array of strings
+	 */
+	public abstract String[] attributes();
+
+	/**
+	 * Determine the max crop size.
+	 * 
+	 * Currently only used for texture allocation.
+	 */
+	public abstract int maxSize();
+
+	/**
+	 * Instantiate your Icons here.
+	 * 
+	 * This method will get called by IC2, don't call it yourself.
+	 */
+	@SideOnly(Side.CLIENT)
+	public void registerSprites(IconRegister iconRegister) {
+		textures = new Icon[maxSize()];
+
+		for (int i = 1; i <= textures.length; i++) {
+			textures[i-1] = iconRegister.registerIcon("ic2:crop/blockCrop."+name()+"."+i);
+		}
+	}
+
+	/**
+	 * Sprite the crop is meant to be rendered with.
+	 * 
+	 * @param crop reference to TECrop
+	 * @return 0-255, representing the sprite index on the crop's spritesheet.
+	 */
+	@SideOnly(Side.CLIENT)
+	public Icon getSprite(TECrop crop) {
+		if (crop.size <= 0 || crop.size > textures.length) return null;
+
+		return textures[crop.size - 1];
+	}
+
+	/**
+	 * Get the crop's spritesheet.
+	 * Per default crops_0.png of ic2-sprites
+	 * @return Texture file path
+	 */
+	public String getTextureFile() {
+		return "/ic2/sprites/crops_0.png";
+	}
+
+	/**
+	 * Amount of growth points needed to increase the plant's size.
+	 * Default is 200 * tier.
+	 */
+	public int growthDuration(TECrop crop)
+	{
+		return tier()*200;
+	}
+
+	/**
+	 * Check whether the plant can grow further.
+	 * 
+	 * Consider:
+	 * - Humidity, nutrients and air quality
+	 * - Current size
+	 * - Light level
+	 * - Special biomes or conditions, accessible through crop.worldObj
+	 * 
+	 * This method will be called upon empty upgraded crops to check whether a neighboring plant can cross onto it! Don't check if the size is greater than 0 and if the ID is real.
+	 * 
+	 * @param crop reference to TECrop
+	 * @return Whether the crop can grow
+	 */
+	public abstract boolean canGrow(TECrop crop);
+
+	/**
+	 * Calculate the influence for the plant to grow based on humidity, nutrients and air.
+	 * Normal behavior is rating the three stats "normal", with each of them ranging from 0-30.
+	 * Basic rule: Assume everything returns 10. All together must equal 30. Add the factors to your likings, for example (humidity*0.7)+(nutrients*0.9)+(air*1.4)
+	 * 
+	 * Default is humidity + nutrients + air (no factors).
+	 * 
+	 * @param crop reference to TECrop
+	 * @param humidity ground humidity, influenced by hydration
+	 * @param nutrients nutrient quality in ground, based on fertilizers
+	 * @param air air quality, influences by open gardens and less crops surrounding this one
+	 * @return 0-30
+	 */
+	public int weightInfluences(TECrop crop, float humidity, float nutrients, float air)
+	{
+		return (int) (humidity+nutrients+air);
+	}
+
+	/**
+	 * Used to determine whether the plant can crossbreed with another crop.
+	 * Default is allow crossbreeding if the size is greater or equal than 3.
+	 * 
+	 * @param crop crop to crossbreed with
+	 */
+	public boolean canCross(TECrop crop)
+	{
+		return crop.size >= 3;
+	}
+
+
+	/**
+	 * Called when the plant is rightclicked by a player.
+	 * Default action is harvesting.
+	 * 
+	 * @param crop reference to TECrop
+	 * @param player player rightclicking the crop
+	 * @return Whether the plant has changed
+	 */
+	public boolean rightclick(TECrop crop, EntityPlayer player)
+	{
+		return crop.harvest(true);
+	}
+
+	/**
+	 * Check whether the crop can be harvested.
+	 * 
+	 * @param crop reference to TECrop
+	 * @return Whether the crop can be harvested in its current state.
+	 */
+	public abstract boolean canBeHarvested(TECrop crop);
+
+	/**
+	 * Base chance for dropping the plant's gains, specify values greater than 1 for multiple drops.
+	 * Default is 0.95^tier.
+	 * 
+	 * @return Chance to drop the gains
+	 */
+	public float dropGainChance()
+	{
+		float base = 1F;
+		for (int i = 0; i < tier(); i++) {base*=0.95;}
+		return base;
+	}
+
+	/**
+	 * Item obtained from harvesting the plant.
+	 * 
+	 * @param crop reference to TECrop
+	 * @return Item obtained
+	 */
+	public abstract ItemStack getGain(TECrop crop);
+
+	/**
+	 * Get the size of the plant after harvesting.
+	 * Default is 1.
+	 * 
+	 * @param crop reference to TECrop
+	 * @return Plant size after harvesting
+	 */
+	public byte getSizeAfterHarvest(TECrop crop) {return 1;}
+
+
+	/**
+	 * Called when the plant is leftclicked by a player.
+	 * Default action is picking the plant.
+	 * 
+	 * @param crop reference to TECrop
+	 * @param player player leftclicked the crop
+	 * @return Whether the plant has changed
+	 */
+	public boolean leftclick(TECrop crop, EntityPlayer player)
+	{
+		return crop.pick(true);
+	}
+
+	/**
+	 * Base chance for dropping seeds when the plant is picked.
+	 * Default is 0.5*0.8^tier with a bigger chance for sizes greater than 2 and absolutely no chance for size 0.
+	 * 
+	 * @param crop reference to TECrop
+	 * @return Chance to drop the seeds
+	 */
+	public float dropSeedChance(TECrop crop)
+	{
+		if (crop.size == 1) return 0;
+		float base = 0.5F;
+		if (crop.size == 2) base/=2F;
+		for (int i = 0; i < tier(); i++) {base*=0.8;}
+		return base;
+	}
+
+	/**
+	 * Obtain seeds dropped when the plant is picked.
+	 * Multiple drops of the returned ItemStack can occur.
+	 * Default action is generating a seed from this crop.
+	 * 
+	 * @param crop reference to TECrop
+	 * @return Seeds
+	 */
+	public ItemStack getSeeds(TECrop crop)
+	{
+		return crop.generateSeeds(crop.id, crop.statGrowth, crop.statGain, crop.statResistance, crop.scanLevel);
+	}
+
+	/**
+	 * Called when a neighbor block to the crop has changed.
+	 * 
+	 * @param crop reference to TECrop
+	 */
+	public void onNeighbourChange(TECrop crop){}
+
+	/**
+	 * Check if the crop should emit redstone.
+	 * 
+	 * @return Whether the crop should emit redstone
+	 */
+	public int emitRedstone(TECrop crop){return 0;}
+
+	/**
+	 * Called when the crop is destroyed.
+	 * 
+	 * @param crop reference to TECrop
+	 */
+	public void onBlockDestroyed(TECrop crop){}
+
+	/**
+	 * Get the light value emitted by the plant.
+	 * 
+	 * @param crop reference to TECrop
+	 * @return Light value emitted
+	 */
+	public int getEmittedLight(TECrop crop) {return 0;}
+
+	/**
+	 * Default is true if the entity is an EntityLiving in jumping or sprinting state.
+	 * 
+	 * @param crop reference to TECrop
+	 * @param entity entity colliding
+	 * @return Whether trampling calculation should happen, return false if the plant is no longer valid.
+	 */
+	public boolean onEntityCollision(TECrop crop, Entity entity)
+	{
+		if (entity instanceof EntityLiving)
+		{
+			return ((EntityLiving)entity).isSprinting();
+		}
+		return false;
+	}
+
+
+	/**
+	 * Called every time the crop ticks.
+	 * Should be called every 256 ticks or around 13 seconds.
+	 * 
+	 * @param crop reference to TECrop
+	 */
+	public void tick(TECrop crop) {}
+
+	/**
+	 * Check whether this plant spreads weed to surrounding tiles.
+	 * Default is true if the plant has a high growth stat (or is weeds) and size greater or equal than 2.
+	 * 
+	 * @param crop reference to TECrop
+	 * @return Whether the plant spreads weed
+	 */
+	public boolean isWeed(TECrop crop)
+	{
+		return crop.size>=2 && (crop.id==0 || crop.statGrowth>=24);
+	}
+
+
+	/**
+	 * Get this plant's ID.
+	 * 
+	 * @return ID of this CropCard or -1 if it's not registered
+	 */
+	public final int getId()
+	{
+		for (int i = 0; i < cropCardList.length; i++)
+		{
+			if (this == cropCardList[i])
+			{
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	private static final CropCard[] cropCardList = new CropCard[256];
+
+	/**
+	 * Get the size of the plant list.
+	 * 
+	 * @return Plant list size
+	 */
+	public static int cropCardListLength() {return cropCardList.length;}
+
+	/**
+	 * Return the CropCard assigned to the given ID.
+	 * If the ID is out of bounds, weed should be returned. If the ID is not registered, weed should be returned and a console print will notify.
+	 * 
+	 * @param id plant ID
+	 * @return Plant class
+	 */
+	public static final CropCard getCrop(int id)
+	{
+		if (id < 0 || id >= cropCardList.length)
+		{// Out of bounds
+			return cropCardList[0];
+		}
+		if (cropCardList[id]==null)
+		{// Out of bounds
+			System.out.println("[IndustrialCraft] Something tried to access non-existant cropID #"+id+"!!!");
+			return cropCardList[0];
+		}
+
+		return cropCardList[id];
+	}
+
+	/**
+	 * Check whether the specified plant ID is already assigned.
+	 * @param id ID to be checked
+	 * @return true if the the given id is inbounds and the registered slot is not null
+	 */
+	public static final boolean idExists(int id)
+	{
+		return !(id < 0 || id >= cropCardList.length || cropCardList[id]==null);
+	}
+
+	/**
+	 * Auto-assign an ID to a plant and register it.
+	 * Usage of this method is not recommended! Other plants could take your IDs and cause your plants to turn into other plants.
+	 * 
+	 * @param crop plant to register
+	 * @return The ID assigned to the plant
+	 */
+	public static final short registerCrop(CropCard crop)
+	{
+		for (short x = 0; x < cropCardList.length; x++)
+		{// Iterate through list
+			if (cropCardList[x]==null)
+			{// Found empty slot, add crop here
+				cropCardList[x]=crop;
+				nameReference.addLocal("ic2.cropSeed"+x, crop.name()+" Seeds");
+				return x;
+			}
+		}
+		//No free slot avaible
+		return -1;
+	}
+
+	/**
+	 * Attempt to register a plant to an ID.
+	 * If the ID is taken, the crop will not be registered and a console print will notify the user.
+	 * 
+	 * @param crop plant to register
+	 * @param i ID to register the plant to
+	 * @return Whether the crop was registered
+	 */
+	public static final boolean registerCrop(CropCard crop, int i)
+	{
+		if (i < 0 || i >= cropCardList.length)
+		{// Out of bounds
+			return false;
+		}
+		if (cropCardList[i]==null)
+		{
+			cropCardList[i]=crop;
+			nameReference.addLocal("ic2.cropSeed"+i, crop.name()+" Seeds");
+			return true;
+		}
+		System.out.println("[IndustrialCraft] Cannot add crop:"+crop.name()+" on ID #"+i+", slot already occupied by crop:"+cropCardList[i].name());
+		return false;
+	}
+
+	/**
+	 * For internal usage only.
+	 */
+	public static TECrop nameReference;
+
+	private static HashMap<ItemStack, BaseSeed> baseseeds = new HashMap<ItemStack, BaseSeed>();
+
+	/**
+	 * Registers a base seed, an item used to plant a crop.
+	 * 
+	 * @param stack item
+	 * @param id plant ID
+	 * @param size initial size
+	 * @param growth initial growth stat
+	 * @param gain initial gain stat
+	 * @param resistance initial resistance stat
+	 * @return True if successful
+	 */
+	public static boolean registerBaseSeed(ItemStack stack, int id, int size, int growth, int gain, int resistance)
+	{
+		for (ItemStack key : baseseeds.keySet())
+			if (key.itemID==stack.itemID && key.getItemDamage()==stack.getItemDamage()) return false;
+
+		baseseeds.put(stack, new BaseSeed(id, size, growth, gain, resistance, stack.stackSize));
+		return true;
+	}
+
+	/**
+	 * Finds a base seed from the given item.
+	 * 
+	 * @return Base seed or null if none found
+	 */
+	public static BaseSeed getBaseSeed(ItemStack stack)
+	{
+		if (stack == null) return null;
+		for (ItemStack key : baseseeds.keySet())
+		{
+			if (key.itemID == stack.itemID &&
+					(key.getItemDamage() == -1 || key.getItemDamage() == stack.getItemDamage()))
+			{
+				return baseseeds.get(key);
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Execute registerSprites for all registered crop cards.
+	 * 
+	 * This method will get called by IC2, don't call it yourself.
+	 */
+	@SideOnly(Side.CLIENT)
+	public static final void startSpriteRegistration(IconRegister iconRegister) {
+		for (CropCard cropCard : cropCardList) {
+			if (cropCard == null) break;
+
+			cropCard.registerSprites(iconRegister);
+		}
+	}
+
+	@SideOnly(Side.CLIENT)
+	protected Icon textures[];
+}

src/minecraft/ic2/api/Crops.java

@@ -0,0 +1,47 @@
+package ic2.api;
+
+import java.util.HashMap;
+
+import net.minecraft.world.biome.BiomeGenBase;
+
+/**
+ * General management of the crop system. All crop management methods will be moved here in the 2.00 update.
+ */
+public class Crops {
+	private static final HashMap<BiomeGenBase,Integer> humidityBiomeBonus = new HashMap<BiomeGenBase,Integer>();
+	private static final HashMap<BiomeGenBase,Integer> nutrientBiomeBonus = new HashMap<BiomeGenBase,Integer>();
+	
+	/**
+	 * Add a crop humidity and nutrient biome bonus.
+	 * 
+	 * 0 indicates no bonus and negative values indicate a penalty.
+	 * 
+	 * @param biome Biome to apply the bonus in
+	 * @param humidityBonus Humidity stat bonus
+	 * @param nutrientsBonus Nutrient stat bonus
+	 */
+	public static void addBiomeBonus(BiomeGenBase biome, int humidityBonus, int nutrientsBonus) {
+		humidityBiomeBonus.put(biome, humidityBonus);
+		nutrientBiomeBonus.put(biome, nutrientsBonus);
+	}
+	
+	/**
+	 * Get the humidity bonus for a biome. 
+	 * 
+	 * @param biome biome to check
+	 * @return Humidity bonus or 0 if none
+	 */
+	public static int getHumidityBiomeBonus(BiomeGenBase biome) {
+		return humidityBiomeBonus.containsKey(biome) ? humidityBiomeBonus.get(biome) : 0;
+	}
+	
+	/**
+	 * Get the nutrient bonus for a biome. 
+	 * 
+	 * @param biome biome to check
+	 * @return Nutrient bonus or 0 if none
+	 */
+	public static int getNutrientBiomeBonus(BiomeGenBase biome) {
+		return nutrientBiomeBonus.containsKey(biome) ? nutrientBiomeBonus.get(biome) : 0;
+	}
+}

src/minecraft/ic2/api/Direction.java

@@ -0,0 +1,107 @@
+package ic2.api;
+
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.ForgeDirection;
+
+/**
+ * Represents the 6 possible directions along the axis of a block.
+ */
+public enum Direction {
+	/**
+	 * -X
+	 */
+	XN(0),
+	/**
+	 * +X
+	 */
+	XP(1),
+	
+	/**
+	 * -Y
+	 */
+	YN(2), //MC-Code starts with 0 here
+	/**
+	 * +Y
+	 */
+	YP(3), // 1...
+	
+	/**
+	 * -Z
+	 */
+	ZN(4),
+	/**
+	 * +Z
+	 */
+	ZP(5);
+	
+	Direction(int dir) {
+		this.dir = dir;
+	}
+	
+	/*public CoordinateTuple ApplyToCoordinates(CoordinateTuple coordinates) {
+		CoordinateTuple ret = new CoordinateTuple(coordinates);
+		
+		ret.coords[dir/2] += GetSign();
+		
+		return ret;
+	}*/
+	
+	/**
+	 * Get the tile entity next to a tile entity following this direction.
+	 *
+	 * @param tileEntity tile entity to check
+	 * @return Adjacent tile entity or null if none exists
+	 */
+	public TileEntity applyToTileEntity(TileEntity tileEntity) {
+		int coords[] = { tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord };
+		
+		coords[dir/2] += getSign();
+		
+		if (tileEntity.worldObj != null && tileEntity.worldObj.blockExists(coords[0], coords[1], coords[2])) {
+			return tileEntity.worldObj.getBlockTileEntity(coords[0], coords[1], coords[2]);
+		} else {
+			return null;
+		}
+	}
+	
+	/**
+	 * Get the inverse of this direction (XN -> XP, XP -> XN, etc.)
+	 * 
+	 * @return Inverse direction
+	 */
+	public Direction getInverse() {
+		int inverseDir = dir - getSign();
+		
+		for (Direction direction : directions) {
+			if (direction.dir == inverseDir) return direction;
+		}
+		
+		return this;
+	}
+	
+	/**
+	 * Convert this direction to a Minecraft side value.
+	 * 
+	 * @return Minecraft side value
+	 */
+	public int toSideValue() {
+		return (dir + 4) % 6;
+	}
+	
+	/**
+	 * Determine direction sign (N for negative or P for positive).
+	 *
+	 * @return -1 if the direction is negative, +1 if the direction is positive
+	 */
+	private int getSign() {
+		return (dir % 2) * 2 - 1;
+	}
+	
+	public ForgeDirection toForgeDirection() {
+		return ForgeDirection.getOrientation(toSideValue());
+	}
+	
+	private int dir;
+	private static final Direction[] directions = Direction.values();
+}
+

src/minecraft/ic2/api/ElectricItem.java

@@ -0,0 +1,128 @@
+package ic2.api;
+
+import java.lang.reflect.Method;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+
+/**
+ * Allows for charging, discharging and using electric items (IElectricItem).
+ *
+ * The charge or remaining capacity of an item can be determined by calling charge/discharge with
+ * ignoreTransferLimit and simulate set to true.
+ */
+public final class ElectricItem {
+	/**
+	 * Charge an item with a specified amount of energy
+	 *
+	 * @param itemStack electric item's stack
+	 * @param amount amount of energy to charge in EU
+	 * @param tier tier of the charging device, has to be at least as high as the item to charge
+	 * @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit()
+	 * @param simulate don't actually change the item, just determine the return value
+	 * @return Energy transferred into the electric item
+	 */
+	public static int charge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate) {
+		try {
+			if (ElectricItem_charge == null) ElectricItem_charge = Class.forName(getPackage() + ".core.item.ElectricItem").getMethod("charge", ItemStack.class, Integer.TYPE, Integer.TYPE, Boolean.TYPE, Boolean.TYPE);
+
+			return (Integer) ElectricItem_charge.invoke(null, itemStack, amount, tier, ignoreTransferLimit, simulate);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	/**
+	 * Discharge an item by a specified amount of energy
+	 *
+	 * @param itemStack electric item's stack
+	 * @param amount amount of energy to charge in EU
+	 * @param tier tier of the discharging device, has to be at least as high as the item to discharge
+	 * @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit()
+	 * @param simulate don't actually discharge the item, just determine the return value
+	 * @return Energy retrieved from the electric item
+	 */
+	public static int discharge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate) {
+		try {
+			if (ElectricItem_discharge == null) ElectricItem_discharge = Class.forName(getPackage() + ".core.item.ElectricItem").getMethod("discharge", ItemStack.class, Integer.TYPE, Integer.TYPE, Boolean.TYPE, Boolean.TYPE);
+
+			return (Integer) ElectricItem_discharge.invoke(null, itemStack, amount, tier, ignoreTransferLimit, simulate);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	/**
+	 * Determine if the specified electric item has at least a specific amount of EU.
+	 * This is supposed to be used in the item code during operation, for example if you want to implement your own electric item.
+	 * BatPacks are not taken into account.
+	 *
+	 * @param itemStack electric item's stack
+	 * @param amount minimum amount of energy required
+	 * @return true if there's enough energy
+	 */
+	public static boolean canUse(ItemStack itemStack, int amount) {
+		try {
+			if (ElectricItem_canUse == null) ElectricItem_canUse = Class.forName(getPackage() + ".core.item.ElectricItem").getMethod("canUse", ItemStack.class, Integer.TYPE);
+
+			return (Boolean) ElectricItem_canUse.invoke(null, itemStack, amount);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	/**
+	 * Try to retrieve a specific amount of energy from an Item, and if applicable, a BatPack.
+	 * This is supposed to be used in the item code during operation, for example if you want to implement your own electric item.
+	 *
+	 * @param itemStack electric item's stack
+	 * @param amount amount of energy to discharge in EU
+	 * @param player player holding the item
+	 * @return true if the operation succeeded
+	 */
+	public static boolean use(ItemStack itemStack, int amount, EntityPlayer player) {
+		try {
+			if (ElectricItem_use == null) ElectricItem_use = Class.forName(getPackage() + ".core.item.ElectricItem").getMethod("use", ItemStack.class, Integer.TYPE, EntityPlayer.class);
+
+			return (Boolean) ElectricItem_use.invoke(null, itemStack, amount, player);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	/**
+	 * Charge an item from the BatPack a player is wearing.
+	 * This is supposed to be used in the item code during operation, for example if you want to implement your own electric item.
+	 * use() already contains this functionality.
+	 *
+	 * @param itemStack electric item's stack
+	 * @param player player holding the item
+	 */
+	public static void chargeFromArmor(ItemStack itemStack, EntityPlayer player) {
+		try {
+			if (ElectricItem_chargeFromArmor == null) ElectricItem_chargeFromArmor = Class.forName(getPackage() + ".core.item.ElectricItem").getMethod("chargeFromArmor", ItemStack.class, EntityPlayer.class);
+
+			ElectricItem_chargeFromArmor.invoke(null, itemStack, player);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	/**
+	 * Get the base IC2 package name, used internally.
+	 *
+	 * @return IC2 package name, if unable to be determined defaults to ic2
+	 */
+	private static String getPackage() {
+		Package pkg = ElectricItem.class.getPackage();
+		if (pkg != null) return pkg.getName().substring(0, pkg.getName().lastIndexOf('.'));
+		else return "ic2";
+	}
+
+	private static Method ElectricItem_charge;
+	private static Method ElectricItem_discharge;
+	private static Method ElectricItem_canUse;
+	private static Method ElectricItem_use;
+	private static Method ElectricItem_chargeFromArmor;
+}
+

src/minecraft/ic2/api/ExplosionWhitelist.java

@@ -0,0 +1,46 @@
+package ic2.api;
+
+import java.util.*;
+
+import net.minecraft.block.Block;
+
+/**
+ * Blocks on this whitelist will not resist an explosion but won't be destroyed.
+ * 
+ * The explosion code by default ignores blocks which absorb more than 1000 explosion power to
+ * prevent abusing personal safes, Trade-O-Mats and other blocks to serve as a cheap and
+ * invulnerable reactor chambers. Said blocks will not shield the explosion and won't get
+ * destroyed.
+ */
+public final class ExplosionWhitelist {
+	/**
+	 * Add a block to the whitelist.
+	 * 
+	 * @param block block to add
+	 */
+	public static void addWhitelistedBlock(Block block) {
+		whitelist.add(block);
+	}
+	
+	/**
+	 * Remove a block from the whitelist.
+	 * 
+	 * @param block block to remove
+	 */
+	public static void removeWhitelistedBlock(Block block) {
+		whitelist.remove(block);
+	}
+	
+	/**
+	 * Check if a block is on the whitelist.
+	 * 
+	 * @param block block to check if whitelisted
+	 * @return Whether the block is whitelisted
+	 */
+	public static boolean isBlockWhitelisted(Block block) {
+		return whitelist.contains(block);
+	}
+
+	private static Set<Block> whitelist = new HashSet<Block>();
+}
+

src/minecraft/ic2/api/IBoxable.java

@@ -0,0 +1,18 @@
+package ic2.api;
+
+import net.minecraft.item.ItemStack;
+
+/**
+ * Provides custom toolbox storage behavior for items.
+ * 
+ * The normal condition for storing an item in a toolbox is having a maximum stack size of 1.
+ */
+public interface IBoxable {
+	/**
+	 * Determine whether an item can be stored in a toolbox or not.
+	 * 
+	 * @param itemstack item to be stored
+	 * @return Whether to store the item in the toolbox or not
+	 */
+	public abstract boolean canBeStoredInToolbox(ItemStack itemstack);
+}

src/minecraft/ic2/api/IC2Reactor.java

@@ -0,0 +1,28 @@
+package ic2.api;
+
+import java.lang.reflect.Field;
+
+public class IC2Reactor {
+	private static Field energyGeneratorNuclear;
+	
+	public static int getEUOutput() {
+		try {
+			if (energyGeneratorNuclear == null) energyGeneratorNuclear = Class.forName(getPackage() + ".core.IC2").getDeclaredField("energyGeneratorNuclear");
+		
+			return energyGeneratorNuclear.getInt(null);
+		} catch (Throwable e) {
+			throw new RuntimeException(e);
+		}
+	}
+	
+	/**
+	 * Get the base IC2 package name, used internally.
+	 * 
+	 * @return IC2 package name, if unable to be determined defaults to ic2
+	 */
+	private static String getPackage() {
+		Package pkg = IC2Reactor.class.getPackage();
+		if (pkg != null) return pkg.getName().substring(0, pkg.getName().lastIndexOf('.'));
+		else return "ic2";
+	}
+}

src/minecraft/ic2/api/ICustomElectricItem.java

@@ -0,0 +1,64 @@
+package ic2.api;
+
+import net.minecraft.item.ItemStack;
+
+/**
+ * Provides the ability to store energy on the implementing item.
+ *
+ * This interface is a special version of IElectricItem which delegates the implementation of
+ * charge(), discharge() and canUse() to the implementing Item.
+ *
+ * The default implementation (when not using ICustomElectricItem) does the following:
+ * - store and retrieve the charge
+ * - handle charging, taking amount, tier, transfer limit and simulate into account
+ * - replace item IDs if appropriate (getChargedItemId() and getEmptyItemId())
+ * - update and manage the damage value for the visual charge indicator
+ *
+ * @note ICustomElectricItem must not call the ElectricItem methods charge, discharge or canUse
+ */
+public interface ICustomElectricItem extends IElectricItem {
+	/**
+	 * Charge an item with a specified amount of energy
+	 *
+	 * @param itemStack electric item's stack
+	 * @param amount amount of energy to charge in EU
+	 * @param tier tier of the charging device, has to be at least as high as the item to charge
+	 * @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit()
+	 * @param simulate don't actually change the item, just determine the return value
+	 * @return Energy transferred into the electric item
+	 */
+	public int charge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate);
+
+	/**
+	 * Discharge an item by a specified amount of energy
+	 *
+	 * @param itemStack electric item's stack
+	 * @param amount amount of energy to charge in EU
+	 * @param tier tier of the discharging device, has to be at least as high as the item to discharge
+	 * @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit()
+	 * @param simulate don't actually discharge the item, just determine the return value
+	 * @return Energy retrieved from the electric item
+	 */
+	public int discharge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate);
+
+	/**
+	 * Determine if the specified electric item has at least a specific amount of EU.
+	 * This is supposed to be used in the item code during operation, for example if you want to implement your own electric item.
+	 * BatPacks are not taken into account.
+	 *
+	 * @param itemStack electric item's stack
+	 * @param amount minimum amount of energy required
+	 * @return true if there's enough energy
+	 */
+	public boolean canUse(ItemStack itemStack, int amount);
+
+	/**
+	 * Determine whether to show the charge tool tip with NEI or other means.
+	 *
+	 * Return false if IC2's handler is incompatible, you want to implement your own or you don't
+	 * want to display the charge at all.
+	 *
+	 * @return true to show the tool tip (x/y EU)
+	 */
+	public boolean canShowChargeToolTip(ItemStack itemStack);
+}

src/minecraft/ic2/api/IElectricItem.java

@@ -0,0 +1,54 @@
+package ic2.api;
+
+import net.minecraft.item.ItemStack;
+
+/**
+ * Provides the ability to store energy on the implementing item.
+ *
+ * The item should have a maximum damage of 13.
+ */
+public interface IElectricItem {
+	/**
+	 * Determine if the item can be used in a machine or as an armor part to supply energy.
+	 *
+	 * @return Whether the item can supply energy
+	 */
+	boolean canProvideEnergy(ItemStack itemStack);
+
+	/**
+	 * Get the item ID to use for a charge energy greater than 0.
+	 *
+	 * @return Item ID to use
+	 */
+	int getChargedItemId(ItemStack itemStack);
+
+	/**
+	 * Get the item ID to use for a charge energy of 0.
+	 *
+	 * @return Item ID to use
+	 */
+	int getEmptyItemId(ItemStack itemStack);
+
+	/**
+	 * Get the item's maximum charge energy in EU.
+	 *
+	 * @return Maximum charge energy
+	 */
+	int getMaxCharge(ItemStack itemStack);
+
+	/**
+	 * Get the item's tier, lower tiers can't send energy to higher ones.
+	 * Batteries are Tier 1, Energy Crystals are Tier 2, Lapotron Crystals are Tier 3.
+	 *
+	 * @return Item's tier
+	 */
+	int getTier(ItemStack itemStack);
+
+	/**
+	 * Get the item's transfer limit in EU per transfer operation.
+	 *
+	 * @return Transfer limit
+	 */
+	int getTransferLimit(ItemStack itemStack);
+}
+

src/minecraft/ic2/api/IEnergyStorage.java

@@ -0,0 +1,52 @@
+package ic2.api;
+
+/**
+ * Interface implemented by the tile entity of energy storage blocks.
+ */
+public interface IEnergyStorage {
+	/**
+	 * Get the amount of energy currently stored in the block.
+	 * 
+	 * @return Energy stored in the block
+	 */
+	public int getStored();
+	
+	/**
+	 * Set the amount of energy currently stored in the block.
+	 *  
+	 * @param energy stored energy
+	 */
+	public void setStored(int energy);
+	
+	/**
+	 * Add the specified amount of energy.
+	 * 
+	 * Use negative values to decrease.
+	 * 
+	 * @param amount of energy to add
+	 * @return Energy stored in the block after adding the specified amount
+	 */
+	public int addEnergy(int amount);
+	
+	/**
+	 * Get the maximum amount of energy the block can store.
+	 * 
+	 * @return Maximum energy stored
+	 */
+	public int getCapacity();
+	
+	/**
+	 * Get the block's energy output.
+	 * 
+	 * @return Energy output in EU/t
+	 */
+	public int getOutput();
+	
+	/**
+	 * Get whether this block can have its energy used by an adjacent teleporter.
+	 * 
+	 * @param side side the teleporter is draining energy from
+	 * @return Whether the block is teleporter compatible
+	 */
+	public boolean isTeleporterCompatible(Direction side);
+}

src/minecraft/ic2/api/IMetalArmor.java

@@ -0,0 +1,20 @@
+package ic2.api;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+
+/**
+ * Armor items implementing this can be considered metal armor.
+ * 
+ * Currently used for determining which boots can be used to slide up a magnetic pole.
+ */
+public interface IMetalArmor {
+	/**
+	 * Determine if the given armor piece is metal armor.
+	 * 
+	 * @param itemstack Armor piece as worn by the player
+	 * @param player The player
+	 * @return Whether the armor piece is metal armor
+	 */
+	public boolean isMetalArmor(ItemStack itemstack, EntityPlayer player);
+}

src/minecraft/ic2/api/IPaintableBlock.java

@@ -0,0 +1,21 @@
+package ic2.api;
+
+import net.minecraft.world.World;
+
+/**
+ * Allows a block to be painted by a Painter.
+ */
+public interface IPaintableBlock
+{
+	/**
+	 * Color the block.
+	 * 
+	 * @param world block's world
+	 * @param x block X position
+	 * @param y block Y position
+	 * @param z block Z position
+	 * @param color painter color, same as dye metadata values
+	 * @return Whether the block was painted and the painter should be damaged
+	 */
+	public boolean colorBlock(World world, int x, int y, int z, int color);
+}

src/minecraft/ic2/api/IReactor.java

@@ -0,0 +1,134 @@
+package ic2.api;
+
+import net.minecraft.util.ChunkCoordinates;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+/**
+ * Interface implemented by the tile entity of nuclear reactors.
+ */
+public interface IReactor {
+	/**
+	 * Get the reactor's position in the world.
+	 * 
+	 * @return Position of the reactor
+	 */
+	public ChunkCoordinates getPosition();
+	
+	/**
+	 * Get the reactor's corresponding world.
+	 * 
+	 * @return The reactor's world
+	 */
+	public World getWorld();
+	
+	/**
+	 * Get the reactor's heat.
+	 * 
+	 * @return The reactor's heat
+	 */
+	public int getHeat();
+	
+	/**
+	 * Set the reactor's heat.
+	 * 
+	 * @param heat reactor heat
+	 */
+	public void setHeat(int heat);
+	
+	/**
+	 * Increase the reactor's heat.
+	 * 
+	 * Use negative values to decrease.
+	 * 
+	 * @param amount amount of heat to add
+	 * @return The reactor's heat after adding the specified amount
+	 */
+	public int addHeat(int amount);
+	
+	/**
+	 * Get the reactor's maximum heat before exploding.
+	 * 
+	 * @return Maximum heat value
+	 */
+	public int getMaxHeat();
+	
+	/**
+	 * Set the reactor's stored maxHeat variable.
+	 * Used by plating to increase the reactors MaxHeat capacity.
+	 * Needs to be called during each cycle process.
+	 */
+	public void setMaxHeat(int newMaxHeat);
+	
+	/**
+	 * Get's the reactor's HEM (Heat Effect Modifier)
+	 * Basic value is 1.0F.
+	 * Reducing the value causes a weakening/reduction of the heat-based sideeffects of reactors
+	 * (F.e. water evaporation, melting, damaging entitys, etc)
+	 * 
+	 * @return HEM
+	 */
+	public float getHeatEffectModifier();
+	
+	/**
+	 * Set's the reactor's HEM
+	 * Needs to be called during each cycle process.
+	 */
+	public void setHeatEffectModifier(float newHEM);
+	
+	/**
+	 * Get the reactor's energy output.
+	 * 
+	 * @return Energy output, not multiplied by the base EU/t value
+	 */
+	public int getOutput();
+	
+	/**
+	 * Add's the given amount of energy to the Reactor's output.
+	 * 
+	 * @return Energy output after adding the value, not multiplied by the base EU/t value
+	 */
+	public int addOutput(int energy);
+	
+	/**
+	 * Replaced by IC2Reactor.getEUOutput() - stays at the universal output value of 1 for compatibility
+	 */
+	@Deprecated
+	public int getPulsePower();
+	
+	/**
+	 * Get the item at the specified grid coordinates.
+	 * 
+	 * @param x X position of the item
+	 * @param y Y position of the item
+	 * @return The item or null if there is no item
+	 */
+	public ItemStack getItemAt(int x, int y);
+	
+	/**
+	 * Set the item at the specified grid coordinates.
+	 * 
+	 * @param x X position of the item
+	 * @param y Y position of the item
+	 * @param item The item to set.
+	 */
+	public void setItemAt(int x, int y, ItemStack item);
+	
+	/**
+	 * Explode the reactor.
+	 */
+	public void explode();
+	
+	/**
+	 * Get the reactor's tick rate (game ticks per reactor tick).
+	 * 
+	 * @return Tick rate
+	 */
+	public int getTickRate();
+	
+	/**
+	 * Get whether the reactor is active and supposed to produce energy
+	 * @return Whether the reactor is active
+	 */
+	public boolean produceEnergy();
+}

src/minecraft/ic2/api/IReactorChamber.java

@@ -0,0 +1,13 @@
+package ic2.api;
+
+/**
+ * Interface implemented by the reactor chamber tile entity.
+ */
+public interface IReactorChamber {
+	/**
+	 * Get the chamber's reactor.
+	 * 
+	 * @return The reactor
+	 */
+	public IReactor getReactor();
+}

src/minecraft/ic2/api/IReactorComponent.java

@@ -0,0 +1,97 @@
+package ic2.api;
+
+import net.minecraft.item.ItemStack;
+
+/**
+ * Design custom Reactor components by implementing this Interface
+ * Items implementing the interface will not be ejected from Reactors in their clean-up
+ * and can/will be interacted with by other elements, f.e. Uranium Cells.
+ * 
+ * All IC2 ReactorComponents implement and use this Interface
+ *
+ */
+public interface IReactorComponent
+{
+	/**
+	 * Called by reactor upon iterating through it's inventory (every cycle).
+	 * Perform all necessary calculation/interaction here
+	 * 
+	 * @param reactor Reference to the Reactor
+	 * @param yourStack Reference to the specific instance of iterated ItemStack
+	 * @param x X-coordinate of the stack in the grid
+	 * @param y Y-coordinate of the stack in the grid
+	 */
+	public void processChamber(IReactor reactor, ItemStack yourStack, int x, int y);
+	
+	/**
+	 * Can be called by Uranium-Components who attempt to generate energy by pulsing to other components.
+	 * Uranium-Uranium interaction (f.e.) uses this method.
+	 * @param reactor Reference to the Reactor
+	 * @param yourStack Reference to the specific instance of called ItemStack
+	 * @param pulsingStack Reference to the specific instance of pulsing ItemStack
+	 * @param youX X-coordinate of your stack in the grid
+	 * @param youY Y-coordinate of your stack in the grid
+	 * @param pulseX X-coordinate of pulsing stack in the grid
+	 * @param pulseY Y-coordinate of pulsing stack in the grid
+	 * @return true if this component reacts to the pulse (and pulse is therefore meant to produce heat)
+	 */
+	public boolean acceptUraniumPulse(IReactor reactor, ItemStack yourStack, ItemStack pulsingStack, int youX, int youY, int pulseX, int pulseY);
+	
+	/**
+	 * Called by components to determine whether your component can be heated.
+	 * @param reactor Reference to the Reactor
+	 * @param yourStack Reference to the specific instance of iterated ItemStack
+	 * @param x X-coordinate of the stack in the grid
+	 * @param y Y-coordinate of the stack in the grid
+	 * @return true if your component can take heat
+	 */
+	public boolean canStoreHeat(IReactor reactor, ItemStack yourStack, int x, int y);
+	
+	/**
+	 * Called by heat-switches to determine how much heat to distribute into which direction.
+	 * Please return the maximum capacity of your heat-containing component here.
+	 * @param reactor Reference to the Reactor
+	 * @param yourStack Reference to the specific instance of iterated ItemStack
+	 * @param x X-coordinate of the stack in the grid
+	 * @param y Y-coordinate of the stack in the grid
+	 * @return Maximum heat
+	 */
+	public int getMaxHeat(IReactor reactor, ItemStack yourStack, int x, int y);
+	
+	/**
+	 * Called by heat-switches to determine how much heat to distribute into which direction.
+	 * Please return the current amount of heat stored in this component
+	 * @param reactor Reference to the Reactor
+	 * @param yourStack Reference to the specific instance of iterated ItemStack
+	 * @param x X-coordinate of the stack in the grid
+	 * @param y Y-coordinate of the stack in the grid
+	 * @return Current Heat
+	 */
+	public int getCurrentHeat(IReactor reactor, ItemStack yourStack, int x, int y);
+	
+	/**
+	 * Called by components to distribute heat to your component.
+	 * Perform heating-calculations and increase your heat (dmg) level accordingly.
+	 * This method will as well be called to REDUCE heat, by providing a negative amount.
+	 * 
+	 * @param reactor Reference to the Reactor
+	 * @param yourStack Reference to the specific instance of iterated ItemStack
+	 * @param x X-coordinate of the stack in the grid
+	 * @param y Y-coordinate of the stack in the grid
+	 * @param heat Amount of heat to be added (may be negative to subtract heat)
+	 * @return 0 if the 'order' was accepted, return >0 to indicate the 'remaining' heat which couldn't be absorbed (and vice versa for <0)
+	 */
+	public int alterHeat(IReactor reactor, ItemStack yourStack, int x, int y, int heat);
+	
+	/**
+	 * Called upon reactor explosion
+	 * Alter the explosion size.
+	 * Returning a float 0 < f < 1 will be counted as multiplier.
+	 * Anything else will be counted as a flat addition (in case of <0 = reduction).
+	 * 
+	 * @param reactor Reference to the Reactor
+	 * @param yourStack Reference to the specific instance of iterated ItemStack
+	 * @return your explosion modifier
+	 */
+	public float influenceExplosion(IReactor reactor, ItemStack yourStack);
+}

src/minecraft/ic2/api/ITerraformingBP.java

@@ -0,0 +1,35 @@
+package ic2.api;
+
+import net.minecraft.world.World;
+
+/**
+ * Allows an item to act as a terraformer blueprint.
+ */
+public interface ITerraformingBP
+{
+	/**
+	 * Get the energy consumption per operation of the blueprint.
+	 * 
+	 * @return Energy consumption in EU
+	 */
+	public abstract int getConsume();
+	
+	/**
+	 * Get the maximum range of the blueprint.
+	 * Should be a divisor of 5.
+	 * 
+	 * @return Maximum range in blocks
+	 */
+	public abstract int getRange();
+	
+	/**
+	 * Perform the terraforming operation.
+	 * 
+	 * @param world world to terraform
+	 * @param x X position to terraform
+	 * @param z Z position to terraform
+	 * @param yCoord Y position of the terraformer
+	 * @return Whether the operation was successful and the terraformer should consume energy.
+	 */
+	public abstract boolean terraform(World world, int x, int z, int yCoord);
+}

src/minecraft/ic2/api/IWrenchable.java

@@ -0,0 +1,59 @@
+package ic2.api;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+
+/**
+ * Allows a tile entity to make use of the wrench's removal and rotation functions.
+ */
+public interface IWrenchable {
+	/**
+	 * Determine if the wrench can be used to set the block's facing.
+	 * Called before wrenchCanRemove().
+	 * 
+	 * @param entityPlayer player using the wrench, may be null
+	 * @param side block's side the wrench was clicked on
+	 * @return Whether the wrenching was done and the wrench should be damaged
+	 */
+	boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side);
+
+	/**
+	 * Get the block's facing.
+	 * 
+	 * @return Block facing
+	 */
+	short getFacing();
+
+	/**
+	 * Set the block's facing
+	 * 
+	 * @param facing facing to set the block to
+	 */
+	void setFacing(short facing);
+
+	/**
+	 * Determine if the wrench can be used to remove the block.
+	 * Called if wrenchSetFacing fails.
+	 *
+	 * @param entityPlayer player using the wrench, may be null
+	 * @return Whether the wrenching was done and the wrench should be damaged
+	 */
+	boolean wrenchCanRemove(EntityPlayer entityPlayer);
+
+	/**
+	 * Determine the probability to drop the block as it is.
+	 * The first entry in getBlockDropped will be replaced by blockid:meta if the drop is successful.
+	 * 
+	 * @return Probability from 0 to 1
+	 */
+	float getWrenchDropRate();
+
+	/**
+	 * Determine the item the block will drop when the wrenching is successful.
+	 * 
+	 * @param entityPlayer player using the wrench, may be null
+	 * @return Item to drop
+	 */
+	ItemStack getWrenchDrop(EntityPlayer entityPlayer);
+}
+

src/minecraft/ic2/api/Ic2Recipes.java

@@ -0,0 +1,364 @@
+package ic2.api;
+
+import java.lang.reflect.Array;
+import java.util.AbstractMap;
+import java.util.List;
+import java.util.Map;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+
+/**
+ * Provides access to Compressor, Extractor and Macerator recipes, as well as charge-aware recipes
+ * and the Recycler blacklist.
+ *
+ * The recipes are only valid after IC2 has been loaded and are metadata and stack size sensitive,
+ * for example you can create a recipe to compress 3 wooden planks into 2 sticks.
+ */
+public final class Ic2Recipes {
+	/**
+	 * Add a charge-aware shaped crafting recipe.
+	 */
+	public static void addCraftingRecipe(ItemStack result, Object... args) {
+		try {
+			Class.forName(getPackage() + ".core.AdvRecipe").getMethod("addAndRegister", ItemStack.class, Array.newInstance(Object.class, 0).getClass()).invoke(null, result, args);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	/**
+	 * Add a charge-aware shapeless crafting recipe.
+	 */
+	public static void addShapelessCraftingRecipe(ItemStack result, Object... args) {
+		try {
+			Class.forName(getPackage() + ".core.AdvShapelessRecipe").getMethod("addAndRegister", ItemStack.class, Array.newInstance(Object.class, 0).getClass()).invoke(null, result, args);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	/**
+	 * Retrieve the registered Compressor recipes.
+	 *
+	 * @return Recipe list as a list of map entries, the key is the input and the value is the output
+	 */
+	@SuppressWarnings("unchecked")
+	public static List<Map.Entry<ItemStack, ItemStack> > getCompressorRecipes() {
+		if (TileEntityCompressor_recipes == null) {
+			try {
+				TileEntityCompressor_recipes = (List<Map.Entry<ItemStack, ItemStack> >) Class.forName(getPackage() + ".core.block.machine.tileentity.TileEntityCompressor").getField("recipes").get(null);
+			} catch (Exception e) {
+				throw new RuntimeException(e);
+			}
+		}
+
+		return TileEntityCompressor_recipes;
+	}
+
+	/**
+	 * Add a Compressor recipe.
+	 *
+	 * @param input Input
+	 * @param output Output
+	 */
+	public static void addCompressorRecipe(ItemStack input, ItemStack output) {
+		getCompressorRecipes().add(new AbstractMap.SimpleEntry<ItemStack, ItemStack>(input, output));
+	}
+
+
+	/**
+	 * Get the Compressor output for an input item.
+	 *
+	 * @param input input item
+	 * @param adjustInput remove the processing requirements from input
+	 * @return Output item as an independent stack
+	 */
+	public static ItemStack getCompressorOutputFor(ItemStack input, boolean adjustInput) {
+		return getOutputFor(input, adjustInput, getCompressorRecipes());
+	}
+
+	/**
+	 * Retrieve the registered Extractor recipes.
+	 *
+	 * @return Recipe list as a list of map entries, the key is the input and the value is the output
+	 */
+	@SuppressWarnings("unchecked")
+	public static List<Map.Entry<ItemStack, ItemStack> > getExtractorRecipes() {
+		if (TileEntityExtractor_recipes == null) {
+			try {
+				TileEntityExtractor_recipes = (List<Map.Entry<ItemStack, ItemStack> >) Class.forName(getPackage() + ".core.block.machine.tileentity.TileEntityExtractor").getField("recipes").get(null);
+			} catch (Exception e) {
+				throw new RuntimeException(e);
+			}
+		}
+
+		return TileEntityExtractor_recipes;
+	}
+
+	/**
+	 * Add a Extractor recipe.
+	 *
+	 * @param input Input
+	 * @param output Output
+	 */
+	public static void addExtractorRecipe(ItemStack input, ItemStack output) {
+		getExtractorRecipes().add(new AbstractMap.SimpleEntry<ItemStack, ItemStack>(input, output));
+	}
+
+
+	/**
+	 * Get the Extractor output for an input item.
+	 *
+	 * @param input input item
+	 * @param adjustInput remove the processing requirements from input
+	 * @return Output item as an independent stack
+	 */
+	public static ItemStack getExtractorOutputFor(ItemStack input, boolean adjustInput) {
+		return getOutputFor(input, adjustInput, getExtractorRecipes());
+	}
+
+	/**
+	 * Retrieve the registered Macerator recipes.
+	 *
+	 * @return Recipe list as a list of map entries, the key is the input and the value is the output
+	 */
+	@SuppressWarnings("unchecked")
+	public static List<Map.Entry<ItemStack, ItemStack> > getMaceratorRecipes() {
+		if (TileEntityMacerator_recipes == null) {
+			try {
+				TileEntityMacerator_recipes = (List<Map.Entry<ItemStack, ItemStack> >) Class.forName(getPackage() + ".core.block.machine.tileentity.TileEntityMacerator").getField("recipes").get(null);
+			} catch (Exception e) {
+				throw new RuntimeException(e);
+			}
+		}
+
+		return TileEntityMacerator_recipes;
+	}
+
+	/**
+	 * Add a Macerator recipe.
+	 *
+	 * @param input Input
+	 * @param output Output
+	 */
+	public static void addMaceratorRecipe(ItemStack input, ItemStack output) {
+		getMaceratorRecipes().add(new AbstractMap.SimpleEntry<ItemStack, ItemStack>(input, output));
+	}
+
+
+	/**
+	 * Get the Macerator output for an input item.
+	 *
+	 * @param input input item
+	 * @param adjustInput remove the processing requirements from input
+	 * @return Output item as an independent stack
+	 */
+	public static ItemStack getMaceratorOutputFor(ItemStack input, boolean adjustInput) {
+		return getOutputFor(input, adjustInput, getMaceratorRecipes());
+	}
+
+
+	private static ItemStack getOutputFor(ItemStack input, boolean adjustInput, List<Map.Entry<ItemStack, ItemStack> > recipeList) {
+		assert input != null;
+
+		for (Map.Entry<ItemStack, ItemStack> entry: recipeList) {
+			if (entry.getKey().isItemEqual(input) && input.stackSize >= entry.getKey().stackSize) {
+				if (adjustInput) input.stackSize -= entry.getKey().stackSize;
+
+				return entry.getValue().copy();
+			}
+		}
+
+		return null;
+	}
+
+
+	/**
+	 * Retrieve the registered Recycler blacklist items.
+	 *
+	 * @return Blacklist
+	 */
+	@SuppressWarnings("unchecked")
+	public static List<ItemStack> getRecyclerBlacklist() {
+		if (TileEntityRecycler_blacklist == null) {
+			try {
+				TileEntityRecycler_blacklist = (List<ItemStack>) Class.forName(getPackage() + ".core.block.machine.tileentity.TileEntityRecycler").getField("blacklist").get(null);
+			} catch (Exception e) {
+				throw new RuntimeException(e);
+			}
+		}
+
+		return TileEntityRecycler_blacklist;
+	}
+
+	/**
+	 * Add an item stack to the Recycler blacklist.
+	 *
+	 * @param newBlacklistedItem item stack to add
+	 */
+	public static void addRecyclerBlacklistItem(ItemStack newBlacklistedItem) {
+		getRecyclerBlacklist().add(newBlacklistedItem);
+	}
+
+	/**
+	 * Add an item to the Recycler blacklist.
+	 *
+	 * @param newBlacklistedItem item to add
+	 */
+	public static void addRecyclerBlacklistItem(Item newBlacklistedItem) {
+		addRecyclerBlacklistItem(new ItemStack(newBlacklistedItem, 1, -1));
+	}
+
+	/**
+	 * Add a block to the Recycler blacklist.
+	 *
+	 * @param newBlacklistedBlock block to add
+	 */
+	public static void addRecyclerBlacklistItem(Block newBlacklistedBlock) {
+		addRecyclerBlacklistItem(new ItemStack(newBlacklistedBlock, 1, -1));
+	}
+
+
+	/**
+	 * Determine if an item is in the Recycler blacklist.
+	 *
+	 * @param itemStack item to check
+	 * @return Whether the item is blacklisted or not
+	 */
+	public static boolean isRecyclerInputBlacklisted(ItemStack itemStack) {
+		for (ItemStack blackItem: getRecyclerBlacklist()) {
+			if (itemStack.isItemEqual(blackItem)) return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Retrieve the registered Scrap Box drops.
+	 *
+	 * @return Drops as a list of item stack and float (chance) pairs
+	 */
+	@SuppressWarnings("unchecked")
+	public static List<Map.Entry<ItemStack,Float>> getScrapboxDrops() {
+		try {
+			return (List<Map.Entry<ItemStack,Float>>) Class.forName(getPackage() + ".core.item.ItemScrapbox").getMethod("getDropList").invoke(null);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	/*
+	 * Reference scrap box chance values:
+	 *
+	 * 0.1: Diamond
+	 * 0.5: Cake, Gold Helmet, Iron Ore, Gold Ore
+	 * 1.0: Wooden tools, Soul Sand, Sign, Leather, Feather, Bone
+	 * 1.5: Apple, Bread
+	 * 2.0: Netherrack, Rotten Flesh
+	 * 3.0: Grass, Gravel
+	 * 4.0: Stick
+	 * 5.0: Dirt, Wooden Hoe
+	 */
+
+	/**
+	 * Add an item stack to the Scrap Box drops.
+	 *
+	 * @param dropItem item stack to add
+	 * @param chance chance for the item to drop, see the code comments for reference values
+	 */
+	public static void addScrapboxDrop(ItemStack dropItem, float chance) {
+		try {
+			Class.forName(getPackage() + ".core.item.ItemScrapbox").getMethod("addDrop", ItemStack.class, float.class).invoke(null, dropItem, chance);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	/**
+	 * Add an item to the Scrap Box drops.
+	 *
+	 * @param dropItem item to add
+	 * @param chance chance for the item to drop, see the code comments for reference values
+	 */
+	public static void addScrapboxDrop(Item dropItem, float chance) {
+		addScrapboxDrop(new ItemStack(dropItem, 1), chance);
+	}
+
+	/**
+	 * Add a block to the Scrap Box drops.
+	 *
+	 * @param dropItem item to add
+	 * @param chance chance for the item to drop, see the code comments for reference values
+	 */
+	public static void addScrapboxDrop(Block dropItem, float chance) {
+		addScrapboxDrop(new ItemStack(dropItem), chance);
+	}
+
+	/**
+	 * Retrieve the registered Mass Fabricator amplifiers.
+	 *
+	 * @return Amplifiers as a list of item stack and integer (amplifier value) pairs
+	 */
+	@SuppressWarnings("unchecked")
+	public static List<Map.Entry<ItemStack, Integer> > getMatterAmplifiers() {
+		if (TileEntityMatter_amplifiers == null) {
+			try {
+				TileEntityMatter_amplifiers = (List<Map.Entry<ItemStack, Integer> >) Class.forName(getPackage() + ".core.block.machine.tileentity.TileEntityMatter").getField("amplifiers").get(null);
+			} catch (Exception e) {
+				throw new RuntimeException(e);
+			}
+		}
+
+		return TileEntityMatter_amplifiers;
+	}
+
+	/**
+	 * Add an item stack to the Mass Fabricator amplifiers.
+	 *
+	 * @param amplifierItem item stack to add
+	 * @param value amplifier value for the item, scrap is 5000
+	 */
+	public static void addMatterAmplifier(ItemStack amplifierItem, int value) {
+		getMatterAmplifiers().add(new AbstractMap.SimpleEntry<ItemStack,Integer>(amplifierItem, value));
+	}
+
+	/**
+	 * Add an item to the Mass Fabricator amplifiers.
+	 *
+	 * @param amplifierItem item to add
+	 * @param value amplifier value for the item, scrap is 5000
+	 */
+	public static void addMatterAmplifier(Item amplifierItem, int value) {
+		addMatterAmplifier(new ItemStack(amplifierItem, 1, -1), value);
+	}
+
+	/**
+	 * Add a block to the Mass Fabricator amplifiers.
+	 *
+	 * @param amplifierItem item to add
+	 * @param value amplifier value for the item, scrap is 5000
+	 */
+	public static void addMatterAmplifier(Block amplifierItem, int value) {
+		addMatterAmplifier(new ItemStack(amplifierItem, 1, -1), value);
+	}
+
+	/**
+	 * Get the base IC2 package name, used internally.
+	 *
+	 * @return IC2 package name, if unable to be determined defaults to ic2
+	 */
+	private static String getPackage() {
+		Package pkg = Ic2Recipes.class.getPackage();
+		if (pkg != null) return pkg.getName().substring(0, pkg.getName().lastIndexOf('.'));
+		else return "ic2";
+	}
+
+	private static List<Map.Entry<ItemStack, ItemStack> > TileEntityCompressor_recipes;
+	private static List<Map.Entry<ItemStack, ItemStack> > TileEntityExtractor_recipes;
+	private static List<Map.Entry<ItemStack, ItemStack> > TileEntityMacerator_recipes;
+	private static List<ItemStack> TileEntityRecycler_blacklist;
+	private static List<Map.Entry<ItemStack, Integer> > TileEntityMatter_amplifiers;
+}
+

src/minecraft/ic2/api/Items.java

@@ -0,0 +1,401 @@
+package ic2.api;
+
+import net.minecraft.item.ItemStack;
+
+/**
+ * Provides access to IC2 blocks and items.
+ * 
+ * Some items can be acquired through the ore dictionary which is the recommended way.
+ * The items are initialized while IC2 is being loaded - try to use ModsLoaded() or load your mod after IC2.
+ * Some blocks/items can be disabled by a config setting, so it's recommended to check if they're null first.
+ * 
+ * Getting the associated Block/Item for an ItemStack x:
+ *   Blocks: Block.blocksList[x.itemID]
+ *   Items: x.getItem()
+ */
+public final class Items {
+	/**
+	 * Get an ItemStack for a specific item name, example: Items.getItem("resin")
+	 * See the list below for item names.
+	 * Make sure to copy() the ItemStack if you want to modify it.
+	 *
+	 * @param name item name
+	 * @return The item or null if the item does not exist or an error occurred
+	 */
+	public static ItemStack getItem(String name) {
+		try {
+			if (Ic2Items == null) Ic2Items = Class.forName(getPackage() + ".core.Ic2Items");
+			
+			Object ret = Ic2Items.getField(name).get(null);
+			
+			if (ret instanceof ItemStack) {
+				return (ItemStack) ret;
+			} else {
+				return null;
+			}
+		} catch (Exception e) {
+			System.out.println("IC2 API: Call getItem failed for "+name);
+			
+			return null;
+		}
+	}
+	
+	/* Possible values:
+	
+	----- blocks -----
+	
+	ores
+		copperOre 				Copper Ore block, currently not meta sensitive, meta in ItemStack set to 0, ore dictionary: oreCopper, null with enableWorldGenOreCopper=false
+		tinOre 					Tin Ore block, currently not meta sensitive, meta in ItemStack set to 0, ore dictionary: oreTin, null with enableWorldGenOreTin=false
+		uraniumOre 				Tin Ore block, currently not meta sensitive, meta in ItemStack set to 0, ore dictionary: oreUranium, null with enableWorldGenOreUranium=false
+	
+	rubber related
+		Rubber wood block, meta reflects the state, meta in ItemStack set to 0, ore dictionary: woodRubber (with meta 0), null with enableWorldGenTreeRubber=false
+		dropped (as an item)  -> metadata 0
+		block, no resin spot  -> metadata 0 or 1
+		block, wet resin spot -> metadata 2-5 (according to the side)
+		block, dry resin spot -> metadata 8-11 (wet state + 6)
+
+		rubberWood
+		rubberLeaves 			Rubber Leaves block, currently not meta sensitive, meta in ItemStack set to 0, null with enableWorldGenTreeRubber=false
+		rubberSapling 			Rubber Sapling block, currently not meta sensitive, meta in ItemStack set to 0, null with enableWorldGenTreeRubber=false
+		resinSheet 				Resin Sheet block, currently not meta sensitive
+		rubberTrampoline 		Rubber Trampoline block, meta reflects internal state, meta in ItemStack set to 0
+	
+	building/storage
+		ironFence 				Iron Fence block, currently not meta sensitive
+	
+		reinforcedStone 		Reinforced Stone block, currently not meta sensitive
+		reinforcedGlass 		Reinforced Glass block, currently not meta sensitive
+		reinforcedDoorBlock 	Reinforced Door block, meta reflects the state (see vanilla doors), meta in ItemStack set to 0
+	
+		constructionFoam 		Construction Foam block, currently not meta sensitive
+		constructionFoamWall 	Construction Foam Wall block, meta = color, implements IPaintableBlock
+		scaffold 				Scaffold block, meta reflects internal physical model data
+	
+		bronzeBlock 			Bronze block, meta sensitive
+		copperBlock 			Copper block, meta sensitive
+		tinBlock 				Tin block, meta sensitive
+		uraniumBlock 			Uranium block, meta sensitive
+	
+	cables (when placed as a block, inventory items are different TE implements IEnergyConductor)
+		copperCableBlock 				Copper Cable block, meta sensitive
+		insulatedCopperCableBlock 		Insulated Copper Cable block, meta sensitive
+	
+		goldCableBlock 					Gold Cable block, meta sensitive
+		insulatedGoldCableBlock 		Insulated Gold Cable block, meta sensitive
+		doubleInsulatedGoldCableBlock 	Double Insulated Gold Cable block, meta sensitive
+	
+		ironCableBlock 					Iron Cable block, meta sensitive
+		insulatedIronCableBlock 		Insulated Iron Cable block, meta sensitive
+		doubleInsulatedIronCableBlock 	Double Insulated Iron Cable block, meta sensitive
+		trippleInsulatedIronCableBlock 	Tripple Insulated Iron Cable block, meta sensitive
+	
+		glassFiberCableBlock 			Glass Fiber Cable block, meta sensitive
+	
+		tinCableBlock 					Tin Cable block, meta sensitive
+	
+		detectorCableBlock 				Detector Cable block, meta sensitive
+		splitterCableBlock 				Splitter Cable block, meta sensitive
+	
+	generators + related (TE implements IEnergySource ex. reactorChamber)
+		generator 				Generator block, meta sensitive
+		geothermalGenerator 	Geothermal Generator block, meta sensitive
+		waterMill 				Water Mill block, meta sensitive
+		solarPanel 				Solar Panel block, meta sensitive
+		windMill 				Wind Mill block, meta sensitive
+		nuclearReactor 			Nuclear Reactor block, meta sensitive
+		reactorChamber 			Reactor Chamber block, currently not meta sensitive
+	
+	energy storages (TE implements IEnergySource and IEnergyConductor)
+		batBox 					BatBox block, meta sensitive
+		mfeUnit 				MFE Unit block, meta sensitive
+		mfsUnit 				MFS Unit block, meta sensitive
+	
+	transformers (TE implements IEnergySource and IEnergyConductor)
+		lvTransformer 			LV Transformer block, meta sensitive
+		mvTransformer 			MV Transformer block, meta sensitive
+		hvTransformer 			HV Transformer block, meta sensitive
+	
+	machines + related (TE implements IEnergySink ex. machine, miningPipe, miningPipeTip)
+		machine 				Machine block, meta sensitive
+		advancedMachine 		Advanced Machine block, meta sensitive
+	
+		ironFurnace 			Iron Furnace block, meta sensitive
+		electroFurnace 			Electro Furnace block, meta sensitive
+		macerator 				Macerator block, meta sensitive
+		extractor 				Extractor block, meta sensitive
+		compressor 				Compressor block, meta sensitive
+		canner 					Canner block, meta sensitive
+		miner 					Miner block, meta sensitive
+		pump 					Pump block, meta sensitive
+		magnetizer				Magnetizer block, meta sensitive
+		electrolyzer 			Electrolyzer block, meta sensitive
+		recycler 				Recycler block, meta sensitive
+		inductionFurnace 		Induction Furnace block, meta sensitive
+		massFabricator 			Mass Fabricator block, meta sensitive
+		terraformer				Terraformer block, meta sensitive
+		teleporter 				Teleporter block, meta sensitive
+		teslaCoil 				Tesla Coil block, meta sensitive
+		luminator 				Passive (dark) Luminator block, meta = facing
+		activeLuminator 		Active (bright) Luminator block, meta = facing
+	
+		miningPipe 				Mining Pipe block, currently not meta sensitive, meta in ItemStack set to 0
+		miningPipeTip 			Mining Pipe Tip block, currently not meta sensitive, meta in ItemStack set to 0
+	
+	personal blocks
+		personalSafe 			Personal Safe block, meta sensitive
+		tradeOMat 				Trade-O-Mat block, meta sensitive
+		energyOMat 				Energy-O-Mat block, meta sensitive
+	
+	explosives
+		industrialTnt 			Industrial TNT block, currently not meta sensitive
+		nuke 					Nuke block, currently not meta sensitive
+		dynamiteStick 			Dynamite Stick block, meta = placement, meta in ItemStack set to 0
+		dynamiteStickWithRemote Dynamite Stick with Remote block, meta = placement, meta in ItemStack set to 0
+	
+	Agriculture Stuff
+		crop 					Crop Block, empty, not meta sensitive
+	
+	
+	----- items -----
+	
+	rubber + related
+		resin 					Resin item, currently not meta sensitive
+		rubber 					Rubber item, currently not meta sensitive, ore dictionary: itemRubber
+	
+	ore drops
+		uraniumDrop 			Uranium Drop item, currently not meta sensitive, ore dictionary: itemDropUranium
+	
+	dusts
+		bronzeDust 				Bronze Dust item, currently not meta sensitive
+		clayDust 				Clay Dust item, currently not meta sensitive
+		coalDust 				Coal Dust item, currently not meta sensitive
+		copperDust 				Copper Dust item, currently not meta sensitive
+		goldDust 				Gold Dust item, currently not meta sensitive
+		ironDust 				Iron Dust item, currently not meta sensitive
+		silverDust 				Silver Dust item, currently not meta sensitive
+		smallIronDust 			Small Iron Dust item, currently not meta sensitive
+		tinDust 				Tin Dust item, currently not meta sensitive
+		hydratedCoalDust 		Hydrated Coal Dust item, currently not meta sensitive
+	
+	ingots
+		refinedIronIngot 		Refined Iron Ingot item, currently not meta sensitive, ore dictionary: ingotRefinedIron
+		copperIngot 			Copper Ingot item, currently not meta sensitive, ore dictionary: ingotCopper
+		tinIngot 				Tin Ingot item, currently not meta sensitive, ore dictionary: ingotTin
+		bronzeIngot 			Bronze Ingot item, currently not meta sensitive, ore dictionary: ingotBronze
+		mixedMetalIngot 		Mixed Metal Ingot item, currently not meta sensitive
+		uraniumIngot 			Uranium Ingot item, currently not meta sensitive, ore dictionary: ingotUranium
+	
+	tools/weapons (without electric tools)
+		treetap 					Treetap item, meta = damage value
+		wrench 						Wrench item, meta = damage value
+		cutter 						Insulation Cutter item, meta = damage value
+		constructionFoamSprayer 	Construction Foam Sprayer item, meta = charges (as of v1.45)
+	
+		bronzePickaxe 				Bronze Pickaxe item, meta = damage value
+		bronzeAxe 					Bronze Axe item, meta = damage value
+		bronzeSword 				Bronze Sword item, meta = damage value
+		bronzeShovel 				Bronze Shovel item, meta = damage value
+		bronzeHoe 					Bronze Hoe item, meta = damage value
+	
+	el. tools/devices/weapons
+		miningDrill 			Mining Drill item, meta = visual charge indicator, implements IElectricItem
+		diamondDrill 			Diamond Tipped Mining Drill item, meta = visual charge indicator, implements IElectricItem
+		chainsaw 				Chainsaw item, meta = visual charge indicator, implements IElectricItem
+		electricWrench			Electric Wrench item, meta = visual charge indicator, implements IElectricItem
+		electricTreetap			Electric Treetap item, meta = visual charge indicator, implements IElectricItem
+		miningLaser 			Mining Laser item, meta = visual charge indicator, implements IElectricItem
+	
+		ecMeter 				EC-Mater item, currently not meta sensitive
+		odScanner 				Ore Density Scanner item, meta = damage value for charge level, implements IElectricItem
+		ovScanner 				Ore Value Scanner item, meta = visual charge indicator, implements IElectricItem
+	
+		frequencyTransmitter 	Frequency Transmitter item, currently not meta sensitive
+	
+		nanoSaber 				Idle Nano Saber item, meta = visual charge indicator, implements IElectricItem
+		enabledNanoSaber 		Enabled Nano Saber item, meta = visual charge indicator, implements IElectricItem
+	
+	armor/wearable
+		rubberBoots 			Rubber Boots item, meta = damage value
+	
+		bronzeHelmet 			Bronze Helmet Armor item, meta = damage value
+		bronzeChestplate 		Bronze Chestplate Armor item, meta = damage value
+		bronzeLeggings 			Bronze Leggings Armor item, meta = damage value
+		bronzeBoots 			Bronze Boots Armor item, meta = damage value
+	
+		compositeArmor 			Composite Armor item, meta = damage value for charge level
+	
+		nanoHelmet 				Nano Helmet Armor item, meta = visual charge indicator, implements IElectricItem
+		nanoBodyarmor 			Nano Bodyarmor item, meta = visual charge indicator, implements IElectricItem
+		nanoLeggings 			Nano Leggings Armor item, meta = visual charge indicator, implements IElectricItem
+		nanoBoots 				Nano Boots Armor item, meta = visual charge indicator, implements IElectricItem
+	
+		quantumHelmet 			Quantum Helmet Armor item, meta = visual charge indicator, implements IElectricItem
+		quantumBodyarmor 		Quantum Bodyarmor item, meta = visual charge indicator, implements IElectricItem
+		quantumLeggings 		Quantum Leggings Armor item, meta = visual charge indicator, implements IElectricItem
+		quantumBoots 			Quantum Boots Armor item, meta = visual charge indicator, implements IElectricItem
+	
+		jetpack 				Jetpack item, meta = damage value for fuel level
+		electricJetpack 		Electric Jetpack item, meta = visual charge indicator, implements IElectricItem
+	
+		batPack 				BatPack item, meta = visual charge indicator, implements IElectricItem, can provide energy
+		lapPack 				LapPack item, meta = visual charge indicator, implements IElectricItem, can provide energy
+	
+		cfPack 					CF Pack item, meta = charges (as of v1.45)
+		
+		solarHelmet				Solar Helmet item, currently not meta sensitive
+		staticBoots				Static Boots item, currently not meta sensitive
+	
+	batteries
+		reBattery 				Empty RE Battery item, currently not meta sensitive, implements IElectricItem
+		chargedReBattery 		RE Battery item, meta = visual charge indicator, implements IElectricItem, can provide energy
+		energyCrystal 			Energy Crystal item, meta = visual charge indicator, implements IElectricItem, can provide energy
+		lapotronCrystal 		Lapotron Crystal item, meta = visual charge indicator, implements IElectricItem, can provide energy
+		suBattery 				SU Battery item, currently not meta sensitive
+	
+	cables
+		copperCableItem 				Copper Cable item, meta sensitive
+		insulatedCopperCableItem 		Insulated Copper Cable item, meta sensitive
+	
+		goldCableItem 					Gold Cable item, meta sensitive
+		insulatedGoldCableItem 			Insulated Gold Cable item, meta sensitive
+		doubleInsulatedGoldCableItem 	Double Insulated Gold Cable item, meta sensitive
+	
+		ironCableItem 					Iron Cable item, meta sensitive
+		insulatedIronCableItem 			Insulated Iron Cable item, meta sensitive
+		doubleInsulatedIronCableItem 	Double Insulated Iron Cable item, meta sensitive
+		trippleInsulatedIronCableItem 	Tripple Insulated Iron Cable item, meta sensitive
+	
+		glassFiberCableItem 			Glass Fiber Cable item, meta sensitive
+	
+		tinCableItem 					Tin Cable item, meta sensitive
+	
+		detectorCableItem 				Detector Cable item, meta sensitive
+		splitterCableItem 				Splitter Cable item, meta sensitive
+	
+	cells/containers (without reactor components)
+		cell 					Empty Cell item, currently not meta sensitive
+		lavaCell 				Lava Cell item, currently not meta sensitive
+		hydratedCoalCell 		Hydrated Coal Cell item, currently not meta sensitive
+		bioCell 				Bio Cell item, currently not meta sensitive
+		coalfuelCell 			Coalfuel Cell item, currently not meta sensitive
+		biofuelCell 			Biofuel Cell item, currently not meta sensitive
+		waterCell 				Water Cell item, currently not meta sensitive
+		electrolyzedWaterCell 	Electrolyzed Water Cell item, currently not meta sensitive
+	
+		fuelCan 				Empty Fuel Can item, currently not meta sensitive
+		filledFuelCan 			Fuel Can item, meta = fuel value (as of v1.45)
+	
+		tinCan 					Empty Tin Can item, currently not meta sensitive
+		filledTinCan 			Filled Tin Can item, currently not meta sensitive
+		
+	reactor components
+		uraniumCell 				Uranium Cell item, meta = damage value
+		coolingCell 				Cooling Cell item, meta = damage value
+	
+		depletedIsotopeCell 		Depleted Isotope Cell item, meta = damage value
+		reEnrichedUraniumCell 		Re-Enriched Uranium Cell item, currently not meta sensitive
+		nearDepletedUraniumCell		Near-Depleted Uranium Cell item, currently not meta sensitive
+	
+		integratedReactorPlating 	Integrated Reactor Plating item, meta = damage value
+		integratedHeatDisperser		Integrated Heat Disperser item, meta = damage value
+	
+	terraformer blueprints
+		terraformerBlueprint 				Empty Terraformer Blueprint item, currently not meta sensitive
+		cultivationTerraformerBlueprint 	Cultivation Terraformer Blueprint item, currently not meta sensitive
+		irrigationTerraformerBlueprint 		Irrigation Terraformer Blueprint item, currently not meta sensitive
+		chillingTerraformerBlueprint 		Chilling Terraformer Blueprint item, currently not meta sensitive
+		desertificationTerraformerBlueprint Desertification Terraformer Blueprint item, currently not meta sensitive
+		flatificatorTerraformerBlueprint 	Flatificator Terraformer Blueprint item, currently not meta sensitive
+		mushroomTerraformerBlueprint 	    Mushroom Terraformer Blueprint item, currently not meta sensitive
+	
+	diamond chain
+		coalBall 				Coal Ball item, currently not meta sensitive
+		compressedCoalBall 		Compressed Coal Ball item, currently not meta sensitive
+		coalChunk 				Coal Chunk item, currently not meta sensitive
+		industrialDiamond 		Industrial Diamond item, currently not meta sensitive, DEPRECATED
+	
+	recycler chain
+		scrap 					Scrap item, currently not meta sensitive
+		scrapBox 				Scrap Box item, currently not meta sensitive
+	
+	fuel production chain
+		hydratedCoalClump 		Hydrated Coal Clump item, currently not meta sensitive
+		plantBall 				Plant Ball item, currently not meta sensitive
+		compressedPlantBall 	Compressed Plant Ball item, currently not meta sensitive
+	
+	painting
+		painter 				Painter item, currently not meta sensitive
+	
+		blackPainter 			Black Painter item, meta = damage value
+		redPainter 				Red Painter item, meta = damage value
+		greenPainter 			Green Painter item, meta = damage value
+		brownPainter 			Brown Painter item, meta = damage value
+		bluePainter 			Blue Painter item, meta = damage value
+		purplePainter 			Purple Painter item, meta = damage value
+		cyanPainter 			Cyan Painter item, meta = damage value
+		lightGreyPainter 		Light Grey Painter item, meta = damage value
+		darkGreyPainter 		Dark Grey Painter item, meta = damage value
+		pinkPainter 			Pink Painter item, meta = damage value
+		limePainter 			Lime Painter item, meta = damage value
+		yellowPainter 			Yellow Painter item, meta = damage value
+		cloudPainter 			Cloud Painter item, meta = damage value
+		magentaPainter 			Magenta Painter item, meta = damage value
+		orangePainter 			Orange Painter item, meta = damage value
+		whitePainter 			White Painter item, meta = damage value
+	
+	explosives + related
+		dynamite 				Throwable Dynamite item, currently not meta sensitive
+		stickyDynamite 			Throwable Sticky Dynamite item, currently not meta sensitive
+	
+		remote 					Dynamite Remote item, currently not meta sensitive
+	
+	misc intermediate recipe ingredients
+		electronicCircuit 		Electronic Circuit item, currently not meta sensitive
+		advancedCircuit 		Advanced Circuit item, currently not meta sensitive
+	
+		advancedAlloy 			Advanced Alloy item, currently not meta sensitive
+	
+		carbonFiber 			Raw Carbon Fiber item, currently not meta sensitive
+		carbonMesh 				Raw Carbon Mesh item, currently not meta sensitive
+		carbonPlate 			Carbon Plate item, currently not meta sensitive
+	
+		matter 					UU-Matter item, currently not meta sensitive
+		iridiumOre 				Iridium Ore item, currently not meta sensitive
+		iridiumPlate 			Iridium Plate item, currently not meta sensitive
+	
+	upgrade modules
+		overclockerUpgrade		overclocker upgrade item, meta sensitive
+		transformerUpgrade		transformer upgrade item, meta sensitive
+		energyStorageUpgrade	energy storage upgrade item, meta sensitive
+	
+	misc
+		coin 					Coin item, currently not meta sensitive
+		reinforcedDoor 			Reinforced Door item, currently not meta sensitive
+		constructionFoamPellet 	Construction Foam Pellet item, currently not meta sensitive
+		cropSeed 				Crop seeds, stuff stored in NBT, don't use for crafting recipes!
+		cropnalyzer				Cropnalyzer handheld device
+		fertilizer				Basic IC2Item, used to provide nutrients toCropBlocks
+		hydratingCell			Cell used to hydrate Crops, meta = Content, 0 = Full, 9999 = Near empty
+		electricHoe				Electric Hoe, meta = charge level
+		solarHelmet				Solar Helmet item, currently not meta sensitive
+		terraWart				Terra Wart item, cures potion effects
+		weedEx					Weed-EX can, meta = uses left
+		
+	*/
+	
+	/**
+	 * Get the base IC2 package name, used internally.
+	 * 
+	 * @return IC2 package name, if unable to be determined defaults to ic2
+	 */
+	private static String getPackage() {
+		Package pkg = Items.class.getPackage();
+		if (pkg != null) return pkg.getName().substring(0, pkg.getName().lastIndexOf('.'));
+		else return "ic2";
+	}
+	
+	private static Class<?> Ic2Items;
+}
+