Updated IC2 API

src/api/java/ic2/api/Direction.java

@@ -36,17 +36,19 @@ public enum Direction {
 	 */
 	ZP(5);
 
-	Direction(int dir1) {
-		this.dir = dir1;
+	public static Direction fromSideValue(int side) {
+		return directions[(side + 2) % 6];
 	}
 
-	/*public CoordinateTuple ApplyToCoordinates(CoordinateTuple coordinates) {
-		CoordinateTuple ret = new CoordinateTuple(coordinates);
+	public static Direction fromForgeDirection(ForgeDirection dir) {
+		if (dir == ForgeDirection.UNKNOWN) return null;
 
-		ret.coords[dir/2] += GetSign();
+		return fromSideValue(dir.ordinal());
+	}
 
-		return ret;
-	}*/
+	private Direction(int dir1) {
+		this.dir = dir1;
+	}
 
 	/**
 	 * Get the tile entity next to a tile entity following this direction.

src/api/java/ic2/api/crops/BaseSeed.java

@@ -0,0 +1,56 @@
+package ic2.api.crops;
+
+/**
+ * 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 id1 plant ID
+	 * @param size1 plant size
+	 * @param statGrowth1 plant growth stat
+	 * @param statGain1 plant gain stat
+	 * @param statResistance1 plant resistance stat
+	 * @param stackSize1 for internal usage only
+	 */
+	public BaseSeed(int id1, int size1, int statGrowth1, int statGain1, int statResistance1, int stackSize1) {
+		super();
+		this.id = id1;
+		this.size = size1;
+		this.statGrowth = statGrowth1;
+		this.statGain = statGain1;
+		this.statResistance = statResistance1;
+		this.stackSize = stackSize1;
+	}
+}

src/api/java/ic2/api/crops/CropCard.java

@@ -0,0 +1,367 @@
+package ic2.api.crops;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+
+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;
+		}
+		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(IIconRegister iconRegister) {
+		textures = new IIcon[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 ICropTile
+	 * @return 0-255, representing the sprite index on the crop's spritesheet.
+	 */
+	@SideOnly(Side.CLIENT)
+	public IIcon getSprite(ICropTile crop) {
+		if (crop.getSize() <= 0 || crop.getSize() > textures.length) return null;
+
+		return textures[crop.getSize() - 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(ICropTile 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 ICropTile
+	 * @return Whether the crop can grow
+	 */
+	public abstract boolean canGrow(ICropTile 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 ICropTile
+	 * @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(ICropTile 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(ICropTile crop) {
+		return crop.getSize() >= 3;
+	}
+
+
+	/**
+	 * Called when the plant is rightclicked by a player.
+	 * Default action is harvesting.
+	 * 
+	 * Only called Serverside.
+	 * 
+	 * @param crop reference to ICropTile
+	 * @param player player rightclicking the crop
+	 * @return Whether the plant has changed
+	 */
+	public boolean rightclick(ICropTile crop, EntityPlayer player) {
+		return crop.harvest(true);
+	}
+
+	/**
+	 * Use in Crop Havester with insert Cropnalyzer to get best Output.
+	 * 
+	 * @param crop reference to ICropTile
+	 * @return  need crop  size for best output.
+	 */
+
+	public abstract int getOptimalHavestSize(ICropTile crop);
+
+	/**
+	 * Check whether the crop can be harvested.
+	 * 
+	 * @param crop reference to ICropTile
+	 * @return Whether the crop can be harvested in its current state.
+	 */
+	public abstract boolean canBeHarvested(ICropTile 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 ICropTile
+	 * @return Item obtained
+	 */
+	public abstract ItemStack getGain(ICropTile crop);
+
+	/**
+	 * Get the size of the plant after harvesting.
+	 * Default is 1.
+	 * 
+	 * @param crop reference to ICropTile
+	 * @return Plant size after harvesting
+	 */
+	public byte getSizeAfterHarvest(ICropTile crop) {return 1;}
+
+
+	/**
+	 * Called when the plant is leftclicked by a player.
+	 * Default action is picking the plant.
+	 * 
+	 * Only called Serverside.
+	 * 
+	 * @param crop reference to ICropTile
+	 * @param player player leftclicked the crop
+	 * @return Whether the plant has changed
+	 */
+	public boolean leftclick(ICropTile 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 ICropTile
+	 * @return Chance to drop the seeds
+	 */
+	public float dropSeedChance(ICropTile crop) {
+		if (crop.getSize() == 1) return 0;
+		float base = 0.5F;
+		if (crop.getSize() == 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 ICropTile
+	 * @return Seeds
+	 */
+	public ItemStack getSeeds(ICropTile crop) {
+		return crop.generateSeeds(crop.getID(), crop.getGrowth(), crop.getGain(), crop.getResistance(), crop.getScanLevel());
+	}
+
+	/**
+	 * Called when a neighbor block to the crop has changed.
+	 * 
+	 * @param crop reference to ICropTile
+	 */
+	public void onNeighbourChange(ICropTile crop) {
+		//
+	}
+
+	/**
+	 * Check if the crop should emit redstone.
+	 * 
+	 * @return Whether the crop should emit redstone
+	 */
+	public int emitRedstone(ICropTile crop) {return 0;}
+
+	/**
+	 * Called when the crop is destroyed.
+	 * 
+	 * @param crop reference to ICropTile
+	 */
+	public void onBlockDestroyed(ICropTile crop) {
+		//
+	}
+
+	/**
+	 * Get the light value emitted by the plant.
+	 * 
+	 * @param crop reference to ICropTile
+	 * @return Light value emitted
+	 */
+	public int getEmittedLight(ICropTile crop) {return 0;}
+
+	/**
+	 * Default is true if the entity is an EntityLiving in jumping or sprinting state.
+	 * 
+	 * @param crop reference to ICropTile
+	 * @param entity entity colliding
+	 * @return Whether trampling calculation should happen, return false if the plant is no longer valid.
+	 */
+	public boolean onEntityCollision(ICropTile crop, Entity entity) {
+		if (entity instanceof EntityLivingBase) {
+			return ((EntityLivingBase) entity).isSprinting();
+		}
+		return false;
+	}
+
+
+	/**
+	 * Called every time the crop ticks.
+	 * Should be called every 256 ticks or around 13 seconds.
+	 * 
+	 * @param crop reference to ICropTile
+	 */
+	public void tick(ICropTile 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 ICropTile
+	 * @return Whether the plant spreads weed
+	 */
+	public boolean isWeed(ICropTile crop) {
+		return crop.getSize() >= 2 && (crop.getID() == 0 || crop.getGrowth() >= 24);
+	}
+
+
+	/**
+	 * Get this plant's ID.
+	 * 
+	 * @return ID of this CropCard or -1 if it's not registered
+	 */
+	public final int getId() {
+		return Crops.instance.getIdFor(this);
+	}
+
+	@SideOnly(Side.CLIENT)
+	protected IIcon textures[];
+}

src/api/java/ic2/api/crops/Crops.java

@@ -0,0 +1,117 @@
+package ic2.api.crops;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.biome.BiomeGenBase;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import net.minecraftforge.common.BiomeDictionary.Type;
+
+/**
+ * General management of the crop system.
+ */
+public abstract class Crops {
+	public static Crops instance;
+
+	/**
+	 * Adds 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 abstract void addBiomeBonus(BiomeGenBase biome, int humidityBonus, int nutrientsBonus);
+
+	/**
+	 * Adds a crop humidity and nutrient biome bonus.
+	 * 
+	 * 0 indicates no bonus and negative values indicate a penalty.
+	 * 
+	 * @param type Forge biome type to apply the bonus in
+	 * @param humidityBonus Humidity stat bonus
+	 * @param nutrientsBonus Nutrient stat bonus
+	 */
+	public abstract void addBiomeBonus(Type type, int humidityBonus, int nutrientsBonus);
+
+	/**
+	 * Gets the humidity bonus for a biome.
+	 * 
+	 * @param biome Biome to check
+	 * @return Humidity bonus or 0 if none
+	 */
+	public abstract int getHumidityBiomeBonus(BiomeGenBase biome);
+
+	/**
+	 * Gets the nutrient bonus for a biome.
+	 * 
+	 * @param biome Biome to check
+	 * @return Nutrient bonus or 0 if none
+	 */
+	public abstract int getNutrientBiomeBonus(BiomeGenBase biome);
+
+	/**
+	 * Returns the list of registered crops.
+	 * 
+	 * @return Registered crops by ID
+	 */
+	public abstract CropCard[] getCropList();
+
+	/**
+	 * 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 abstract short registerCrop(CropCard crop);
+
+	/**
+	 * 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 abstract boolean registerCrop(CropCard crop, int i);
+
+	/**
+	 * 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 abstract boolean registerBaseSeed(ItemStack stack, int id, int size, int growth, int gain, int resistance);
+
+	/**
+	 * Finds a base seed from the given item.
+	 * 
+	 * @return Base seed or null if none found
+	 */
+	public abstract BaseSeed getBaseSeed(ItemStack stack);
+
+	/**
+	 * Execute registerSprites for all registered crop cards.
+	 * 
+	 * This method will get called by IC2, don't call it yourself.
+	 */
+	@SideOnly(Side.CLIENT)
+	public abstract void startSpriteRegistration(IIconRegister iconRegister);
+
+	/**
+	 * Returns the ID for the given crop.
+	 * 
+	 * @param crop Crop to look up
+	 * @return ID, or -1 if not found
+	 */
+	public abstract int getIdFor(CropCard crop);
+}

src/api/java/ic2/api/crops/ICropTile.java

@@ -0,0 +1,264 @@
+package ic2.api.crops;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ChunkCoordinates;
+import net.minecraft.world.World;
+
+/**
+ * Interface implemented by the crop tile entity.
+ */
+public interface ICropTile {
+	/**
+	 * Get the crop's plant ID.
+	 * 
+	 * @return Plant ID, or -1 if there is no plant currently on the crop
+	 */
+	public short getID();
+
+	/**
+	 * Set the crop's plant ID.
+	 * 
+	 * @param id Plant ID, or -1 for no plant
+	 */
+	public void setID(short id);
+
+	/**
+	 * Get the crop's plant size.
+	 * 
+	 * @return Plant size, starting with 1 and maximum varies depending on plant
+	 */
+	public byte getSize();
+
+	/**
+	 * Set the crop's plant size.
+	 * 
+	 * @param size Plant size
+	 */
+	public void setSize(byte size);
+
+	/**
+	 * Get the crop's plant growth stat.
+	 * Higher values indicate faster growth.
+	 * 
+	 * @return Plant growth stat
+	 */
+	public byte getGrowth();
+
+	/**
+	 * Set the crop's plant growth stat.
+	 * 
+	 * @param growth Plant growth stat
+	 */
+	public void setGrowth(byte growth);
+
+	/**
+	 * Get the crop's plant gain stat.
+	 * Higher values indicate more drops.
+	 * 
+	 * @return Plant gain stat
+	 */
+	public byte getGain();
+
+	/**
+	 * Set the crop's plant gain stat.
+	 * 
+	 * @param gain Plant gain stat
+	 */
+	public void setGain(byte gain);
+
+	/**
+	 * Get the crop's plant resistance stat.
+	 * Higher values indicate more resistance against trampling.
+	 * 
+	 * @return Plant resistance stat
+	 */
+	public byte getResistance();
+
+	/**
+	 * Set the crop's plant resistance stat.
+	 * 
+	 * @param resistance Plant resistance stat
+	 */
+	public void setResistance(byte resistance);
+
+	/**
+	 * Get the crop's plant scan level.
+	 * Increases every time the seed is analyzed.
+	 * 
+	 * @return Plant scan level
+	 */
+	public byte getScanLevel();
+
+	/**
+	 * Set the crop's plant scan level.
+	 * 
+	 * @param scanLevel Plant scan level
+	 */
+	public void setScanLevel(byte scanLevel);
+
+	/**
+	 * Get the crop's plant custom data, stored alongside the crop.
+	 * Can be modified in place.
+	 * 
+	 * @return Plant custom data
+	 */
+	public NBTTagCompound getCustomData();
+
+	/**
+	 * Get the crop's nutrient storage.
+	 * Ranges from 0 to 100.
+	 * 
+	 * @return Crop nutrient storage
+	 */
+	public int getNutrientStorage();
+
+	/**
+	 * Set the crop's nutrient storage.
+	 * 
+	 * @param nutrientStorage Crop nutrient storage
+	 */
+	public void setNutrientStorage(int nutrientStorage);
+
+	/**
+	 * Get the crop's hydration storage.
+	 * 0 indicates nothing, 1-10 indicate water hydration and 11-100 for hydration cells.
+	 * 
+	 * @return Crop hydration storage
+	 */
+	public int getHydrationStorage();
+
+	/**
+	 * Set the crop's hydration storage.
+	 * 
+	 * @param hydrationStorage Crop hydration storage
+	 */
+	public void setHydrationStorage(int hydrationStorage);
+
+	/**
+	 * Get the crop's Weed-Ex storage.
+	 * 
+	 * @return Crop Weed-Ex storage
+	 */
+	public int getWeedExStorage();
+
+	/**
+	 * Set the crop's Weed-Ex storage.
+	 * 
+	 * @param weedExStorage Crop Weed-Ex storage
+	 */
+	public void setWeedExStorage(int weedExStorage);
+
+	/**
+	 * Get the crop's humidity.
+	 * Ranges from 0 (dry) to 10 (humid).
+	 * Updates every couple of seconds or when an update is requested.
+	 * 
+	 * @see #updateState()
+	 * 
+	 * @return Crop humidity level
+	 */
+	public byte getHumidity();
+
+	/**
+	 * Get the crop's nutrient level.
+	 * Ranges from 0 (empty) to 10 (full).
+	 * Updates every couple of seconds or when an update is requested.
+	 * 
+	 * @see #updateState()
+	 * 
+	 * @return Crop nutrient level
+	 */
+	public byte getNutrients();
+
+	/**
+	 * Get the crop's air quality.
+	 * Ranges from 0 (cluttered) to 10 (fresh).
+	 * Updates every couple of seconds or when an update is requested.
+	 * 
+	 * @see #updateState()
+	 * 
+	 * @return Crop air quality
+	 */
+	public byte getAirQuality();
+
+	/**
+	 * Get the crop's world.
+	 * 
+	 * @return Crop world
+	 */
+	public World getWorld();
+
+	/**
+	 * Get the crop's location.
+	 * 
+	 * @return Crop location
+	 */
+	public ChunkCoordinates getLocation();
+
+	/**
+	 * Get the crop's light level.
+	 * 
+	 * @return Crop light level
+	 */
+	public int getLightLevel();
+
+	/**
+	 * Pick the crop, removing and giving seeds for the plant.
+	 * 
+	 * @param manual whether it was done by hand (not automated)
+	 * @return true if successfully picked
+	 */
+	public boolean pick(boolean manual);
+
+	/**
+	 * Harvest the crop, turning it into gain and resetting its size.
+	 * drop output on ground
+	 * @param manual
+	 * @return true if successfully harvested
+	 */
+	public boolean harvest(boolean manual);
+
+	/**
+	 * Harvest the crop, turning it into gain and resetting its size.
+	 * drop output on ground
+	 * @param Optimal force check getOptimalHavestSize() for harvest
+	 * @return ItemStack[] of harvest output
+	 */
+
+	ItemStack[] harvest_automated(boolean Optimal);
+
+	/**
+	 * Fully clears the crop without dropping anything.
+	 */
+	public void reset();
+
+	/**
+	 * Request a texture and lighting update.
+	 */
+	public void updateState();
+
+	/**
+	 * Check if a block is under the farmland containing the crop.
+	 * Searches up to 2 blocks below the farmland or an air space, whichever appears first.
+	 * 
+	 * @param block block to search
+	 * @return Whether the block was found
+	 */
+	public boolean isBlockBelow(Block block);
+
+	/**
+	 * Generate plant seeds with the given parameters.
+	 * 
+	 * @param plant plant ID
+	 * @param growth plant growth stat
+	 * @param gain plant gain stat
+	 * @param resis plant resistance stat
+	 * @param scan plant scan level
+	 * @return Plant seed item
+	 */
+	public ItemStack generateSeeds(short plant, byte growth, byte gain, byte resis, byte scan);
+
+
+}

src/api/java/ic2/api/crops/package-info.java

@@ -0,0 +1,4 @@
+@API(apiVersion="1.0", owner="IC2", provides="IC2API")
+package ic2.api.crops;
+import cpw.mods.fml.common.API;
+

src/api/java/ic2/api/energy/IEnergyNet.java

@@ -42,7 +42,9 @@ public interface IEnergyNet {
 	 * @note call this twice with x ticks delay to get the avg. emitted power p = (call2 - call1) / x EU/tick
 	 *
 	 * @param tileEntity energy emitter
+	 * @deprecated Discontinued, use getNodeStats instead.
 	 */
+	@Deprecated
 	double getTotalEnergyEmitted(TileEntity tileEntity);
 
 	/**
@@ -51,9 +53,21 @@ public interface IEnergyNet {
 	 * @note call this twice with x ticks delay to get the avg. sunken power p = (call2 - call1) / x EU/tick
 	 *
 	 * @param tileEntity energy emitter
+	 * @deprecated Discontinued, use getNodeStats instead.
 	 */
+	@Deprecated
 	double getTotalEnergySunken(TileEntity tileEntity);
 
+	/**
+	 * Retrieve statistics for the tile entity specified.
+	 * 
+	 * The statistics apply to the last simulated tick.
+	 * 
+	 * @param te Tile entity to check.
+	 * @return Statistics for the tile entity.
+	 */
+	NodeStats getNodeStats(TileEntity te);
+
 	/**
 	 * Determine the typical power used by the specific tier, e.g. 128 eu/t for tier 2.
 	 * 

src/api/java/ic2/api/energy/NodeStats.java

@@ -0,0 +1,25 @@
+package ic2.api.energy;
+
+public class NodeStats {
+	public NodeStats(double energyIn, double energyOut, double voltage) {
+		this.energyIn = energyIn;
+		this.energyOut = energyOut;
+		this.voltage = voltage;
+	}
+
+	public double getEnergyIn() {
+		return energyIn;
+	}
+
+	public double getEnergyOut() {
+		return energyOut;
+	}
+
+	public double getVoltage() {
+		return voltage;
+	}
+
+	private final double energyIn;
+	private final double energyOut;
+	private final double voltage;
+}

src/api/java/ic2/api/energy/prefab/BasicSink.java

@@ -0,0 +1,373 @@
+package ic2.api.energy.prefab;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+
+import cpw.mods.fml.common.FMLCommonHandler;
+
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import ic2.api.energy.event.EnergyTileLoadEvent;
+import ic2.api.energy.event.EnergyTileUnloadEvent;
+import ic2.api.energy.tile.IEnergySink;
+import ic2.api.info.Info;
+import ic2.api.item.ElectricItem;
+
+/**
+ * BasicSink is a simple adapter to provide an ic2 energy sink.
+ * 
+ * It's designed to be attached to a tile entity as a delegate. Functionally BasicSink acts as a
+ * one-time configurable input energy buffer, thus providing a common use case for machines.
+ * 
+ * Sub-classing BasicSink instead of using it as a delegate works as well, but isn't recommended.
+ * The delegate can be extended with additional functionality through a sub class though.
+ * 
+ * The constraints set by BasicSink like the strict tank-like energy buffering should provide a
+ * more easy to use and stable interface than using IEnergySink directly while aiming for
+ * optimal performance.
+ * 
+ * Using BasicSink involves the following steps:
+ * - create a BasicSink instance in your TileEntity, typically in a field
+ * - forward invalidate, onChunkUnload, readFromNBT, writeToNBT and updateEntity to the BasicSink
+ *   instance.
+ *   If you have other means of determining when the tile entity is fully loaded, notify onLoaded
+ *   that way instead of forwarding updateEntity.
+ * - call useEnergy whenever appropriate. canUseEnergy determines if enough energy is available
+ *   without consuming the energy.
+ * - optionally use getEnergyStored to display the output buffer charge level
+ * - optionally use setEnergyStored to sync the stored energy to the client (e.g. in the Container)
+ *
+ * Example implementation code:
+ * @code{.java}
+ * public class SomeTileEntity extends TileEntity {
+ *     // new basic energy sink, 1000 EU buffer, tier 1 (32 EU/t, LV)
+ *     private BasicSink ic2EnergySink = new BasicSink(this, 1000, 1);
+ * 
+ *     @Override
+ *     public void invalidate() {
+ *         ic2EnergySink.invalidate(); // notify the energy sink
+ *         ...
+ *         super.invalidate(); // this is important for mc!
+ *     }
+ * 
+ *     @Override
+ *     public void onChunkUnload() {
+ *         ic2EnergySink.onChunkUnload(); // notify the energy sink
+ *         ...
+ *     }
+ * 
+ *     @Override
+ *     public void readFromNBT(NBTTagCompound tag) {
+ *         super.readFromNBT(tag);
+ * 
+ *         ic2EnergySink.readFromNBT(tag);
+ *         ...
+ *     }
+ * 
+ *     @Override
+ *     public void writeToNBT(NBTTagCompound tag) {
+ *         super.writeToNBT(tag);
+ * 
+ *         ic2EnergySink.writeToNBT(tag);
+ *         ...
+ *     }
+ * 
+ *     @Override
+ *     public void updateEntity() {
+ *         ic2EnergySink.updateEntity(); // notify the energy sink
+ *         ...
+ *         if (ic2EnergySink.useEnergy(5)) { // use 5 eu from the sink's buffer this tick
+ *             ... // do something with the energy
+ *         }
+ *         ...
+ *     }
+ * 
+ *     ...
+ * }
+ * @endcode
+ */
+public class BasicSink extends TileEntity implements IEnergySink {
+	// **********************************
+	// *** Methods for use by the mod ***
+	// **********************************
+
+	/**
+	 * Constructor for a new BasicSink delegate.
+	 * 
+	 * @param parent1 TileEntity represented by this energy sink.
+	 * @param capacity1 Maximum amount of eu to store.
+	 * @param tier1 IC2 tier, 1 = LV, 2 = MV, ...
+	 */
+	public BasicSink(TileEntity parent1, int capacity1, int tier1) {
+		this.parent = parent1;
+		this.capacity = capacity1;
+		this.tier = tier1;
+	}
+
+	// in-world te forwards	>>
+
+	/**
+	 * Forward for the base TileEntity's updateEntity(), used for creating the energy net link.
+	 * Either updateEntity or onLoaded have to be used.
+	 */
+	@Override
+	public void updateEntity() {
+		if (!addedToEnet) onLoaded();
+	}
+
+	/**
+	 * Notification that the base TileEntity finished loaded, for advanced uses.
+	 * Either updateEntity or onLoaded have to be used.
+	 */
+	public void onLoaded() {
+		if (!addedToEnet &&
+				!FMLCommonHandler.instance().getEffectiveSide().isClient() &&
+				Info.isIc2Available()) {
+			worldObj = parent.getWorldObj();
+			xCoord = parent.xCoord;
+			yCoord = parent.yCoord;
+			zCoord = parent.zCoord;
+
+			MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this));
+
+			addedToEnet = true;
+		}
+	}
+
+	/**
+	 * Forward for the base TileEntity's invalidate(), used for destroying the energy net link.
+	 * Both invalidate and onChunkUnload have to be used.
+	 */
+	@Override
+	public void invalidate() {
+		super.invalidate();
+
+		onChunkUnload();
+	}
+
+	/**
+	 * Forward for the base TileEntity's onChunkUnload(), used for destroying the energy net link.
+	 * Both invalidate and onChunkUnload have to be used.
+	 */
+	@Override
+	public void onChunkUnload() {
+		if (addedToEnet &&
+				Info.isIc2Available()) {
+			MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this));
+
+			addedToEnet = false;
+		}
+	}
+
+	/**
+	 * Forward for the base TileEntity's readFromNBT(), used for loading the state.
+	 * 
+	 * @param tag Compound tag as supplied by TileEntity.readFromNBT()
+	 */
+	@Override
+	public void readFromNBT(NBTTagCompound tag) {
+		super.readFromNBT(tag);
+
+		NBTTagCompound data = tag.getCompoundTag("IC2BasicSink");
+
+		energyStored = data.getDouble("energy");
+	}
+
+	/**
+	 * Forward for the base TileEntity's writeToNBT(), used for saving the state.
+	 * 
+	 * @param tag Compound tag as supplied by TileEntity.writeToNBT()
+	 */
+	@Override
+	public void writeToNBT(NBTTagCompound tag) {
+		try {
+			super.writeToNBT(tag);
+		} catch (RuntimeException e) {
+			// happens if this is a delegate, ignore
+		}
+
+		NBTTagCompound data = new NBTTagCompound();
+
+		data.setDouble("energy", energyStored);
+
+		tag.setTag("IC2BasicSink", data);
+	}
+
+	// << in-world te forwards
+	// methods for using this adapter >>
+
+	/**
+	 * Get the maximum amount of energy this sink can hold in its buffer.
+	 * 
+	 * @return Capacity in EU.
+	 */
+	public int getCapacity() {
+		return capacity;
+	}
+
+	/**
+	 * Set the maximum amount of energy this sink can hold in its buffer.
+	 * 
+	 * @param capacity1 Capacity in EU.
+	 */
+	public void setCapacity(int capacity1) {
+		this.capacity = capacity1;
+	}
+
+	/**
+	 * Get the IC2 energy tier for this sink.
+	 * 
+	 * @return IC2 Tier.
+	 */
+	public int getTier() {
+		return tier;
+	}
+
+	/**
+	 * Set the IC2 energy tier for this sink.
+	 * 
+	 * @param tier1 IC2 Tier.
+	 */
+	public void setTier(int tier1) {
+		this.tier = tier1;
+	}
+
+	/**
+	 * Determine the energy stored in the sink's input buffer.
+	 * 
+	 * @return amount in EU, may be above capacity
+	 */
+	public double getEnergyStored() {
+		return energyStored;
+	}
+
+	/**
+	 * Set the stored energy to the specified amount.
+	 * 
+	 * This is intended for server -> client synchronization, e.g. to display the stored energy in
+	 * a GUI through getEnergyStored().
+	 * 
+	 * @param amount
+	 */
+	public void setEnergyStored(double amount) {
+		energyStored = amount;
+	}
+
+	/**
+	 * Determine if the specified amount of energy is available.
+	 * 
+	 * @param amount in EU
+	 * @return true if the amount is available
+	 */
+	public boolean canUseEnergy(double amount) {
+		return energyStored >= amount;
+	}
+
+	/**
+	 * Use the specified amount of energy, if available.
+	 * 
+	 * @param amount amount to use
+	 * @return true if the amount was available
+	 */
+	public boolean useEnergy(double amount) {
+		if (canUseEnergy(amount) && !FMLCommonHandler.instance().getEffectiveSide().isClient()) {
+			energyStored -= amount;
+
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Discharge the supplied ItemStack into this sink's energy buffer.
+	 * 
+	 * @param stack ItemStack to discharge (null is ignored)
+	 * @param limit Transfer limit, values <= 0 will use the battery's limit
+	 * @return true if energy was transferred
+	 */
+	public boolean discharge(ItemStack stack, int limit) {
+		if (stack == null || !Info.isIc2Available()) return false;
+
+		double amount = capacity - energyStored;
+		if (amount <= 0) return false;
+
+		if (limit > 0 && limit < amount) amount = limit;
+
+		amount = ElectricItem.manager.discharge(stack, amount, tier, limit > 0, true, false);
+
+		energyStored += amount;
+
+		return amount > 0;
+	}
+
+	// << methods for using this adapter
+
+	// backwards compatibility (ignore these) >>
+
+	@Deprecated
+	public void onUpdateEntity() {
+		updateEntity();
+	}
+
+	@Deprecated
+	public void onInvalidate() {
+		invalidate();
+	}
+
+	@Deprecated
+	public void onOnChunkUnload() {
+		onChunkUnload();
+	}
+
+	@Deprecated
+	public void onReadFromNbt(NBTTagCompound tag) {
+		readFromNBT(tag);
+	}
+
+	@Deprecated
+	public void onWriteToNbt(NBTTagCompound tag) {
+		writeToNBT(tag);
+	}
+
+	// << backwards compatibility
+
+	// ******************************
+	// *** Methods for use by ic2 ***
+	// ******************************
+
+	// energy net interface >>
+
+	@Override
+	public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction) {
+		return true;
+	}
+
+	@Override
+	public double getDemandedEnergy() {
+		return Math.max(0, capacity - energyStored);
+	}
+
+	@Override
+	public double injectEnergy(ForgeDirection directionFrom, double amount, double voltage) {
+		energyStored += amount;
+
+		return 0;
+	}
+
+	@Override
+	public int getSinkTier() {
+		return tier;
+	}
+
+	// << energy net interface
+
+
+	public final TileEntity parent;
+
+	protected int capacity;
+	protected int tier;
+	protected double energyStored;
+	protected boolean addedToEnet;
+}

src/api/java/ic2/api/energy/prefab/BasicSource.java

@@ -0,0 +1,375 @@
+package ic2.api.energy.prefab;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+
+import cpw.mods.fml.common.FMLCommonHandler;
+
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import ic2.api.energy.EnergyNet;
+import ic2.api.energy.event.EnergyTileLoadEvent;
+import ic2.api.energy.event.EnergyTileUnloadEvent;
+import ic2.api.energy.tile.IEnergySource;
+import ic2.api.info.Info;
+import ic2.api.item.ElectricItem;
+
+/**
+ * BasicSource is a simple adapter to provide an ic2 energy source.
+ * 
+ * It's designed to be attached to a tile entity as a delegate. Functionally BasicSource acts as a
+ * one-time configurable output energy buffer, thus providing a common use case for generators.
+ * 
+ * Sub-classing BasicSource instead of using it as a delegate works as well, but isn't recommended.
+ * The delegate can be extended with additional functionality through a sub class though.
+ * 
+ * The constraints set by BasicSource like the strict tank-like energy buffering should provide a
+ * more easy to use and stable interface than using IEnergySource directly while aiming for
+ * optimal performance.
+ * 
+ * Using BasicSource involves the following steps:
+ * - create a BasicSource instance in your TileEntity, typically in a field
+ * - forward invalidate, onChunkUnload, readFromNBT, writeToNBT and updateEntity to the BasicSource
+ *   instance.
+ *   If you have other means of determining when the tile entity is fully loaded, notify onLoaded
+ *   that way instead of forwarding updateEntity.
+ * - call addEnergy whenever appropriate, using getFreeCapacity may determine if e.g. the generator
+ *   should run
+ * - optionally use getEnergyStored to display the output buffer charge level
+ * - optionally use setEnergyStored to sync the stored energy to the client (e.g. in the Container)
+ *
+ * Example implementation code:
+ * @code{.java}
+ * public class SomeTileEntity extends TileEntity {
+ *     // new basic energy source, 1000 EU buffer, tier 1 (32 EU/t, LV)
+ *     private BasicSource ic2EnergySource = new BasicSource(this, 1000, 1);
+ * 
+ *     @Override
+ *     public void invalidate() {
+ *         ic2EnergySource.invalidate(); // notify the energy source
+ *         ...
+ *         super.invalidate(); // this is important for mc!
+ *     }
+ * 
+ *     @Override
+ *     public void onChunkUnload() {
+ *         ic2EnergySource.onChunkUnload(); // notify the energy source
+ *         ...
+ *     }
+ * 
+ *     @Override
+ *     public void readFromNBT(NBTTagCompound tag) {
+ *         super.readFromNBT(tag);
+ * 
+ *         ic2EnergySource.readFromNBT(tag);
+ *         ...
+ *     }
+ * 
+ *     @Override
+ *     public void writeToNBT(NBTTagCompound tag) {
+ *         super.writeToNBT(tag);
+ * 
+ *         ic2EnergySource.writeToNBT(tag);
+ *         ...
+ *     }
+ * 
+ *     @Override
+ *     public void updateEntity() {
+ *         ic2EnergySource.updateEntity(); // notify the energy source
+ *         ...
+ *         ic2EnergySource.addEnergy(5); // add 5 eu to the source's buffer this tick
+ *         ...
+ *     }
+ * 
+ *     ...
+ * }
+ * @endcode
+ */
+public class BasicSource extends TileEntity implements IEnergySource {
+	// **********************************
+	// *** Methods for use by the mod ***
+	// **********************************
+
+	/**
+	 * Constructor for a new BasicSource delegate.
+	 * 
+	 * @param parent1 Base TileEntity represented by this energy source.
+	 * @param capacity1 Maximum amount of eu to store.
+	 * @param tier1 IC2 tier, 1 = LV, 2 = MV, ...
+	 */
+	public BasicSource(TileEntity parent1, double capacity1, int tier1) {
+		double power = EnergyNet.instance.getPowerFromTier(tier1);
+
+		this.parent = parent1;
+		this.capacity = capacity1 < power ? power : capacity1;
+		this.tier = tier1;
+		this.power = power;
+	}
+
+	// in-world te forwards	>>
+
+	/**
+	 * Forward for the base TileEntity's updateEntity(), used for creating the energy net link.
+	 * Either updateEntity or onLoaded have to be used.
+	 */
+	@Override
+	public void updateEntity() {
+		if (!addedToEnet) onLoaded();
+	}
+
+	/**
+	 * Notification that the base TileEntity finished loading, for advanced uses.
+	 * Either updateEntity or onLoaded have to be used.
+	 */
+	public void onLoaded() {
+		if (!addedToEnet &&
+				!FMLCommonHandler.instance().getEffectiveSide().isClient() &&
+				Info.isIc2Available()) {
+			worldObj = parent.getWorldObj();
+			xCoord = parent.xCoord;
+			yCoord = parent.yCoord;
+			zCoord = parent.zCoord;
+
+			MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this));
+
+			addedToEnet = true;
+		}
+	}
+
+	/**
+	 * Forward for the base TileEntity's invalidate(), used for destroying the energy net link.
+	 * Both invalidate and onChunkUnload have to be used.
+	 */
+	@Override
+	public void invalidate() {
+		super.invalidate();
+
+		onChunkUnload();
+	}
+
+	/**
+	 * Forward for the base TileEntity's onChunkUnload(), used for destroying the energy net link.
+	 * Both invalidate and onChunkUnload have to be used.
+	 */
+	@Override
+	public void onChunkUnload() {
+		if (addedToEnet &&
+				Info.isIc2Available()) {
+			MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this));
+
+			addedToEnet = false;
+		}
+	}
+
+	/**
+	 * Forward for the base TileEntity's readFromNBT(), used for loading the state.
+	 * 
+	 * @param tag Compound tag as supplied by TileEntity.readFromNBT()
+	 */
+	@Override
+	public void readFromNBT(NBTTagCompound tag) {
+		super.readFromNBT(tag);
+
+		NBTTagCompound data = tag.getCompoundTag("IC2BasicSource");
+
+		energyStored = data.getDouble("energy");
+	}
+
+	/**
+	 * Forward for the base TileEntity's writeToNBT(), used for saving the state.
+	 * 
+	 * @param tag Compound tag as supplied by TileEntity.writeToNBT()
+	 */
+	@Override
+	public void writeToNBT(NBTTagCompound tag) {
+		try {
+			super.writeToNBT(tag);
+		} catch (RuntimeException e) {
+			// happens if this is a delegate, ignore
+		}
+
+		NBTTagCompound data = new NBTTagCompound();
+
+		data.setDouble("energy", energyStored);
+
+		tag.setTag("IC2BasicSource", data);
+	}
+
+	// << in-world te forwards
+	// methods for using this adapter >>
+
+	/**
+	 * Get the maximum amount of energy this source can hold in its buffer.
+	 * 
+	 * @return Capacity in EU.
+	 */
+	public double getCapacity() {
+		return capacity;
+	}
+
+	/**
+	 * Set the maximum amount of energy this source can hold in its buffer.
+	 * 
+	 * @param capacity1 Capacity in EU.
+	 */
+	public void setCapacity(double capacity1) {
+		if (capacity1 < power) capacity1 = power;
+
+		this.capacity = capacity1;
+	}
+
+	/**
+	 * Get the IC2 energy tier for this source.
+	 * 
+	 * @return IC2 Tier.
+	 */
+	public int getTier() {
+		return tier;
+	}
+
+	/**
+	 * Set the IC2 energy tier for this source.
+	 * 
+	 * @param tier1 IC2 Tier.
+	 */
+	public void setTier(int tier1) {
+		double power = EnergyNet.instance.getPowerFromTier(tier1);
+
+		if (capacity < power) capacity = power;
+
+		this.tier = tier1;
+		this.power = power;
+	}
+
+
+	/**
+	 * Determine the energy stored in the source's output buffer.
+	 * 
+	 * @return amount in EU
+	 */
+	public double getEnergyStored() {
+		return energyStored;
+	}
+
+	/**
+	 * Set the stored energy to the specified amount.
+	 * 
+	 * This is intended for server -> client synchronization, e.g. to display the stored energy in
+	 * a GUI through getEnergyStored().
+	 * 
+	 * @param amount
+	 */
+	public void setEnergyStored(double amount) {
+		energyStored = amount;
+	}
+
+	/**
+	 * Determine the free capacity in the source's output buffer.
+	 * 
+	 * @return amount in EU
+	 */
+	public double getFreeCapacity() {
+		return capacity - energyStored;
+	}
+
+	/**
+	 * Add some energy to the output buffer.
+	 * 
+	 * @param amount maximum amount of energy to add
+	 * @return amount added/used, NOT remaining
+	 */
+	public double addEnergy(double amount) {
+		if (FMLCommonHandler.instance().getEffectiveSide().isClient()) return 0;
+		if (amount > capacity - energyStored) amount = capacity - energyStored;
+
+		energyStored += amount;
+
+		return amount;
+	}
+
+	/**
+	 * Charge the supplied ItemStack from this source's energy buffer.
+	 * 
+	 * @param stack ItemStack to charge (null is ignored)
+	 * @return true if energy was transferred
+	 */
+	public boolean charge(ItemStack stack) {
+		if (stack == null || !Info.isIc2Available()) return false;
+
+		double amount = ElectricItem.manager.charge(stack, energyStored, tier, false, false);
+
+		energyStored -= amount;
+
+		return amount > 0;
+	}
+
+	// << methods for using this adapter
+
+	// backwards compatibility (ignore these) >>
+
+	@Deprecated
+	public void onUpdateEntity() {
+		updateEntity();
+	}
+
+	@Deprecated
+	public void onInvalidate() {
+		invalidate();
+	}
+
+	@Deprecated
+	public void onOnChunkUnload() {
+		onChunkUnload();
+	}
+
+	@Deprecated
+	public void onReadFromNbt(NBTTagCompound tag) {
+		readFromNBT(tag);
+	}
+
+	@Deprecated
+	public void onWriteToNbt(NBTTagCompound tag) {
+		writeToNBT(tag);
+	}
+
+	// << backwards compatibility
+
+	// ******************************
+	// *** Methods for use by ic2 ***
+	// ******************************
+
+	// energy net interface >>
+
+	@Override
+	public boolean emitsEnergyTo(TileEntity receiver, ForgeDirection direction) {
+		return true;
+	}
+
+	@Override
+	public double getOfferedEnergy() {
+		return Math.min(energyStored, power);
+	}
+
+	@Override
+	public void drawEnergy(double amount) {
+		energyStored -= amount;
+	}
+
+	@Override
+	public int getSourceTier() {
+		return tier;
+	}
+
+	// << energy net interface
+
+
+	public final TileEntity parent;
+
+	protected double capacity;
+	protected int tier;
+	protected double power;
+	protected double energyStored;
+	protected boolean addedToEnet;
+}

src/api/java/ic2/api/energy/prefab/package-info.java

@@ -0,0 +1,4 @@
+@API(apiVersion="1.0", owner="IC2", provides="IC2API")
+package ic2.api.energy.prefab;
+import cpw.mods.fml.common.API;
+

src/api/java/ic2/api/energy/tile/IEnergyConductor.java

@@ -0,0 +1,53 @@
+package ic2.api.energy.tile;
+
+/**
+ * Tile entities which conduct energy pulses without buffering (mostly cables) have to implement this
+ * interface.
+ * 
+ * See ic2/api/energy/usage.txt for an overall description of the energy net api.
+ */
+public interface IEnergyConductor extends IEnergyAcceptor, IEnergyEmitter {
+	/**
+	 * Energy loss for the conductor in EU per block.
+	 * 
+	 * @return Energy loss
+	 */
+	double getConductionLoss();
+
+	/**
+	 * Amount of energy the insulation will handle before shocking nearby players and mobs.
+	 * 
+	 * @return Insulation energy absorption in EU
+	 */
+	double getInsulationEnergyAbsorption();
+
+	/**
+	 * Amount of energy the insulation will handle before it is destroyed.
+	 * Ensure that this value is greater than the insulation energy absorption + 64.
+	 *
+	 * @return Insulation-destroying energy in EU
+	 */
+	double getInsulationBreakdownEnergy();
+
+	/**
+	 * Amount of energy the conductor will handle before it melts.
+	 * 
+	 * @return Conductor-destroying energy in EU
+	 */
+	double getConductorBreakdownEnergy();
+
+	/**
+	 * Remove the conductor's insulation if the insulation breakdown energy was exceeded.
+	 * 
+	 * @see #getInsulationBreakdownEnergy()
+	 */
+	void removeInsulation();
+
+	/**
+	 * Remove the conductor if the conductor breakdown energy was exceeded.
+	 * 
+	 * @see #getConductorBreakdownEnergy()
+	 */
+	void removeConductor();
+}
+

src/api/java/ic2/api/energy/tile/IEnergySink.java

@@ -24,6 +24,7 @@ public interface IEnergySink extends IEnergyAcceptor {
 	 * 1 = LV, 2 = MV, 3 = HV, 4 = EV etc.
 	 * 
 	 * @note Modifying the energy net from this method is disallowed.
+	 * @note Return Integer.MAX_VALUE to allow any voltage.
 	 *
 	 * @return tier of this energy sink
 	 */

src/api/java/ic2/api/energy/tile/IHeatSource.java

@@ -0,0 +1,23 @@
+package ic2.api.energy.tile;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+public interface IHeatSource {
+	
+	/*
+	 *  Return max heat transmission peer Tick (only theoretical bandwidth not available amount)
+	 */
+	int  maxrequestHeatTick(ForgeDirection directionFrom);
+	
+	/*
+	 * @param requested amount of heat to transfer
+	 * 
+	 * @return transmitted amount of heat
+	 * 
+	 * example: You Request 100 units of heat but the Source have only 50 units left
+	 * 
+	 * requestHeat(100) : return 50 : so 50 units of heat remove from HeatSource
+	 */
+	
+	int requestHeat(ForgeDirection directionFrom, int requestheat);
+}

src/api/java/ic2/api/energy/tile/IKineticSource.java

@@ -0,0 +1,22 @@
+package ic2.api.energy.tile;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+public interface IKineticSource {
+	/*
+	 *  Return max kinetic energy transmission peer Tick (only theoretical bandwidth not available amount)
+	 */
+	int  maxrequestkineticenergyTick(ForgeDirection directionFrom);
+
+	/*
+	 * @param requested amount of kinetic energy to transfer
+	 * 
+	 * @return transmitted amount of kineticenergy
+	 * 
+	 * example: You Request 100 units of kinetic energy but the Source have only 50 units left
+	 * 
+	 * requestkineticenergy(100) : return 50 : so 50 units of kinetic energy remove from KineticSource
+	 */
+
+	int requestkineticenergy(ForgeDirection directionFrom, int requestkineticenergy);
+}

src/api/java/ic2/api/energy/tile/IMetaDelegate.java

@@ -0,0 +1,36 @@
+package ic2.api.energy.tile;
+
+import java.util.List;
+
+import net.minecraft.tileentity.TileEntity;
+
+/**
+ * Interface for grouping multi-block structures to a single energy net delegate.
+ * 
+ * The energy net uses TileEntity to refer to a specific xyz+world position. If multiple of those
+ * positions should belong to the same functional structure, i.e. they consume or produce energy
+ * only once for the whole multi-block instead of once per every single block, this interface
+ * allows to do so.
+ * 
+ * The tile entity implementing IMetaDelegate has to be added/removed to/from the energy net
+ * instead of every single sub-TileEntity. The energy net interaction will be handled by the
+ * IMetaDelegate TileEntity as well.
+ * 
+ * The sub tile array TileEntity[] just provides optional connectivity (IEnergyAcceptor,
+ * IEnergyEmitter) and mandatory position (x, y, z, World) data.
+ * If the connectivity data on the sub tile is missing, the meta delegate is queried instead.
+ * 
+ * See ic2/api/energy/usage.txt for an overall description of the energy net api.
+ */
+public interface IMetaDelegate extends IEnergyTile {
+	/**
+	 * Get the sub-TileEntities belonging to this Meta TileEntity.
+	 * 
+	 * @note The list has to be consistent between the EnergyNet Load and Unload events.
+	 * @note The list must have at least 1 element.
+	 * @note The parent te implementing IMetaDelegate isn't automatically included.
+	 * 
+	 * @return sub-TileEntity array
+	 */
+	List<TileEntity> getSubTiles();
+}

src/api/java/ic2/api/event/LaserEvent.java

@@ -0,0 +1,114 @@
+package ic2.api.event;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+import cpw.mods.fml.common.eventhandler.Cancelable;
+
+import net.minecraftforge.event.world.WorldEvent;
+
+/**
+ * A bunch of Events to handle the power of the Mining Laser.
+ */
+@Cancelable
+public class LaserEvent extends WorldEvent {
+	// the Laser Entity
+	public final Entity lasershot;
+
+	// the following variables can be changed and the Laser will adjust to them
+
+	// the Player firing the Laser. If the Laser gets "reflected" the Player could change.
+	public EntityLivingBase owner;
+	// Range of the Laser Shot. Determine the amount of broken blocks, as well, as each broken block will subtract ~1F from range.
+	public float range, power;
+	public int blockBreaks;
+	// Determines whether the laser will explode upon hitting something
+	public boolean explosive, smelt;
+
+	public LaserEvent(World world1, Entity lasershot1, EntityLivingBase owner1, float range1, float power1, int blockBreaks1, boolean explosive1, boolean smelt1) {
+		super(world1);
+		this.lasershot = lasershot1;
+		this.owner = owner1;
+		this.range = range1;
+		this.power = power1;
+		this.blockBreaks = blockBreaks1;
+		this.explosive = explosive1;
+		this.smelt = smelt1;
+	}
+
+	/**
+	 * Event when the Laser is getting shot by a Player.
+	 * 
+	 * The Item is the Laser Gun which the "Player" has shot
+	 */
+	public static class LaserShootEvent extends LaserEvent {
+		ItemStack laseritem;
+
+		public LaserShootEvent(World world1, Entity lasershot1, EntityLivingBase owner1, float range1, float power1, int blockBreaks1, boolean explosive1, boolean smelt1, ItemStack laseritem1) {
+			super(world1, lasershot1, owner1, range1, power1, blockBreaks1, explosive1, smelt1);
+			this.laseritem = laseritem1;
+		}
+	}
+
+	/**
+	 * Event when the Laser is exploding for some Reason.
+	 * 
+	 * The Laser will no longer exist after this Event is posted as it either Explodes or despawns after the Event is fired.
+	 */
+	public static class LaserExplodesEvent extends LaserEvent {
+		// explosion strength, even that can be changed!
+		public float explosionpower, explosiondroprate, explosionentitydamage;
+
+		public LaserExplodesEvent(World world1, Entity lasershot1, EntityLivingBase owner1, float range1, float power1, int blockBreaks1, boolean explosive1, boolean smelt1, float explosionpower1, float explosiondroprate1, float explosionentitydamage1) {
+			super(world1, lasershot1, owner1, range1, power1, blockBreaks1, explosive1, smelt1);
+			this.explosionpower = explosionpower1;
+			this.explosiondroprate = explosiondroprate1;
+			this.explosionentitydamage = explosionentitydamage1;
+		}
+	}
+
+	/**
+	 * Event when the Laser is hitting a Block
+	 * x, y and z are the Coords of the Block.
+	 * 
+	 * Canceling this Event stops the Laser from attempting to break the Block, what is very useful for Glass.
+	 * Use lasershot.setDead() to remove the Shot entirely.
+	 */
+	public static class LaserHitsBlockEvent extends LaserEvent {
+		// targeted block, even that can be changed!
+		public int x, y, z;
+		public int side;
+		// removeBlock determines if the Block will be removed. dropBlock determines if the Block should drop something.
+		public boolean removeBlock, dropBlock;
+		public float dropChance;
+
+		public LaserHitsBlockEvent(World world1, Entity lasershot1, EntityLivingBase owner1, float range1, float power1, int blockBreaks1, boolean explosive1, boolean smelt1, int x1, int y1, int z1, int side1, float dropChance1, boolean removeBlock1, boolean dropBlock1) {
+			super(world1, lasershot1, owner1, range1, power1, blockBreaks1, explosive1, smelt1);
+			this.x = x1;
+			this.y = y1;
+			this.z = z1;
+			this.side = side1;
+			this.removeBlock = removeBlock1;
+			this.dropBlock = dropBlock1;
+			this.dropChance = dropChance1;
+		}
+	}
+
+	/**
+	 * Event when the Laser is getting at a Living Entity
+	 * 
+	 * Canceling this Event ignores the Entity
+	 * Use lasershot.setDead() to remove the Shot entirely.
+	 */
+	public static class LaserHitsEntityEvent extends LaserEvent {
+		// the Entity which the Laser has shot at, even the target can be changed!
+		public Entity hitentity;
+
+		public LaserHitsEntityEvent(World world1, Entity lasershot1, EntityLivingBase owner1, float range1, float power1, int blockBreaks1, boolean explosive1, boolean smelt1, Entity hitentity1) {
+			super(world1, lasershot1, owner1, range1, power1, blockBreaks1, explosive1, smelt1);
+			this.hitentity = hitentity1;
+		}
+	}
+}

src/api/java/ic2/api/event/PaintEvent.java

@@ -0,0 +1,32 @@
+package ic2.api.event;
+
+import net.minecraft.world.World;
+
+import cpw.mods.fml.common.eventhandler.Cancelable;
+
+import net.minecraftforge.event.world.WorldEvent;
+
+@Cancelable
+public class PaintEvent extends WorldEvent {
+	// target block
+	public final int x;
+	public final int y;
+	public final int z;
+	public final int side;
+
+	// color to paint the block
+	public final int color;
+
+	// set to true to confirm the operation
+	public boolean painted = false;
+
+	public PaintEvent(World world1, int x1, int y1, int z1, int side1, int color1) {
+		super(world1);
+
+		this.x = x1;
+		this.y = y1;
+		this.z = z1;
+		this.side = side1;
+		this.color = color1;
+	}
+}

src/api/java/ic2/api/event/RetextureEvent.java

@@ -0,0 +1,37 @@
+package ic2.api.event;
+
+import net.minecraft.block.Block;
+import net.minecraft.world.World;
+
+import cpw.mods.fml.common.eventhandler.Cancelable;
+
+import net.minecraftforge.event.world.WorldEvent;
+
+@Cancelable
+public class RetextureEvent extends WorldEvent {
+	// target block
+	public final int x;
+	public final int y;
+	public final int z;
+	public final int side;
+
+	// referenced block (to grab the texture from)
+	public final Block referencedBlock;
+	public final int referencedMeta;
+	public final int referencedSide;
+
+	// set to true to confirm the operation
+	public boolean applied = false;
+
+	public RetextureEvent(World world1, int x1, int y1, int z1, int side1, Block referencedBlock, int referencedMeta1, int referencedSide1) {
+		super(world1);
+
+		this.x = x1;
+		this.y = y1;
+		this.z = z1;
+		this.side = side1;
+		this.referencedBlock = referencedBlock;
+		this.referencedMeta = referencedMeta1;
+		this.referencedSide = referencedSide1;
+	}
+}

src/api/java/ic2/api/event/package-info.java

@@ -0,0 +1,4 @@
+@API(apiVersion="1.0", owner="IC2", provides="IC2API")
+package ic2.api.event;
+import cpw.mods.fml.common.API;
+

src/api/java/ic2/api/info/IEnergyValueProvider.java

@@ -7,6 +7,9 @@ public interface IEnergyValueProvider {
 	 * Determine the energy value for a single item in the supplied stack.
 	 * The value is used by most machines in the discharge slot.
 	 * 
+	 * This only applies to basic single use items, others are to be queried
+	 * through e.g. ElectricItem.manager.getCharge().
+	 * 
 	 * @param itemStack ItemStack containing the item to evaluate.
 	 * @return energy in EU
 	 */

src/api/java/ic2/api/item/IBlockCuttingBlade.java

@@ -0,0 +1,6 @@
+package ic2.api.item;
+
+
+public interface IBlockCuttingBlade {
+	int gethardness();
+}

src/api/java/ic2/api/item/IBoxable.java

@@ -0,0 +1,14 @@
+package ic2.api.item;
+
+import net.minecraft.item.ItemStack;
+
+
+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/api/java/ic2/api/item/IC2Items.java

@@ -0,0 +1,598 @@
+package ic2.api.item;
+
+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 IC2Items {
+	/**
+	 * 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;
+			}
+			return null;
+		} catch (Exception e) {
+			System.out.println("IC2 API: Call getItem failed for "+name);
+
+			return null;
+		}
+	}
+
+	/* Possible values:
+
+	// 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
+	  leadOre;            // Lead Ore Block, currently not meta sensitive,  meta in ItemStack set to 0, ore dictionary: oreLead, null with enableWorldGenOreLead = 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
+
+	  constructionreinforcedFoam; //  Construction Reinforced Foam block, currently not meta sensitive
+	  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
+	  ironScaffold; 				// 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
+	  leadBlock;          // 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
+	  insulatedtinCableBlock;         // Insulated Tin Cable item, 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
+	  RTGenerator;             //  Radioisotope Thermoelectric Generator block, meta sensitive
+	  semifluidGenerator;      //  Semifluid Generator block, meta sensitive
+
+
+	// energy storages (TE implements IEnergySource and IEnergyConductor)
+
+	  batBox; 			// BatBox block, meta sensitive
+	  cesuUnit;           // CESU Unit 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
+	  evTransformer; 		// EV 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
+	  centrifuge;         // Centrifuge block, meta sensitive
+	  metalformer;         // MetalFormer block , meta sensitive
+	  orewashingplant;    // Ore Wasching Plant, Meta sensitive
+	  patternstorage;    // Pattern Storage, Meta sensitive
+	  scanner;           // Scanner, Meta sensitive
+	  replicator;           // Replicator, Meta sensitive
+
+	  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
+	  cropmatron; // Cropmatron machien block, meta sensititve
+
+	// ----- items -----
+
+	// rubber + related
+	  resin; 				// Resin item, currently not meta sensitive
+	  rubber; 			// Rubber item, currently not meta sensitive, ore dictionary: itemRubber
+
+	  FluidCell;
+
+	//  Lithium -> Tritium
+
+	  reactorLithiumCell;    // LithiumCell use in Reaktor, , meta = damage value
+	  TritiumCell;           // Tritium, currently not meta sensitive
+
+	// Nuclear Fuel
+
+	  UranFuel;               // , currently not meta sensitive
+	  MOXFuel;                // , currently not meta sensitive
+	  Plutonium;              // , currently not meta sensitive
+	  smallPlutonium;         // , currently not meta sensitive
+	  Uran235;                // , currently not meta sensitive
+	  smallUran235;           // , currently not meta sensitive
+	  Uran238;                // , currently not meta sensitive
+
+	  reactorDepletedUraniumSimple;   // Depleted Uranium Cell items, currently not meta sensitive
+	  reactorDepletedUraniumDual;
+	  reactorDepletedUraniumQuad;
+	  reactorDepletedMOXSimple;   // Depleted MOX Cell items, currently not meta sensitive
+	  reactorDepletedMOXDual;
+	  reactorDepletedMOXQuad;
+	  reactorMOXSimple;   // Depleted MOX Cell items, currently not meta sensitive
+	  reactorMOXDual;
+	  reactorMOXQuad;
+	  RTGPellets;
+
+
+	// Recipe Parts
+
+	  coil;                   // Coil,  meta sensitive
+	  elemotor;               // electric motor,  meta sensitive
+	  powerunit;              // Item Power Unit,  meta sensitive
+	  powerunitsmall;              // Item Power Unit,  meta sensitive
+
+
+	// ItemCasing
+
+	  casingcopper;           //  Copper ItemCasing,  meta sensitive
+	  casingtin;              //  Tin ItemCasing,  meta sensitive
+	  casingbronze;           //  Bronze ItemCasing,  meta sensitive
+	  casinggold;             //  Gold ItemCasing,  meta sensitive
+	  casingiron;             //  Iron ItemCasing,  meta sensitive
+	@Deprecated
+	  casingadviron;          //  Refined Iron ItemCasing,  meta sensitive
+	  casinglead;             //  Lead ItemCasing,  meta sensitive
+
+	// Crushed Ore
+	  crushedIronOre;       // Crushed Iron Ore,  meta sensitive
+	  crushedCopperOre;     // Crushed Copper Ore,  meta sensitive
+	  crushedGoldOre;       // Crushed Gold Ore,  meta sensitive
+	  crushedTinOre;        // Crushed Tin Ore,  meta sensitive
+	  crushedUraniumOre;    // Crushed Uranium Ore,  meta sensitive
+	  crushedSilverOre;     // Crushed Silver Ore,  meta sensitive
+	  crushedLeadOre;       // Crushed Lead Ore,  meta sensitive
+
+
+	//Purify Crushed Ore
+	  purifiedCrushedIronOre;       // Purify Crushed Iron Ore,  meta sensitive
+	  purifiedCrushedCopperOre;     // Purify Crushed Copper Ore,  meta sensitive
+	  purifiedCrushedGoldOre;       // Purify Crushed Gold Ore,  meta sensitive
+	  purifiedCrushedTinOre;        // Purify Crushed Tin Ore,  meta sensitive
+	  purifiedCrushedUraniumOre;    // Purify Crushed Uranium Ore,  meta sensitive
+	  purifiedCrushedSilverOre;     // Purify Crushed Silver Ore,  meta sensitive
+	  purifiedCrushedLeadOre;       // Purify Crushed Lead Ore,  meta sensitive
+
+	// dusts
+	  stoneDust;
+	  bronzeDust; 		// Bronze Dust item,   meta sensitive, ore dictionary: dustBronze
+	  clayDust; 			// Clay Dust item,   meta sensitive, ore dictionary: dustClay
+	  coalDust; 			// Coal Dust item,   meta sensitive, ore dictionary: dustCoal
+	  copperDust; 		// Copper Dust item,   meta sensitive, ore dictionary: dustCopper
+	  goldDust; 			// Gold Dust item,   meta sensitive, ore dictionary: dustGold
+	  ironDust; 			// Iron Dust item,   meta sensitive, ore dictionary: dustIron
+	  silverDust; 		// Silver Dust item,   meta sensitive, ore dictionary: dustSilver
+	  tinDust; 			// Tin Dust item,   meta sensitive, ore dictionary: dustTin
+	  hydratedCoalDust; 	// Hydrated Coal Dust item,   meta sensitive
+	  leadDust;           // Lead Dust item,   meta sensitive, ore dictionary: dustLead
+	  obsidianDust;       // Obsidian Dust item,   meta sensitive, ore dictionary: dustObsidian
+	  lapiDust;           // Lapi Dust item,   meta sensitive, ore dictionary: dustLapi
+	  sulfurDust;         // Sulfur Dust item,   meta sensitive, ore dictionary: dustSulfur
+	  lithiumDust;        // Lithium dust,   meta sensitive, ore dictionary: dustLithium
+
+	// small dusts
+
+	  smallIronDust;      // Small Iron Dust item,  meta sensitive
+	  smallCopperDust;    // Small Copper Dust item, meta sensitive
+	  smallGoldDust;      // Small Gold Dust item,  meta sensitive
+	  smallTinDust;       // Small Tin Dust item,  meta sensitive
+	  smallSilverDust;    // Small Silver Dust item,  meta sensitive
+	  smallLeadDust;      // Small Lead Dust item,  meta sensitive
+	  smallSulfurDust;    // Small Sulfur Dust item,  meta sensitive
+	  smallLithiumDust;   // Small Lithium Dust item,  meta sensitive
+
+
+	// ingots
+	@Deprecated
+	  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
+	  leadIngot;          // Lead Ingot item, currently not meta sensitive
+
+
+	// 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
+
+	  ForgeHammer;             // Refine Iron Hammer item, meta = damage value
+
+	// el. tools/devices/weapons
+	  miningDrill; 		// Mining Drill item, meta = damage value for charge level
+	  diamondDrill; 		// Diamond Tipped Mining Drill item, meta = damage value for charge level
+	  iridiumDrill;		// Iridium Tipped Mining Drill item, meta = damage value for charge level
+	  chainsaw; 			// Chainsaw item, meta = damage value for charge level
+	  electricWrench;		// Electric Wrench item, meta = damage value for charge level
+	  electricTreetap;	// Electric Treetap item, meta = damage value for charge level
+	  miningLaser; 		// Mining Laser item, meta = damage value for charge level
+
+	  ecMeter; 			// EC-Mater item, meta = itemdata db index (as of v1.45)
+	  odScanner; 			// Ore Density Scanner item, meta = damage value for charge level
+	  ovScanner; 			// Ore Value Scanner item, meta = damage value for charge level
+	  obscurator;			// Obscurator item, meta = damage value for charge level
+
+	  frequencyTransmitter; // Frequency Transmitter item, meta = itemdata db index (as of v1.45)
+
+	  nanoSaber; 			// Idle Nano Saber item, meta = damage value for charge level
+	  enabledNanoSaber; 	// Enabled Nano Saber item, meta = damage value for charge level
+
+	  toolbox; 			// Open/Empty toolbox, meta = Open (0) / Closed (1)
+
+	// armor/wearable
+	  hazmatHelmet; 		// Hazmat Helmet item, meta = damage value
+	  hazmatChestplate; 	// Hazmat Chestplate item, meta = damage value
+	  hazmatLeggings; 	// Hazmat Leggings item, meta = damage value
+	  hazmatBoots; 		// Hazmat 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 = damage value for charge level
+	  nanoBodyarmor; 		// Nano Bodyarmor item, meta = damage value for charge level
+	  nanoLeggings; 		// Nano Leggings Armor item, meta = damage value for charge level
+	  nanoBoots; 			// Nano Boots Armor item, meta = damage value for charge level
+
+	  quantumHelmet; 		// Quantum Helmet Armor item, meta = damage value for charge level
+	  quantumBodyarmor; 	// Quantum Bodyarmor item, meta = damage value for charge level
+	  quantumLeggings; 	// Quantum Leggings Armor item, meta = damage value for charge level
+	  quantumBoots; 		// Quantum Boots Armor item, meta = damage value for charge level
+
+	  jetpack; 			// Jetpack item, meta = damage value for fuel level
+	  electricJetpack; 	// Electric Jetpack item, meta = damage value for charge level
+
+	  batPack; 			// BatPack item, meta = damage value for charge level
+	  advbatPack; 		// Adv.BatPack item, meta = damage value for charge level
+	  lapPack; 			// LapPack item, meta = damage value for charge level
+	  energyPack; 		// EnergyPack item, meta = damage value for charge level
+
+	  cfPack; 			// CF Pack item, meta = charges (as of v1.45)
+	  solarHelmet;		// Solar Helmet, currently not meta sensitive
+	  staticBoots;		// Static Boots, currently not meta sensitive
+	  nightvisionGoggles;	// Nightvision Goggles, meta = damage value for charge level
+
+	// batteries
+	  reBattery; 			// Empty RE Battery item, currently not meta sensitive
+	  chargedReBattery; 	// RE Battery item, meta = damage value for charge level
+	  advBattery;         // Adv Batteryitem, meta = damage value for charge level
+	  energyCrystal; 		// Energy Crystal item, meta = damage value for charge level
+	  lapotronCrystal; 	// Lapotron Crystal item, meta = damage value for charge level
+	  suBattery; 			// SU Battery item, meta = damage value for charge level
+
+	// 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
+
+	@Deprecated
+	  doubleInsulatedGoldCableItem; 	// Double Insulated Gold Cable item, meta sensitive
+
+	  ironCableItem; 					// Iron Cable item, meta sensitive
+	  insulatedIronCableItem; 		// Insulated Iron Cable item, meta sensitive
+
+	@Deprecated
+	  doubleInsulatedIronCableItem; 	// Double Insulated Iron Cable item, meta sensitive
+	@Deprecated
+	  trippleInsulatedIronCableItem; 	// Tripple Insulated Iron Cable item, meta sensitive
+	  insulatedTinCableItem;
+	  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, meta sensitive
+	  lavaCell; 				// Lava Cell item,  meta sensitive
+	  waterCell; 				// Water Cell item, meta sensitive
+	  UuMatterCell;			// UUMatter Cell item, meta sensitive
+	  CFCell;					// constructionFoam Cell item, meta sensitive
+
+
+	  fuelRod;                // Empy Fuel Rod 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
+	  electrolyzedWaterCell; 	// Electrolyzed Water Cell item, currently not meta sensitive
+	  airCell; 				// Compressed Air 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
+	  reactorUraniumSimple; 	   // Uranium Cell items, meta = consumed uranium ticks
+	  reactorUraniumDual;
+	  reactorUraniumQuad;
+
+	  reactorCoolantSimple;
+	  reactorCoolantTriple ;		// Coolant Cell item, NBT for heat-storage, meta is 0-10000 for display
+	  reactorCoolantSix;
+
+	  reactorPlating; 			// Integrated Reactor Plating item, currently not meta sensitive
+	  reactorPlatingHeat;
+	  reactorPlatingExplosive;
+
+	  reactorHeatSwitch;	// Integrated Heat Disperser item,  NBT for heat-storage, meta is 0-10000 for display
+	  reactorHeatSwitchCore;
+	  reactorHeatSwitchSpread;
+	  reactorHeatSwitchDiamond;
+
+	  reactorVent;			// Heat Venting component,  NBT for heat-storage, meta is 0-10000 for display
+	  reactorVentCore;
+	  reactorVentGold;
+	  reactorVentSpread;// Special: Does not store heat
+	  reactorVentDiamond;
+
+	  reactorReflector;			// Increase efficiency without additional ticks,  NBT for heat-storage, meta is 0-10000 for display
+	  reactorReflectorThick;			// Increase efficiency without additional ticks,   NBT for heat-storage, meta is 0-10000 for display
+	  reactorCondensator;			// Consumes redstone to absorb heat, NBT for storage, meta is 0-10000 for display
+	  reactorCondensatorLap;			// Consumes redstone/lapis to absorb heat, mNBT for storage, meta is 0-10000 for display
+
+	// 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; 			// UUA item, currently not meta sensitive
+	  iridiumOre; 		// Iridium Ore item, currently not meta sensitive
+	  iridiumPlate; 		// Iridium Plate item, currently not meta sensitive
+
+
+	// Metal Plates
+
+	  platecopper;               // Metal plate item, meta sensitive
+	  platetin;                  // Metal plate item, meta sensitive
+	  platebronze;               // Metal plate item, meta sensitive
+	  plategold;                 // Metal plate item, meta sensitive
+	  plateiron;                 // Metal plate item, meta sensitive
+	  platelead;                  // Metal plate item, meta sensitive
+	  platelapi;                  // Metal plate item, meta sensitive
+	  plateobsidian;              // Metal plate item, meta sensitive
+	  plateadviron;              // Metal plate item, meta sensitive
+
+	// Metal Dense Plates
+	  denseplatecopper;               // Metal dense plate item, meta sensitive
+	  denseplatetin;                  // Metal dense plate item, meta sensitive
+	  denseplatebronze;               // Metal dense  plate item, meta sensitive
+	  denseplategold;                 // Metal dense plate item, meta sensitive
+	  denseplateiron;                 // Metal dense plate item, meta sensitive
+	@Deprecated
+	  denseplateadviron;              // Metal dense plate item, meta sensitive
+	  denseplatelead;                  // Metal dense plate item, meta sensitive
+	  denseplatelapi;                  // Metal dense plate item, meta sensitive
+	  denseplateobsidian;              // Metal dense plate item, meta sensitive
+
+
+	// upgrade modules
+	  overclockerUpgrade;		// overclocker upgrade item, meta sensitive
+	  transformerUpgrade;		// transformer upgrade item, meta sensitive
+	  energyStorageUpgrade;	// energy storage upgrade item, meta sensitive
+	  ejectorUpgrade;			// ejector upgrade item, meta sensitive
+
+	// misc
+	  coin; 					// Coin item, currently not meta sensitive
+	  reinforcedDoor; 		// Reinforced Door item, currently not meta sensitive
+	  constructionFoamPowder; // Construction Foam Powder item, currently not meta sensitive
+	  grinPowder;				// Poisonous ingrident, currently not meta sensitive
+	  debug;					// Debug item, currently not meta sensitive
+	  boatCarbon;				// Carbon Fiber Canoe item, meta sensitive
+	  boatRubber;				// Rubber Dinghy item, meta sensitive
+	  boatRubberBroken;		// Damaged Rubber Dinghy item, meta sensitive
+	  boatElectric;			// Electric Boat item, meta sensitive
+
+	//Agriculture
+	  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, Metadata indicates charge level
+	  terraWart;				// Mystic opposite of NEtherWart, cures StatusEffects, simply consumeable
+	  weedEx;					// Spraying can of WEED-EX, meta indicates usages left
+
+	//Boozeception
+	  mugEmpty;				// Simple stone mug
+	  coffeeBeans;			// Harvested CoffeeBeans
+	  coffeePowder; 			// Processed Coffee Beans, used to craft drinkable Coffee
+	  mugCoffee;				// Mug of Coffee, Meta indicates status 0 = cold, 1 = Normal, 2 = Sugar'd
+	  hops;					// Hops, harvested freshly from crop
+	  barrel; 				// Carried Barrel, metadata encrypts the information about the liquid inside
+	  blockBarrel;			// Unobtainable "placed barrel", TileEntity controlling the Fermentation process
+	  mugBooze; 				// Mug filled with booze, metadata encrypts the information about the liquid inside
+
+	 */
+
+	/**
+	 * 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 = IC2Items.class.getPackage();
+
+		if (pkg != null) {
+			String packageName = pkg.getName();
+
+			return packageName.substring(0, packageName.length() - ".api.item".length());
+		}
+
+		return "ic2";
+	}
+
+	private static Class<?> Ic2Items;
+}
+

src/api/java/ic2/api/item/IDebuggable.java

@@ -0,0 +1,22 @@
+package ic2.api.item;
+
+
+/**
+ * Allows a tile entity to output a debug message when the debugItem is used on it.
+ * Suggestions by Myrathi
+ */
+public abstract interface IDebuggable {
+    /**
+     * Checks if the tile entity is in a state that can be debugged.
+     *
+     * @return True if the tile entity can be debugged
+     */
+    public abstract boolean isDebuggable();
+
+    /**
+     * Gets the debug text for the tile entity.
+     *
+     * @return The text that the debugItem should show
+     */
+    public abstract String getDebugText();
+}

src/api/java/ic2/api/item/IItemHudInfo.java

@@ -0,0 +1,24 @@
+package ic2.api.item;
+
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+
+public interface IItemHudInfo {
+	/*
+    Add Info to Nano- and Quantum-Suit Helm Hud
+    for itemStack
+
+        @Override
+        public List<String> getHudInfo(ItemStack itemStack) {
+        List<String> info = new LinkedList<String>();
+        info.add("i am a Cool Item");
+        info.add("and have Cool info");
+        return info;
+    }
+
+
+	 */
+
+	public List<String> getHudInfo(ItemStack itemStack);
+}

src/api/java/ic2/api/item/IKineticWindRotor.java

@@ -0,0 +1,15 @@
+package ic2.api.item;
+
+import net.minecraft.util.ResourceLocation;
+
+public interface IKineticWindRotor {
+	public int getDiameter();
+
+	public ResourceLocation getRotorRenderTexture();
+
+	public float getefficiency();
+
+	int getminWindStrength();
+
+	int getmaxWindStrength();
+}

src/api/java/ic2/api/item/IMetalArmor.java

@@ -0,0 +1,20 @@
+package ic2.api.item;
+
+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/api/java/ic2/api/item/ITerraformingBP.java

@@ -0,0 +1,34 @@
+package ic2.api.item;
+
+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/api/java/ic2/api/item/ItemWrapper.java

@@ -0,0 +1,50 @@
+package ic2.api.item;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Multimap;
+
+/**
+ * Wrapper for inserting interfaces into items you don't own.
+ * 
+ * @author Richard
+ */
+public class ItemWrapper {
+	private static final Multimap<Item, IBoxable> boxableItems = ArrayListMultimap.create();
+	private static final Multimap<Item, IMetalArmor> metalArmorItems = ArrayListMultimap.create();
+	
+	public static void registerBoxable(Item item, IBoxable boxable) {
+		boxableItems.put(item, boxable);
+	}
+	
+	public static boolean canBeStoredInToolbox(ItemStack stack) {
+		Item item = stack.getItem();
+		// use customs first to allow for overriding behavior
+		for (IBoxable boxable : boxableItems.get(item)) {
+			if (boxable.canBeStoredInToolbox(stack)) return true;
+		}
+		
+		if (item instanceof IBoxable && ((IBoxable) item).canBeStoredInToolbox(stack)) return true;
+		
+		return false;
+	}
+	
+	public static void registerMetalArmor(Item item, IMetalArmor armor) {
+		metalArmorItems.put(item, armor);
+	}
+	
+	public static boolean isMetalArmor(ItemStack stack, EntityPlayer player) {
+		Item item = stack.getItem();
+		// use customs first to allow for overriding behavior
+		for (IMetalArmor metalArmor : metalArmorItems.get(item)) {
+			if (metalArmor.isMetalArmor(stack, player)) return true;
+		}
+		
+		if (item instanceof IMetalArmor && ((IMetalArmor) item).isMetalArmor(stack, player)) return true;
+		
+		return false;
+	}
+}

src/api/java/ic2/api/network/INetworkClientTileEntityEventListener.java

@@ -0,0 +1,17 @@
+package ic2.api.network;
+
+import net.minecraft.entity.player.EntityPlayer;
+
+/**
+ * Allows a tile entity to receive network events received from clients.
+ */
+public interface INetworkClientTileEntityEventListener {
+	/**
+	 * Called when a network event is received.
+	 * 
+	 * @param player client which sent the event
+	 * @param event event ID
+	 */
+	void onNetworkEvent(EntityPlayer player, int event);
+}
+

src/api/java/ic2/api/network/INetworkDataProvider.java

@@ -0,0 +1,18 @@
+package ic2.api.network;
+
+import java.util.List;
+
+/**
+ * Tile entities which want to synchronized specific fields between client and server have to implement this.
+ * 
+ * The fields don't update themselves, a field update must be sent every time a synchronized field changes.
+ */
+public interface INetworkDataProvider {
+	/**
+	 * Get the list of synchronized fields.
+	 * 
+	 * @return Names of the synchronized fields
+	 */
+	List<String> getNetworkedFields();
+}
+

src/api/java/ic2/api/network/INetworkItemEventListener.java

@@ -0,0 +1,19 @@
+package ic2.api.network;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+
+/**
+ * Allows an item to receive network events received from the server.
+ */
+public interface INetworkItemEventListener {
+	/**
+	 * Called when a network event is received.
+	 * 
+	 * @param itemStack item stack
+	 * @param player player containing the item
+	 * @param event event ID
+	 */
+	void onNetworkEvent(ItemStack stack, EntityPlayer player, int event);
+}
+

src/api/java/ic2/api/network/INetworkTileEntityEventListener.java

@@ -0,0 +1,14 @@
+package ic2.api.network;
+
+/**
+ * Allows a tile entity to receive network events received from the server.
+ */
+public interface INetworkTileEntityEventListener {
+	/**
+	 * Called when a network event is received.
+	 * 
+	 * @param event Event ID
+	 */
+	void onNetworkEvent(int event);
+}
+

src/api/java/ic2/api/network/INetworkUpdateListener.java

@@ -0,0 +1,14 @@
+package ic2.api.network;
+
+/**
+ * Allows a tile entity to receive field sync updates received from the server. 
+ */
+public interface INetworkUpdateListener {
+	/**
+	 * Called when a field is synchronized.
+	 * 
+	 * @param field field synchronized
+	 */
+	void onNetworkUpdate(String field);
+}
+

src/api/java/ic2/api/network/NetworkHelper.java

@@ -0,0 +1,194 @@
+package ic2.api.network;
+
+import java.lang.reflect.Method;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+
+/**
+ * Provides methods to initiate events and synchronize tile entity fields in SMP.
+ *
+ * The methods are transparent between singleplayer and multiplayer - if a method is called in
+ * singleplayer, the associated callback will be locally executed. The implementation is different
+ * between the client and server versions of IC2.
+ *
+ * You'll usually want to use the server->client methods defined here to synchronize information
+ * which is needed by the clients outside the GUI, such as rendering the block, playing sounds or
+ * producing effects. Anything which is only visible inside the GUI should be synchronized through
+ * the Container class associated to the GUI in Container.updateProgressBar().
+ */
+public final class NetworkHelper {
+	// server -> client
+
+
+	/**
+	 * Schedule a TileEntity's field to be updated to the clients in range.
+	 *
+	 * The updater will query the field's value during the next update, updates happen usually
+	 * every 2 ticks. If low latency is important use initiateTileEntityEvent instead.
+	 *
+	 * IC2's network updates have to get triggered every time, it doesn't continuously poll/send
+	 * the field value. Just call updateTileEntityField after every change to a field which needs
+	 * network synchronization.
+	 *
+	 * The following field data types are currently supported:
+	 *  - int, int[], short, short[], byte, byte[], long, long[]
+	 *  - float, float[], double, double[]
+	 *  - boolean, boolean[]
+	 *  - String, String[]
+	 *  - ItemStack
+	 *  - NBTBase (includes NBTTagCompound)
+	 *  - Block, Item, Achievement, Potion, Enchantment
+	 *  - ChunkCoordinates, ChunkCoordIntPair
+	 *  - TileEntity (does not sync the actual tile entity, instead looks up the tile entity by its position in the client world)
+	 *  - World (does not sync the actual world, instead looks up the world by its dimension ID)
+	 *
+	 * Once the update has been processed by the client, it'll call onNetworkUpdate on the client-
+	 * side TileEntity if it implements INetworkUpdateListener.
+	 *
+	 * If this method is being executed on the client (i.e. Singleplayer), it'll just call
+	 * INetworkUpdateListener.onNetworkUpdate (if implemented by the te).
+	 *
+	 * @param te TileEntity to update
+	 * @param field Name of the field to update
+	 */
+	public static void updateTileEntityField(TileEntity te, String field) {
+		try {
+			if (NetworkManager_updateTileEntityField == null) NetworkManager_updateTileEntityField = Class.forName(getPackage() + ".core.network.NetworkManager").getMethod("updateTileEntityField", TileEntity.class, String.class);
+			if (instance == null) instance = getInstance();
+
+			NetworkManager_updateTileEntityField.invoke(instance, te, field);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	/**
+	 * Immediately send an event for the specified TileEntity to the clients in range.
+	 *
+	 * If this method is being executed on the client (i.e. Singleplayer), it'll just call
+	 * INetworkTileEntityEventListener.onNetworkEvent (if implemented by the te).
+	 *
+	 * @param te TileEntity to notify, should implement INetworkTileEntityEventListener
+	 * @param event Arbitrary integer to represent the event, choosing the values is up to you
+	 * @param limitRange Limit the notification range to (currently) 20 blocks instead of the
+	 *        tracking distance if true
+	 */
+	public static void initiateTileEntityEvent(TileEntity te, int event, boolean limitRange) {
+		try {
+			if (NetworkManager_initiateTileEntityEvent == null) NetworkManager_initiateTileEntityEvent = Class.forName(getPackage() + ".core.network.NetworkManager").getMethod("initiateTileEntityEvent", TileEntity.class, Integer.TYPE, Boolean.TYPE);
+			if (instance == null) instance = getInstance();
+
+			NetworkManager_initiateTileEntityEvent.invoke(instance, te, event, limitRange);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	/**
+	 * Immediately send an event for the specified Item to the clients in range.
+	 *
+	 * The item should implement INetworkItemEventListener to receive the event.
+	 *
+	 * If this method is being executed on the client (i.e. Singleplayer), it'll just call
+	 * INetworkItemEventListener.onNetworkEvent (if implemented by the item).
+	 *
+	 * @param player EntityPlayer holding the item
+	 * @param itemStack ItemStack containing the item
+	 * @param event Arbitrary integer to represent the event, choosing the values is up to you
+	 * @param limitRange Limit the notification range to (currently) 20 blocks instead of the
+	 *        tracking distance if true
+	 */
+	public static void initiateItemEvent(EntityPlayer player, ItemStack itemStack, int event, boolean limitRange) {
+		try {
+			if (NetworkManager_initiateItemEvent == null) NetworkManager_initiateItemEvent = Class.forName(getPackage() + ".core.network.NetworkManager").getMethod("initiateItemEvent", EntityPlayer.class, ItemStack.class, Integer.TYPE, Boolean.TYPE);
+			if (instance == null) instance = getInstance();
+
+			NetworkManager_initiateItemEvent.invoke(instance, player, itemStack, event, limitRange);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+
+	// client -> server
+
+	/**
+	 * Immediately send an event for the specified TileEntity to the server.
+	 *
+	 * This method doesn't do anything if executed on the server.
+	 *
+	 * @param te TileEntity to notify, should implement INetworkClientTileEntityEventListener
+	 * @param event Arbitrary integer to represent the event, choosing the values is up to you
+	 */
+	public static void initiateClientTileEntityEvent(TileEntity te, int event) {
+		try {
+			if (NetworkManager_initiateClientTileEntityEvent == null) NetworkManager_initiateClientTileEntityEvent = Class.forName(getPackage() + ".core.network.NetworkManager").getMethod("initiateClientTileEntityEvent", TileEntity.class, Integer.TYPE);
+			if (instance == null) instance = getInstance();
+
+			NetworkManager_initiateClientTileEntityEvent.invoke(instance, te, event);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	/**
+	 * Immediately send an event for the specified Item to the clients in range.
+	 *
+	 * The item should implement INetworkItemEventListener to receive the event.
+	 *
+	 * This method doesn't do anything if executed on the server.
+	 *
+	 * @param itemStack ItemStack containing the item
+	 * @param event Arbitrary integer to represent the event, choosing the values is up to you
+	 */
+	public static void initiateClientItemEvent(ItemStack itemStack, int event) {
+		try {
+			if (NetworkManager_initiateClientItemEvent == null) NetworkManager_initiateClientItemEvent = Class.forName(getPackage() + ".core.network.NetworkManager").getMethod("initiateClientItemEvent", ItemStack.class, Integer.TYPE);
+			if (instance == null) instance = getInstance();
+
+			NetworkManager_initiateClientItemEvent.invoke(instance, itemStack, event);
+		} 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 = NetworkHelper.class.getPackage();
+
+		if (pkg != null) {
+			String packageName = pkg.getName();
+
+			return packageName.substring(0, packageName.length() - ".api.network".length());
+		}
+
+		return "ic2";
+	}
+
+	/**
+	 * Get the NetworkManager instance, used internally.
+	 *
+	 * @return NetworkManager instance
+	 */
+	private static Object getInstance() {
+		try {
+			return Class.forName(getPackage() + ".core.IC2").getDeclaredField("network").get(null);
+		} catch (Throwable e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private static Object instance;
+	private static Method NetworkManager_updateTileEntityField;
+	private static Method NetworkManager_initiateTileEntityEvent;
+	private static Method NetworkManager_initiateItemEvent;
+	private static Method NetworkManager_initiateClientTileEntityEvent;
+	private static Method NetworkManager_initiateClientItemEvent;
+}
+

src/api/java/ic2/api/network/package-info.java

@@ -0,0 +1,4 @@
+@API(apiVersion="1.0", owner="IC2", provides="IC2API")
+package ic2.api.network;
+import cpw.mods.fml.common.API;
+