AE2 First Commit, the dawn of 1.7 hast arrived.

items/AEBaseItem.java

@@ -0,0 +1,52 @@
+package appeng.items;
+
+import java.util.EnumSet;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import appeng.core.Configuration;
+import appeng.core.features.AEFeature;
+import appeng.core.features.AEFeatureHandler;
+import appeng.core.features.IAEFeature;
+
+public class AEBaseItem extends Item implements IAEFeature
+{
+
+	String FeatureFullname;
+	String FeatureSubname;
+	AEFeatureHandler feature;
+
+	@Override
+	public String toString()
+	{
+		return FeatureFullname;
+	}
+
+	@Override
+	public AEFeatureHandler feature()
+	{
+		return feature;
+	}
+
+	public void setfeature(EnumSet<AEFeature> f)
+	{
+		feature = new AEFeatureHandler( f, this, FeatureSubname );
+	}
+
+	public AEBaseItem(Class c) {
+		this( c, null );
+	}
+
+	public AEBaseItem(Class c, String subname) {
+		super( Configuration.instance.getItemID( c, subname ) );
+		FeatureSubname = subname;
+		FeatureFullname = AEFeatureHandler.getName( c, subname );
+	}
+
+	@Override
+	public boolean isBookEnchantable(ItemStack itemstack1, ItemStack itemstack2)
+	{
+		return false;
+	}
+
+}

items/ItemEncodedPattern.java

@@ -0,0 +1,25 @@
+package appeng.items;
+
+import java.util.EnumSet;
+
+import net.minecraft.item.ItemStack;
+import appeng.api.crafting.ICraftingPatternMAC;
+import appeng.api.implementations.ICraftingPatternItem;
+import appeng.core.features.AEFeature;
+
+public class ItemEncodedPattern extends AEBaseItem implements ICraftingPatternItem
+{
+
+	public ItemEncodedPattern() {
+		super( ItemEncodedPattern.class );
+		setfeature( EnumSet.of( AEFeature.Crafting ) );
+	}
+
+	@Override
+	public ICraftingPatternMAC getPatternForItem(ItemStack is)
+	{
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+}

items/materials/ItemMaterial.java

@@ -0,0 +1,90 @@
+package appeng.items.materials;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.oredict.OreDictionary;
+import appeng.api.implementations.IStorageComponent;
+import appeng.items.AEBaseItem;
+
+public class ItemMaterial extends AEBaseItem implements IStorageComponent
+{
+
+	final MaterialType material;
+
+	public ItemMaterial(MaterialType type) {
+		super( ItemMaterial.class, type.name() );
+		setfeature( type.getFeature() );
+		material = type;
+
+		if ( type.getOreName() != null )
+			OreDictionary.registerOre( type.getOreName(), this );
+	}
+
+	@Override
+	public boolean hasCustomEntity(ItemStack is)
+	{
+		return material.hasCustomEntity();
+	}
+
+	@Override
+	public Entity createEntity(World w, Entity location, ItemStack itemstack)
+	{
+		Class<? extends Entity> droppedEntity = material.getCustomEntityClass();
+		Entity eqi;
+
+		try
+		{
+			eqi = droppedEntity.getConstructor( World.class, double.class, double.class, double.class, ItemStack.class ).newInstance( w, location.posX,
+					location.posY, location.posZ, itemstack );
+		}
+		catch (Throwable t)
+		{
+			throw new RuntimeException( t );
+		}
+
+		eqi.motionX = location.motionX;
+		eqi.motionY = location.motionY;
+		eqi.motionZ = location.motionZ;
+
+		if ( location instanceof EntityItem && eqi instanceof EntityItem )
+			((EntityItem) eqi).delayBeforeCanPickup = ((EntityItem) location).delayBeforeCanPickup;
+
+		return eqi;
+	}
+
+	@Override
+	public int getBytes(ItemStack is)
+	{
+		switch (material)
+		{
+		case Cell1kPart:
+			return 1024;
+		case Cell4kPart:
+			return 1024 * 4;
+		case Cell16kPart:
+			return 1024 * 16;
+		case Cell64kPart:
+			return 1024 * 64;
+		default:
+		}
+		return 0;
+	}
+
+	@Override
+	public boolean isStorageComponent(ItemStack is)
+	{
+		switch (material)
+		{
+		case Cell1kPart:
+		case Cell4kPart:
+		case Cell16kPart:
+		case Cell64kPart:
+			return true;
+		default:
+		}
+		return false;
+	}
+
+}

items/materials/MaterialType.java

@@ -0,0 +1,97 @@
+package appeng.items.materials;
+
+import java.util.EnumSet;
+
+import net.minecraft.entity.Entity;
+import net.minecraftforge.oredict.OreDictionary;
+import appeng.client.render.entity.EntityIds;
+import appeng.core.AppEng;
+import appeng.core.features.AEFeature;
+import appeng.entity.EntityChargedQuartz;
+import appeng.entity.EntitySingularity;
+import cpw.mods.fml.common.registry.EntityRegistry;
+
+public enum MaterialType
+{
+	CertusQuartzCrystal(AEFeature.Core), CertusQuartzCrystalCharged(AEFeature.Core, EntityChargedQuartz.class),
+
+	CertusQuartzDust, NetherQuartzDust(AEFeature.Core, "dustNetherQuartz"), Flour(AEFeature.Flour, "dustWheat"), GoldDust(AEFeature.Core, "dustGold"), IronDust(
+			AEFeature.Core, "dustIron"), IronNugget(AEFeature.Core, "nuggetIron"),
+
+	Silicon(AEFeature.Core, "itemSilicon"), MatterBall,
+
+	FluixCrystal(AEFeature.Core, "crystalFLuix"), FluixDust(AEFeature.Core, "dustFluix"), FluixPearl(AEFeature.Core, "pearlFluix"),
+
+	PureifiedCertusQuartzCrystal, PureifiedNetherQuartzCrystal, PureifiedFluixCrystal,
+
+	LogicProcessorAsm(AEFeature.QuartzKnife), LogicProcessor,
+
+	CalcProcessor, EngProcessor,
+
+	// Basic Cards
+	BasicCard, CardRedstone, CardCapacity,
+
+	// Adv Cards
+	AdvCard, CardFuzzy, CardSpeed,
+
+	Cell2SpatialPart(AEFeature.SpatialIO), Cell16SpatialPart(AEFeature.SpatialIO), Cell128SpatialPart(AEFeature.SpatialIO),
+
+	Cell1kPart(AEFeature.StorageCells), Cell4kPart(AEFeature.StorageCells), Cell16kPart(AEFeature.StorageCells), Cell64kPart(AEFeature.StorageCells), EmptyStorageCell(
+			AEFeature.StorageCells),
+
+	WoodenGear(AEFeature.GrindStone, "gearWood"),
+
+	Wireless(AEFeature.WirelessAccessTerminal), WirelessBooster(AEFeature.WirelessAccessTerminal),
+
+	BlankPattern, FormationCore, AnnihilationCore,
+
+	EnderDust(AEFeature.QuantumNetworkBridge, "dustEnder"), Singularity(AEFeature.QuantumNetworkBridge), QESingularity(AEFeature.QuantumNetworkBridge,
+			EntitySingularity.class);
+
+	private String oreName;
+	private EnumSet<AEFeature> features;
+	private Class<? extends Entity> droppedEntity;
+
+	MaterialType() {
+		features = EnumSet.of( AEFeature.Core );
+	}
+
+	MaterialType(AEFeature part) {
+		features = EnumSet.of( part );
+	}
+
+	MaterialType(AEFeature part, Class<? extends Entity> c) {
+		features = EnumSet.of( part );
+		droppedEntity = c;
+
+		EntityRegistry.registerModEntity( droppedEntity, droppedEntity.getSimpleName(), EntityIds.get( droppedEntity ), AppEng.instance, 16, 4, true );
+	}
+
+	MaterialType(AEFeature part, String oreDictionary) {
+		features = EnumSet.of( part );
+		oreName = oreDictionary;
+		if ( OreDictionary.getOres( oreDictionary ).size() > 0 )
+			features.add( AEFeature.DuplicateItems );
+	}
+
+	public EnumSet<AEFeature> getFeature()
+	{
+		return features;
+	}
+
+	public String getOreName()
+	{
+		return oreName;
+	}
+
+	public boolean hasCustomEntity()
+	{
+		return droppedEntity != null;
+	}
+
+	public Class<? extends Entity> getCustomEntityClass()
+	{
+		return droppedEntity;
+	}
+
+}

items/parts/ItemFacade.java

@@ -0,0 +1,167 @@
+package appeng.items.parts;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockGlass;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import net.minecraftforge.client.MinecraftForgeClient;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.AEApi;
+import appeng.block.solids.OreQuartz;
+import appeng.client.render.BusRenderer;
+import appeng.core.features.AEFeature;
+import appeng.facade.FacadePart;
+import appeng.facade.IFacadeItem;
+import appeng.items.AEBaseItem;
+import appeng.util.Platform;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemFacade extends AEBaseItem implements IFacadeItem
+{
+
+	public ItemFacade() {
+		super( ItemFacade.class );
+		setfeature( EnumSet.of( AEFeature.Facades ) );
+		setHasSubtypes( true );
+		if ( Platform.isClient() )
+			MinecraftForgeClient.registerItemRenderer( this.itemID, BusRenderer.instance );
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int getSpriteNumber()
+	{
+		return 0;
+	}
+
+	@Override
+	public boolean onItemUse(ItemStack is, EntityPlayer player, World w, int x, int y, int z, int side, float hitX, float hitY, float hitZ)
+	{
+		return AEApi.instance().partHelper().placeBus( is, x, y, z, side, player, w );
+	}
+
+	@Override
+	public FacadePart createPartFromItemStack(ItemStack is, ForgeDirection side)
+	{
+		ItemStack in = getTextureItem( is );
+		if ( in != null )
+			return new FacadePart( is, side );
+		return null;
+	}
+
+	List<ItemStack> subTypes = null;
+
+	@Override
+	public void getSubItems(int number, CreativeTabs tab, List list)
+	{
+		calculateSubTypes();
+		list.addAll( subTypes );
+	}
+
+	public ItemStack createFromInts(int[] ids)
+	{
+		ItemStack is = new ItemStack( AEApi.instance().items().itemFacade.item() );
+		NBTTagCompound data = new NBTTagCompound();
+		data.setIntArray( "x", ids );
+		is.setTagCompound( data );
+		return is;
+	}
+
+	@Override
+	public ItemStack getTextureItem(ItemStack is)
+	{
+		Block blk = getBlock( is );
+		if ( blk != null )
+			return new ItemStack( blk, 1, getMeta( is ) );
+		return null;
+	}
+
+	private void calculateSubTypes()
+	{
+		if ( subTypes == null )
+		{
+			subTypes = new ArrayList();
+			for (Block b : Block.blocksList)
+			{
+				if ( b != null && (b.isOpaqueCube() && !b.getTickRandomly() && !(b instanceof OreQuartz)) || b instanceof BlockGlass )
+				{
+					try
+					{
+						List<ItemStack> tmpList = new ArrayList();
+						b.getSubBlocks( b.blockID, b.getCreativeTabToDisplayOn(), tmpList );
+						for (ItemStack l : tmpList)
+						{
+							ItemStack is = new ItemStack( this );
+							NBTTagCompound data = new NBTTagCompound();
+							int[] ds = new int[2];
+							ds[0] = l.itemID;
+							ds[1] = l.getItem().getMetadata( l.getItemDamage() );
+							data.setIntArray( "x", ds );
+							is.setTagCompound( data );
+
+							subTypes.add( is );
+						}
+					}
+					catch (Throwable t)
+					{
+						// just absorb..
+					}
+				}
+			}
+		}
+	}
+
+	@Override
+	public Block getBlock(ItemStack is)
+	{
+		NBTTagCompound data = is.getTagCompound();
+		if ( data != null )
+		{
+			int[] blk = data.getIntArray( "x" );
+			if ( blk != null && blk.length == 2 )
+				return Block.blocksList[blk[0]];
+		}
+		return Block.glass;
+	}
+
+	@Override
+	public int getMeta(ItemStack is)
+	{
+		NBTTagCompound data = is.getTagCompound();
+		if ( data != null )
+		{
+			int[] blk = data.getIntArray( "x" );
+			if ( blk != null && blk.length == 2 )
+				return blk[1];
+		}
+		return 0;
+	}
+
+	@Override
+	public String getItemDisplayName(ItemStack is)
+	{
+		try
+		{
+			ItemStack in = getTextureItem( is );
+			if ( in != null )
+			{
+				return super.getItemDisplayName( is ) + " - " + in.getDisplayName();
+			}
+		}
+		catch (Throwable t)
+		{
+
+		}
+
+		return super.getItemDisplayName( is );
+	}
+
+}

items/parts/ItemPart.java

@@ -0,0 +1,73 @@
+package appeng.items.parts;
+
+import java.util.List;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import appeng.api.AEApi;
+import appeng.api.parts.IPartItem;
+import appeng.api.parts.IPart;
+import appeng.items.AEBaseItem;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemPart extends AEBaseItem implements IPartItem
+{
+
+	final PartType part;
+
+	public ItemPart(PartType type) {
+		super( ItemPart.class, type.name() );
+		setfeature( type.getFeature() );
+		AEApi.instance().partHelper().setItemBusRenderer( this );
+		part = type;
+		if ( type == PartType.CableSmart || type == PartType.CableCovered || type == PartType.CableGlass )
+		{
+			setHasSubtypes( true );
+		}
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int getSpriteNumber()
+	{
+		return 0;
+	}
+
+	@Override
+	public boolean onItemUse(ItemStack is, EntityPlayer player, World w, int x, int y, int z, int side, float hitX, float hitY,
+			float hitZ)
+	{
+		return AEApi.instance().partHelper().placeBus( is, x, y, z, side, player, w );
+	}
+
+	@Override
+	public IPart createPartFromItemStack(ItemStack is)
+	{
+		try
+		{
+			return part.getPart().getConstructor( ItemStack.class ).newInstance( is );
+		}
+		catch (Throwable e)
+		{
+			throw new RuntimeException( "Unable to construct IBusPart from IBusItem : " + part.getPart().getName()
+					+ " ; Possibly didn't have correct constructor( ItemStack )", e );
+		}
+	}
+
+	@Override
+	public void getSubItems(int number, CreativeTabs tab, List list)
+	{
+		if ( part == PartType.CableSmart || part == PartType.CableCovered || part == PartType.CableGlass )
+		{
+			list.add( new ItemStack( this, 1, 16 ) );
+			for (int x = 0; x < 16; x++)
+				list.add( new ItemStack( this, 1, x ) );
+			return;
+		}
+		super.getSubItems( number, tab, list );
+	}
+
+}

items/parts/PartType.java

@@ -0,0 +1,93 @@
+package appeng.items.parts;
+
+import java.util.EnumSet;
+
+import appeng.api.parts.IPart;
+import appeng.core.features.AEFeature;
+import appeng.parts.automation.PartAnnihilationPlane;
+import appeng.parts.automation.PartExportBus;
+import appeng.parts.automation.PartFormationPlane;
+import appeng.parts.automation.PartImportBus;
+import appeng.parts.automation.PartLevelEmitter;
+import appeng.parts.misc.PartCableAnchor;
+import appeng.parts.misc.PartInvertedToggleBus;
+import appeng.parts.misc.PartP2PTunnel;
+import appeng.parts.misc.PartStorageBus;
+import appeng.parts.misc.PartToggleBus;
+import appeng.parts.networking.PartCableCovered;
+import appeng.parts.networking.PartCableGlass;
+import appeng.parts.networking.PartCableSmart;
+import appeng.parts.networking.PartQuartzFiber;
+import appeng.parts.reporting.PartConversionMonitor;
+import appeng.parts.reporting.PartCraftingMonitor;
+import appeng.parts.reporting.PartCraftingTerminal;
+import appeng.parts.reporting.PartDarkMonitor;
+import appeng.parts.reporting.PartMonitor;
+import appeng.parts.reporting.PartPatternTerminal;
+import appeng.parts.reporting.PartSemiDarkMonitor;
+import appeng.parts.reporting.PartStorageMonitor;
+import appeng.parts.reporting.PartTerminal;
+
+public enum PartType
+{
+	ToggleBus(AEFeature.Core, PartToggleBus.class),
+
+	InvertedToggleBus(AEFeature.Core, PartInvertedToggleBus.class),
+
+	CableSmart(AEFeature.Core, PartCableSmart.class), CableCovered(AEFeature.Core, PartCableCovered.class), CableGlass(AEFeature.Core, PartCableGlass.class),
+
+	CableAnchor(AEFeature.Core, PartCableAnchor.class),
+
+	QuartzFiber(AEFeature.Core, PartQuartzFiber.class),
+
+	Monitior(AEFeature.Core, PartMonitor.class),
+
+	SemiDarkMonitor(AEFeature.Core, PartSemiDarkMonitor.class),
+
+	DarkMonitor(AEFeature.Core, PartDarkMonitor.class),
+
+	StorageBus(AEFeature.StorageBus, PartStorageBus.class),
+
+	ImportBus(AEFeature.ImportBus, PartImportBus.class),
+
+	ExportBus(AEFeature.ExportBus, PartExportBus.class),
+
+	LevelEmitter(AEFeature.LevelEmiter, PartLevelEmitter.class),
+
+	AnnihilationPlane(AEFeature.AnnihilationPlane, PartAnnihilationPlane.class),
+
+	FormationPlane(AEFeature.FormationPlane, PartFormationPlane.class),
+
+	P2PTunnel(AEFeature.P2PTunnel, PartP2PTunnel.class),
+
+	CraftingMonitor(AEFeature.Crafting, PartCraftingMonitor.class),
+
+	PatternTerminal(AEFeature.CraftingTerminal, PartPatternTerminal.class),
+
+	CraftingTerminal(AEFeature.CraftingTerminal, PartCraftingTerminal.class),
+
+	Terminal(AEFeature.Core, PartTerminal.class),
+
+	StorageMonitor(AEFeature.StorageMonitor, PartStorageMonitor.class),
+
+	ConversionMonitor(AEFeature.PartConversionMonitor, PartConversionMonitor.class);
+
+	private EnumSet<AEFeature> features;
+	private Class<? extends IPart> myPart;
+
+	PartType(AEFeature part, Class<? extends IPart> c) {
+		features = EnumSet.of( part );
+		myPart = c;
+	}
+
+	public EnumSet<AEFeature> getFeature()
+	{
+		return features;
+	}
+
+	public Class<? extends IPart> getPart()
+	{
+		return myPart;
+	}
+
+}

items/storage/ItemBasicStorageCell.java

@@ -0,0 +1,119 @@
+package appeng.items.storage;
+
+import java.util.EnumSet;
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.StatCollector;
+import appeng.api.implementations.IStorageCell;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.core.features.AEFeature;
+import appeng.items.AEBaseItem;
+import appeng.items.materials.MaterialType;
+import appeng.me.storage.CellInventory;
+import appeng.me.storage.CellInventoryHandler;
+
+public class ItemBasicStorageCell extends AEBaseItem implements IStorageCell
+{
+
+	final MaterialType component;
+	final int totalBytes;
+	final double idleDrain;
+
+	public ItemBasicStorageCell(MaterialType whichCell, int Kilobytes) {
+		super( ItemBasicStorageCell.class, Kilobytes + "k" );
+		setfeature( EnumSet.of( AEFeature.StorageCells ) );
+		maxStackSize = 1;
+		totalBytes = Kilobytes * 1024;
+		component = whichCell;
+
+		switch (component)
+		{
+		case Cell1kPart:
+			idleDrain = 0.5;
+			break;
+		case Cell4kPart:
+			idleDrain = 1.0;
+			break;
+		case Cell16kPart:
+			idleDrain = 1.5;
+			break;
+		case Cell64kPart:
+			idleDrain = 2.0;
+			break;
+		default:
+			idleDrain = 0.0;
+		}
+	}
+
+	@Override
+	public void addInformation(ItemStack i, EntityPlayer p, List l, boolean b)
+	{
+		CellInventory cd = ((CellInventoryHandler) CellInventory.getCell( i )).getCellInv();
+
+		if ( cd != null )
+		{
+			l.add( cd.usedBytes() + " " + StatCollector.translateToLocal( "Appeng.GuiITooltip.Of" ) + " " + cd.totalBytes() + " "
+					+ StatCollector.translateToLocal( "Appeng.GuiITooltip.BytesUsed" ) );
+			l.add( cd.storedItemTypes() + " " + StatCollector.translateToLocal( "Appeng.GuiITooltip.Of" ) + " " + cd.getTotalItemTypes() + " "
+					+ StatCollector.translateToLocal( "Appeng.GuiITooltip.Types" ) );
+			/*
+			 * if ( cd.isPreformatted() ) { String List = StatCollector.translateToLocal( cd.getListMode() ==
+			 * ListMode.WHITELIST ? "AppEng.Gui.Whitelisted" : "AppEng.Gui.Blacklisted" ); if ( cd.isFuzzyPreformatted()
+			 * ) l.add( StatCollector.translateToLocal( "Appeng.GuiITooltip.Partitioned" ) + " - " + List + " " +
+			 * StatCollector.translateToLocal( "Appeng.GuiITooltip.Fuzzy" ) ); else l.add(
+			 * StatCollector.translateToLocal( "Appeng.GuiITooltip.Partitioned" ) + " - " + List + " " +
+			 * StatCollector.translateToLocal( "Appeng.GuiITooltip.Precise" ) ); }
+			 */
+		}
+	}
+
+	@Override
+	public int getBytes(ItemStack cellItem)
+	{
+		return totalBytes;
+	}
+
+	@Override
+	public int BytePerType(ItemStack iscellItem)
+	{
+		return 8;
+	}
+
+	@Override
+	public int getTotalTypes(ItemStack cellItem)
+	{
+		return 63;
+	}
+
+	@Override
+	public boolean isBlackListed(ItemStack cellItem, IAEItemStack requsetedAddition)
+	{
+		Item i = requsetedAddition.getItem();
+
+		if ( i instanceof IStorageCell )
+			return !((IStorageCell) i).storableInStorageCell();
+
+		return false;
+	}
+
+	@Override
+	public boolean storableInStorageCell()
+	{
+		return false;
+	}
+
+	@Override
+	public boolean isStorageCell(ItemStack i)
+	{
+		return true;
+	}
+
+	@Override
+	public double getIdleDrain()
+	{
+		return idleDrain;
+	}
+}

items/storage/ItemCreativeStorageCell.java

@@ -0,0 +1,17 @@
+package appeng.items.storage;
+
+import java.util.EnumSet;
+
+import appeng.core.features.AEFeature;
+import appeng.items.AEBaseItem;
+
+public class ItemCreativeStorageCell extends AEBaseItem
+{
+
+	public ItemCreativeStorageCell() {
+		super( ItemCreativeStorageCell.class );
+		setfeature( EnumSet.of( AEFeature.StorageCells, AEFeature.Creative ) );
+		maxStackSize = 1;
+	}
+
+}

items/storage/ItemSpatialStorageCell.java

@@ -0,0 +1,21 @@
+package appeng.items.storage;
+
+import java.util.EnumSet;
+
+import appeng.core.features.AEFeature;
+import appeng.items.AEBaseItem;
+import appeng.items.materials.MaterialType;
+
+public class ItemSpatialStorageCell extends AEBaseItem
+{
+	final MaterialType component;
+	final int maxRegion;
+
+	public ItemSpatialStorageCell(MaterialType whichCell, int spatialScale) {
+		super( ItemSpatialStorageCell.class, spatialScale + "Cubed" );
+		setfeature( EnumSet.of( AEFeature.SpatialIO ) );
+		maxRegion = spatialScale;
+		component = whichCell;
+	}
+
+}

items/tools/ToolMemoryCard.java

@@ -0,0 +1,82 @@
+package appeng.items.tools;
+
+import java.util.EnumSet;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.StatCollector;
+import appeng.api.implementations.IMemoryCard;
+import appeng.api.implementations.MemoryCardMessages;
+import appeng.core.features.AEFeature;
+import appeng.core.localization.PlayerMessages;
+import appeng.items.AEBaseItem;
+import appeng.util.Platform;
+
+public class ToolMemoryCard extends AEBaseItem implements IMemoryCard
+{
+
+	public ToolMemoryCard() {
+		super( ToolMemoryCard.class );
+		setfeature( EnumSet.of( AEFeature.Core ) );
+	}
+
+	@Override
+	public void addInformation(ItemStack i, EntityPlayer p, List l, boolean b)
+	{
+		l.add( StatCollector.translateToLocal( getSettingsName( i ) ) );
+		NBTTagCompound data = getData( i );
+		if ( data.hasKey( "tooltip" ) )
+		{
+			l.add( StatCollector.translateToLocal( data.getString( "tooltip" ) ) );
+		}
+	}
+
+	@Override
+	public void setMemoryCardContents(ItemStack is, String SettingsName, NBTTagCompound data)
+	{
+		NBTTagCompound c = Platform.openNbtData( is );
+		c.setString( "Config", SettingsName );
+		;
+		c.setCompoundTag( "Data", data );
+	}
+
+	@Override
+	public String getSettingsName(ItemStack is)
+	{
+		NBTTagCompound c = Platform.openNbtData( is );
+		String name = c.getString( "Config" );
+		return name == null || name == "" ? "gui.appliedenergistics2.Blank" : name;
+	}
+
+	@Override
+	public NBTTagCompound getData(ItemStack is)
+	{
+		NBTTagCompound c = Platform.openNbtData( is );
+		NBTTagCompound o = c.getCompoundTag( "Data" );
+		if ( o == null )
+			o = new NBTTagCompound();
+		return (NBTTagCompound) o.copy();
+	}
+
+	@Override
+	public void notifyUser(Block blk, EntityPlayer player, MemoryCardMessages msg)
+	{
+		switch (msg)
+		{
+		case INVALID_MACHINE:
+			player.sendChatToPlayer( PlayerMessages.InvalidMachine.get() );
+			break;
+		case SETTINGS_LOADED:
+			player.sendChatToPlayer( PlayerMessages.LoadedSettings.get() );
+			break;
+		case SETTINGS_SAVED:
+			player.sendChatToPlayer( PlayerMessages.SavedSettings.get() );
+			break;
+		default:
+		}
+	}
+
+}

items/tools/powered/ToolChargedStaff.java

@@ -0,0 +1,53 @@
+package appeng.items.tools.powered;
+
+import java.io.IOException;
+import java.util.EnumSet;
+
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.DamageSource;
+import appeng.core.features.AEFeature;
+import appeng.core.sync.packets.PacketLightning;
+import appeng.items.tools.powered.powersink.AEBasePoweredItem;
+import appeng.server.ServerHelper;
+import appeng.util.Platform;
+
+public class ToolChargedStaff extends AEBasePoweredItem
+{
+
+	public ToolChargedStaff() {
+		super( ToolChargedStaff.class, null );
+		setfeature( EnumSet.of( AEFeature.ChargedStaff, AEFeature.PoweredTools ) );
+		maxStoredPower = 8000;
+	}
+
+	@Override
+	public boolean hitEntity(ItemStack item, EntityLivingBase target, EntityLivingBase hitter)
+	{
+		if ( this.getAECurrentPower( item ) > 300 )
+		{
+			extractAEPower( item, 300 );
+			if ( Platform.isServer() )
+			{
+				try
+				{
+					for (int x = 0; x < 2; x++)
+					{
+						float dx = (float) (Platform.getRandomFloat() * target.width + target.boundingBox.minX);
+						float dy = (float) (Platform.getRandomFloat() * target.height + target.boundingBox.minY);
+						float dz = (float) (Platform.getRandomFloat() * target.width + target.boundingBox.minZ);
+						ServerHelper.proxy.sendToAllNearExcept( null, dx, dy, dz, 32.0, target.worldObj, (new PacketLightning( dx, dy, dz )).getPacket() );
+					}
+				}
+				catch (IOException e)
+				{
+
+				}
+			}
+			target.attackEntityFrom( DamageSource.magic, 6 );
+			return true;
+		}
+
+		return false;
+	}
+}

items/tools/powered/ToolEntropyManipulator.java

@@ -0,0 +1,268 @@
+package appeng.items.tools.powered;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.Hashtable;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.FurnaceRecipes;
+import net.minecraft.util.EnumMovingObjectType;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.core.features.AEFeature;
+import appeng.items.tools.powered.powersink.AEBasePoweredItem;
+import appeng.util.InWorldToolOperationResult;
+import appeng.util.Platform;
+
+public class ToolEntropyManipulator extends AEBasePoweredItem
+{
+
+	static private Hashtable<String, InWorldToolOperationResult> heatUp;
+	static private Hashtable<String, InWorldToolOperationResult> coolDown;
+
+	static public void heat(int BlockID, int Metadata, World w, int x, int y, int z)
+	{
+		InWorldToolOperationResult r = heatUp.get( BlockID + ":" + Metadata );
+
+		if ( r == null )
+		{
+			r = heatUp.get( BlockID + ":*" );
+		}
+
+		if ( r.BlockItem != null )
+		{
+			w.setBlock( x, y, z, r.BlockItem.itemID, r.BlockItem.getItemDamage(), 3 );
+		}
+		else
+		{
+			w.setBlock( x, y, z, 0, 0, 3 );
+		}
+
+		if ( r.Drops != null )
+		{
+			Platform.spawnDrops( w, x, y, z, r.Drops );
+		}
+	}
+
+	static public boolean canHeat(int BlockID, int Metadata)
+	{
+		InWorldToolOperationResult r = heatUp.get( BlockID + ":" + Metadata );
+
+		if ( r == null )
+		{
+			r = heatUp.get( BlockID + ":*" );
+		}
+
+		return r != null;
+	}
+
+	static public void cool(int BlockID, int Metadata, World w, int x, int y, int z)
+	{
+		InWorldToolOperationResult r = coolDown.get( BlockID + ":" + Metadata );
+
+		if ( r == null )
+		{
+			r = coolDown.get( BlockID + ":*" );
+		}
+
+		if ( r.BlockItem != null )
+		{
+			w.setBlock( x, y, z, r.BlockItem.itemID, r.BlockItem.getItemDamage(), 3 );
+		}
+		else
+		{
+			w.setBlock( x, y, z, 0, 0, 3 );
+		}
+
+		if ( r.Drops != null )
+		{
+			Platform.spawnDrops( w, x, y, z, r.Drops );
+		}
+	}
+
+	static public boolean canCool(int BlockID, int Metadata)
+	{
+		InWorldToolOperationResult r = coolDown.get( BlockID + ":" + Metadata );
+
+		if ( r == null )
+		{
+			r = coolDown.get( BlockID + ":*" );
+		}
+
+		return r != null;
+	}
+
+	public ToolEntropyManipulator() {
+		super( ToolEntropyManipulator.class, null );
+		setfeature( EnumSet.of( AEFeature.EntropyManipulator, AEFeature.PoweredTools ) );
+
+		coolDown = new Hashtable<String, InWorldToolOperationResult>();
+		coolDown.put( Block.stone.blockID + ":0", new InWorldToolOperationResult( new ItemStack( Block.cobblestone ) ) );
+		coolDown.put( Block.stoneBrick.blockID + ":0", new InWorldToolOperationResult( new ItemStack( Block.stoneBrick, 1, 2 ) ) );
+		coolDown.put( Block.lavaStill.blockID + ":*", new InWorldToolOperationResult( new ItemStack( Block.obsidian ) ) );
+		coolDown.put( Block.lavaMoving.blockID + ":*", new InWorldToolOperationResult( new ItemStack( Block.obsidian ) ) );
+		coolDown.put( Block.grass.blockID + ":*", new InWorldToolOperationResult( new ItemStack( Block.dirt ) ) );
+
+		List<ItemStack> snowBalls = new ArrayList();
+		snowBalls.add( new ItemStack( Item.snowball ) );
+		coolDown.put( Block.waterMoving.blockID + ":*", new InWorldToolOperationResult( null, snowBalls ) );
+		coolDown.put( Block.waterStill.blockID + ":*", new InWorldToolOperationResult( new ItemStack( Block.ice ) ) );
+
+		heatUp = new Hashtable<String, InWorldToolOperationResult>();
+		heatUp.put( Block.ice.blockID + ":0", new InWorldToolOperationResult( new ItemStack( Block.waterStill ) ) );
+		heatUp.put( Block.waterMoving.blockID + ":*", new InWorldToolOperationResult() );
+		heatUp.put( Block.waterStill.blockID + ":*", new InWorldToolOperationResult() );
+		heatUp.put( Block.blockSnow.blockID + ":*", new InWorldToolOperationResult( new ItemStack( Block.waterStill ) ) );
+	}
+
+	@Override
+	public boolean hitEntity(ItemStack item, EntityLivingBase target, EntityLivingBase hitter)
+	{
+		if ( this.getAECurrentPower( item ) > 1600 )
+		{
+			extractAEPower( item, 1600 );
+			target.setFire( 8 );
+		}
+
+		return false;
+	}
+
+	@Override
+	public ItemStack onItemRightClick(ItemStack item, World w, EntityPlayer p)
+	{
+		MovingObjectPosition target = this.getMovingObjectPositionFromPlayer( w, p, true );
+
+		if ( target == null )
+			return item;
+		else
+		{
+			if ( target.typeOfHit == EnumMovingObjectType.TILE )
+			{
+				int x = target.blockX;
+				int y = target.blockY;
+				int z = target.blockZ;
+
+				if ( w.getBlockMaterial( x, y, z ) == Material.lava || w.getBlockMaterial( x, y, z ) == Material.water )
+				{
+					if ( w.canMineBlock( p, x, y, z ) )
+					{
+						onItemUse( item, p, w, x, y, z, 0, 0.0F, 0.0F, 0.0F );
+					}
+				}
+			}
+		}
+
+		return item;
+	}
+
+	@Override
+	public boolean onItemUse(ItemStack item, EntityPlayer p, World w, int x, int y, int z, int side, float hitX, float hitY, float hitZ)
+	{
+		if ( this.getAECurrentPower( item ) > 1600 )
+		{
+			if ( !p.canPlayerEdit( x, y, z, side, item ) )
+				return false;
+
+			int BlockID = w.getBlockId( x, y, z );
+			int Metadata = w.getBlockMetadata( x, y, z );
+
+			if ( p.isSneaking() )
+			{
+				if ( canCool( BlockID, Metadata ) )
+				{
+					extractAEPower( item, 1600 );
+					cool( BlockID, Metadata, w, x, y, z );
+					return true;
+				}
+			}
+			else
+			{
+				if ( canHeat( BlockID, Metadata ) )
+				{
+					extractAEPower( item, 1600 );
+					heat( BlockID, Metadata, w, x, y, z );
+					return true;
+				}
+
+				ItemStack[] stack = Platform.getBlockDrops( w, x, y, z );
+				List<ItemStack> out = new ArrayList<ItemStack>();
+				boolean hasFurnaceable = false;
+				boolean canFurnaceable = true;
+
+				for (ItemStack i : stack)
+				{
+					ItemStack result = FurnaceRecipes.smelting().getSmeltingResult( i );
+
+					if ( result != null )
+					{
+						if ( result.getItem() instanceof ItemBlock )
+						{
+							if ( ((ItemBlock) result.getItem()).getBlockID() == BlockID && result.getItem().getDamage( result ) == Metadata )
+							{
+								canFurnaceable = false;
+							}
+						}
+						hasFurnaceable = true;
+						out.add( result );
+					}
+					else
+					{
+						canFurnaceable = false;
+						out.add( i );
+					}
+				}
+
+				if ( hasFurnaceable && canFurnaceable )
+				{
+					extractAEPower( item, 1600 );
+					InWorldToolOperationResult or = InWorldToolOperationResult.getBlockOperationResult( out.toArray( new ItemStack[out.size()] ) );
+					w.playSoundEffect( (double) x + 0.5D, (double) y + 0.5D, (double) z + 0.5D, "fire.ignite", 1.0F, itemRand.nextFloat() * 0.4F + 0.8F );
+
+					if ( or.BlockItem == null )
+					{
+						w.setBlock( x, y, z, 0, 0, 3 );
+					}
+					else
+					{
+						w.setBlock( x, y, z, or.BlockItem.itemID, or.BlockItem.getItemDamage(), 3 );
+					}
+
+					if ( or.Drops != null )
+					{
+						Platform.spawnDrops( w, x, y, z, or.Drops );
+					}
+
+					return true;
+				}
+				else
+				{
+					ForgeDirection dir = ForgeDirection.getOrientation( side );
+					x += dir.offsetX;
+					y += dir.offsetY;
+					z += dir.offsetZ;
+
+					if ( !p.canPlayerEdit( x, y, z, side, item ) )
+						return false;
+
+					if ( w.isAirBlock( x, y, z ) )
+					{
+						w.playSoundEffect( (double) x + 0.5D, (double) y + 0.5D, (double) z + 0.5D, "fire.ignite", 1.0F, itemRand.nextFloat() * 0.4F + 0.8F );
+						w.setBlock( x, y, z, Block.fire.blockID );
+					}
+
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+}

items/tools/powered/ToolMassCannon.java

@@ -0,0 +1,16 @@
+package appeng.items.tools.powered;
+
+import java.util.EnumSet;
+
+import appeng.core.features.AEFeature;
+import appeng.items.tools.powered.powersink.AEBasePoweredItem;
+
+public class ToolMassCannon extends AEBasePoweredItem
+{
+
+	public ToolMassCannon() {
+		super( ToolMassCannon.class, null );
+		setfeature( EnumSet.of( AEFeature.MatterCannon, AEFeature.PoweredTools ) );
+	}
+
+}

items/tools/powered/ToolWirelessTerminal.java

@@ -0,0 +1,54 @@
+package appeng.items.tools.powered;
+
+import java.util.EnumSet;
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.StatCollector;
+import net.minecraft.world.World;
+import appeng.api.AEApi;
+import appeng.core.features.AEFeature;
+import appeng.items.tools.powered.powersink.AEBasePoweredItem;
+import appeng.util.Platform;
+
+public class ToolWirelessTerminal extends AEBasePoweredItem
+{
+
+	String name;
+	int DISTNACE_CALC = 2;
+
+	public ToolWirelessTerminal() {
+		super( ToolWirelessTerminal.class, null );
+		setfeature( EnumSet.of( AEFeature.WirelessAccessTerminal, AEFeature.PoweredTools ) );
+	}
+
+	@Override
+	public ItemStack onItemRightClick(ItemStack item, World w, EntityPlayer player)
+	{
+		AEApi.instance().registries().wireless().OpenWirelessTermainlGui( item, w, player );
+		return item;
+	}
+
+	@Override
+	public void addInformation(ItemStack i, EntityPlayer p, List l, boolean b)
+	{
+		if ( i.hasTagCompound() )
+		{
+			NBTTagCompound tag = Platform.openNbtData( i );
+			if ( tag != null )
+			{
+				String encKey = tag.getString( "encKey" );
+
+				if ( encKey == null || encKey == "" )
+					l.add( StatCollector.translateToLocal( "AppEng.GuiITooltip.Unlinked" ) );
+				else
+					l.add( StatCollector.translateToLocal( "AppEng.GuiITooltip.Linked" ) );
+			}
+		}
+		else
+			l.add( StatCollector.translateToLocal( "AppEng.GuiITooltip.Unlinked" ) );
+	}
+
+}

items/tools/powered/powersink/AEBasePoweredItem.java

@@ -0,0 +1,10 @@
+package appeng.items.tools.powered.powersink;
+
+public class AEBasePoweredItem extends UniversalElectricity
+{
+
+	public AEBasePoweredItem(Class c, String subname) {
+		super( c, subname );
+	}
+
+}

items/tools/powered/powersink/AERootPoweredItem.java

@@ -0,0 +1,179 @@
+package appeng.items.tools.powered.powersink;
+
+import java.text.MessageFormat;
+import java.util.List;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import appeng.api.config.AccessRestriction;
+import appeng.api.config.PowerUnits;
+import appeng.api.implementations.IAEItemPowerStorage;
+import appeng.items.AEBaseItem;
+import appeng.util.Platform;
+
+public class AERootPoweredItem extends AEBaseItem implements IAEItemPowerStorage
+{
+
+	private enum batteryOperation
+	{
+		STORAGE, INJECT, EXTRACT
+	};
+
+	public double maxStoredPower = 200000;
+
+	public AERootPoweredItem(Class c, String subname) {
+		super( c, subname );
+		setMaxDamage( 32 );
+		hasSubtypes = false;
+	}
+
+	@Override
+	public void addInformation(ItemStack is, EntityPlayer player, List lines, boolean advancedItemTooltips)
+	{
+		NBTTagCompound tag = is.getTagCompound();
+		double internalCurrentPower = 0;
+		double internalMaxPower = getAEMaxPower( is );
+
+		if ( tag != null )
+		{
+			internalCurrentPower = tag.getDouble( "internalCurrentPower" );
+		}
+
+		double percent = internalCurrentPower / internalMaxPower;
+
+		lines.add( Platform.gui_localize( "Stored Energy" ) + ":" + MessageFormat.format( " {0,number,#} ", internalCurrentPower )
+				+ Platform.gui_localize( PowerUnits.AE.unlocalizedName ) + " - " + MessageFormat.format( " {0,number,#.##%} ", percent ) );
+
+	}
+
+	@Override
+	public boolean isDamageable()
+	{
+		return true;
+	}
+
+	@Override
+	public boolean isDamaged(ItemStack stack)
+	{
+		return true;
+	}
+
+	@Override
+	public boolean isRepairable()
+	{
+		return false;
+	}
+
+	@Override
+	public void setDamage(ItemStack stack, int damage)
+	{
+
+	}
+
+	final String EnergyVar = "internalCurrentPower";
+
+	private double getInternalBattery(ItemStack is, batteryOperation op, double adjustment)
+	{
+		NBTTagCompound data = Platform.openNbtData( is );
+
+		double currentStorage = data.getDouble( EnergyVar );
+		double maxStorage = getAEMaxPower( is );
+
+		switch (op)
+		{
+		case INJECT:
+			currentStorage += adjustment;
+			if ( currentStorage > maxStorage )
+			{
+				double diff = currentStorage - maxStorage;
+				data.setDouble( EnergyVar, maxStorage );
+				return diff;
+			}
+			data.setDouble( EnergyVar, currentStorage );
+			return 0;
+		case EXTRACT:
+			if ( currentStorage > adjustment )
+			{
+				currentStorage -= adjustment;
+				data.setDouble( EnergyVar, currentStorage );
+				return adjustment;
+			}
+			data.setDouble( EnergyVar, 0 );
+			return currentStorage;
+		default:
+			break;
+		}
+
+		return currentStorage;
+	}
+
+	/**
+	 * inject external
+	 */
+	double injectExternalPower(PowerUnits input, ItemStack is, double amount, boolean simulate)
+	{
+		if ( simulate )
+		{
+			int requiredEU = (int) PowerUnits.AE.convertTo( PowerUnits.EU, getAEMaxPower( is ) - getAECurrentPower( is ) );
+			if ( amount < requiredEU )
+				return 0;
+			return amount - requiredEU;
+		}
+		else
+		{
+			double powerRemainder = injectAEPower( is, PowerUnits.EU.convertTo( PowerUnits.AE, amount ) );
+			return PowerUnits.AE.convertTo( PowerUnits.EU, powerRemainder );
+		}
+	}
+
+	@Override
+	public double injectAEPower(ItemStack is, double amt)
+	{
+		return getInternalBattery( is, batteryOperation.INJECT, amt );
+	}
+
+	@Override
+	public double extractAEPower(ItemStack is, double amt)
+	{
+		return getInternalBattery( is, batteryOperation.EXTRACT, amt );
+	}
+
+	@Override
+	public double getAEMaxPower(ItemStack is)
+	{
+		return maxStoredPower;
+	}
+
+	@Override
+	public double getAECurrentPower(ItemStack is)
+	{
+		return getInternalBattery( is, batteryOperation.STORAGE, 0 );
+	}
+
+	@Override
+	public AccessRestriction getPowerFlow(ItemStack is)
+	{
+		return AccessRestriction.WRITE;
+	}
+
+	@Override
+	public int getDisplayDamage(ItemStack is)
+	{
+		return 32 - (int) (32 * (getAECurrentPower( is ) / getAEMaxPower( is )));
+	}
+
+	@Override
+	public void getSubItems(int id, CreativeTabs tab, List list)
+	{
+		super.getSubItems( id, tab, list );
+
+		ItemStack charged = new ItemStack( this, 1 );
+		NBTTagCompound tag = Platform.openNbtData( charged );
+		tag.setDouble( "internalCurrentPower", getAEMaxPower( charged ) );
+		tag.setDouble( "internalMaxPower", getAEMaxPower( charged ) );
+		list.add( charged );
+	}
+
+}

items/tools/powered/powersink/IC2.java

@@ -0,0 +1,63 @@
+package appeng.items.tools.powered.powersink;
+
+import ic2.api.item.IElectricItemManager;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.item.ItemStack;
+import appeng.api.config.PowerUnits;
+
+public class IC2 extends AERootPoweredItem implements IElectricItemManager
+{
+
+	public IC2(Class c, String subname) {
+		super( c, subname );
+	}
+
+	@Override
+	public int charge(ItemStack is, int amount, int tier, boolean ignoreTransferLimit, boolean simulate)
+	{
+		return amount - ((int) injectExternalPower( PowerUnits.EU, is, amount, simulate ));
+	}
+
+	@Override
+	public int discharge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate)
+	{
+		return 0;
+	}
+
+	@Override
+	public int getCharge(ItemStack is)
+	{
+		return (int) PowerUnits.AE.convertTo( PowerUnits.EU, getAECurrentPower( is ) );
+	}
+
+	@Override
+	public boolean canUse(ItemStack is, int amount)
+	{
+		return getCharge( is ) > amount;
+	}
+
+	@Override
+	public boolean use(ItemStack is, int amount, EntityLivingBase entity)
+	{
+		if ( canUse( is, amount ) )
+		{
+			// use the power..
+			extractAEPower( is, PowerUnits.EU.convertTo( PowerUnits.AE, amount ) );
+			return true;
+		}
+		return false;
+	}
+
+	@Override
+	public void chargeFromArmor(ItemStack itemStack, EntityLivingBase entity)
+	{
+		// wtf?
+	}
+
+	@Override
+	public String getToolTip(ItemStack itemStack)
+	{
+		return null;
+	}
+
+}

items/tools/powered/powersink/ThermalExpansion.java

@@ -0,0 +1,38 @@
+package appeng.items.tools.powered.powersink;
+
+import net.minecraft.item.ItemStack;
+import appeng.api.config.PowerUnits;
+import cofh.api.energy.IEnergyContainerItem;
+
+public class ThermalExpansion extends IC2 implements IEnergyContainerItem
+{
+
+	public ThermalExpansion(Class c, String subname) {
+		super( c, subname );
+	}
+
+	@Override
+	public int receiveEnergy(ItemStack is, int maxReceive, boolean simulate)
+	{
+		return maxReceive - (int) injectExternalPower( PowerUnits.RF, is, maxReceive, simulate );
+	}
+
+	@Override
+	public int extractEnergy(ItemStack container, int maxExtract, boolean simulate)
+	{
+		return 0;
+	}
+
+	@Override
+	public int getEnergyStored(ItemStack is)
+	{
+		return (int) PowerUnits.AE.convertTo( PowerUnits.RF, getAECurrentPower( is ) );
+	}
+
+	@Override
+	public int getMaxEnergyStored(ItemStack is)
+	{
+		return (int) PowerUnits.AE.convertTo( PowerUnits.EU, getMaxEnergyStored( is ) );
+	}
+
+}

items/tools/powered/powersink/UniversalElectricity.java

@@ -0,0 +1,61 @@
+package appeng.items.tools.powered.powersink;
+
+import net.minecraft.item.ItemStack;
+import universalelectricity.core.item.IItemElectric;
+import appeng.api.config.PowerUnits;
+
+public class UniversalElectricity extends ThermalExpansion implements IItemElectric
+{
+
+	public UniversalElectricity(Class c, String subname) {
+		super( c, subname );
+	}
+
+	@Override
+	public float recharge(ItemStack is, float energy, boolean doRecharge)
+	{
+		return (float) (energy - injectExternalPower( PowerUnits.KJ, is, energy, !doRecharge ));
+	}
+
+	@Override
+	public float discharge(ItemStack is, float energy, boolean doDischarge)
+	{
+		return 0;
+	}
+
+	@Override
+	public float getElectricityStored(ItemStack is)
+	{
+		return (int) PowerUnits.AE.convertTo( PowerUnits.KJ, getAECurrentPower( is ) );
+	}
+
+	@Override
+	public float getMaxElectricityStored(ItemStack is)
+	{
+		return (int) PowerUnits.AE.convertTo( PowerUnits.KJ, getAEMaxPower( is ) );
+	}
+
+	@Override
+	public void setElectricity(ItemStack is, float joules)
+	{
+		double currentPower = getAECurrentPower( is );
+		double targetPower = PowerUnits.KJ.convertTo( PowerUnits.AE, joules );
+		if ( targetPower > currentPower )
+			injectAEPower( is, targetPower - currentPower );
+		else
+			extractAEPower( is, currentPower - targetPower );
+	}
+
+	@Override
+	public float getTransfer(ItemStack is)
+	{
+		return (float) PowerUnits.AE.convertTo( PowerUnits.KJ, getAEMaxPower( is ) - getAECurrentPower( is ) );
+	}
+
+	@Override
+	public float getVoltage(ItemStack itemStack)
+	{
+		return 120;
+	}
+
+}

items/tools/quartz/ToolQuartzAxe.java

@@ -0,0 +1,30 @@
+package appeng.items.tools.quartz;
+
+import java.util.EnumSet;
+
+import net.minecraft.item.EnumToolMaterial;
+import net.minecraft.item.ItemAxe;
+import net.minecraftforge.common.MinecraftForge;
+import appeng.core.Configuration;
+import appeng.core.features.AEFeature;
+import appeng.core.features.AEFeatureHandler;
+import appeng.core.features.IAEFeature;
+
+public class ToolQuartzAxe extends ItemAxe implements IAEFeature
+{
+
+	AEFeatureHandler feature;
+
+	@Override
+	public AEFeatureHandler feature()
+	{
+		return feature;
+	}
+
+	public ToolQuartzAxe(AEFeature Type) {
+		super( Configuration.instance.getItemID( ToolQuartzAxe.class, Type.name() ), EnumToolMaterial.IRON );
+		MinecraftForge.setToolClass( this, "axe", EnumToolMaterial.IRON.getHarvestLevel() );
+		feature = new AEFeatureHandler( EnumSet.of( Type, AEFeature.QuartzAxe ), this, Type.name() );
+	}
+
+}

items/tools/quartz/ToolQuartzCuttingKnife.java

@@ -0,0 +1,44 @@
+package appeng.items.tools.quartz;
+
+import java.util.EnumSet;
+
+import net.minecraft.item.ItemStack;
+import appeng.core.features.AEFeature;
+import appeng.items.AEBaseItem;
+
+public class ToolQuartzCuttingKnife extends AEBaseItem
+{
+
+	public ToolQuartzCuttingKnife(AEFeature type) {
+		super( ToolQuartzCuttingKnife.class, type.name() );
+		setfeature( EnumSet.of( type, AEFeature.QuartzKnife ) );
+		setMaxDamage( 50 );
+		setMaxStackSize( 1 );
+	}
+
+	@Override
+	public boolean isRepairable()
+	{
+		return false;
+	}
+
+	@Override
+	public boolean doesContainerItemLeaveCraftingGrid(ItemStack par1ItemStack)
+	{
+		return false;
+	}
+
+	@Override
+	public boolean hasContainerItem()
+	{
+		return true;
+	}
+
+	@Override
+	public ItemStack getContainerItemStack(ItemStack itemStack)
+	{
+		itemStack.setItemDamage( itemStack.getItemDamage() + 1 );
+		return itemStack;
+	}
+
+}

items/tools/quartz/ToolQuartzHoe.java

@@ -0,0 +1,30 @@
+package appeng.items.tools.quartz;
+
+import java.util.EnumSet;
+
+import net.minecraft.item.EnumToolMaterial;
+import net.minecraft.item.ItemHoe;
+import net.minecraftforge.common.MinecraftForge;
+import appeng.core.Configuration;
+import appeng.core.features.AEFeature;
+import appeng.core.features.AEFeatureHandler;
+import appeng.core.features.IAEFeature;
+
+public class ToolQuartzHoe extends ItemHoe implements IAEFeature
+{
+
+	AEFeatureHandler feature;
+
+	@Override
+	public AEFeatureHandler feature()
+	{
+		return feature;
+	}
+
+	public ToolQuartzHoe(AEFeature Type) {
+		super( Configuration.instance.getItemID( ToolQuartzHoe.class, Type.name() ), EnumToolMaterial.IRON );
+		MinecraftForge.setToolClass( this, "hoe", EnumToolMaterial.IRON.getHarvestLevel() );
+		feature = new AEFeatureHandler( EnumSet.of( Type, AEFeature.QuartzHoe ), this, Type.name() );
+	}
+
+}

items/tools/quartz/ToolQuartzPickaxe.java

@@ -0,0 +1,30 @@
+package appeng.items.tools.quartz;
+
+import java.util.EnumSet;
+
+import net.minecraft.item.EnumToolMaterial;
+import net.minecraft.item.ItemPickaxe;
+import net.minecraftforge.common.MinecraftForge;
+import appeng.core.Configuration;
+import appeng.core.features.AEFeature;
+import appeng.core.features.AEFeatureHandler;
+import appeng.core.features.IAEFeature;
+
+public class ToolQuartzPickaxe extends ItemPickaxe implements IAEFeature
+{
+
+	AEFeatureHandler feature;
+
+	@Override
+	public AEFeatureHandler feature()
+	{
+		return feature;
+	}
+
+	public ToolQuartzPickaxe(AEFeature Type) {
+		super( Configuration.instance.getItemID( ToolQuartzPickaxe.class, Type.name() ), EnumToolMaterial.IRON );
+		MinecraftForge.setToolClass( this, "pickaxe", EnumToolMaterial.IRON.getHarvestLevel() );
+		feature = new AEFeatureHandler( EnumSet.of( Type, AEFeature.QuartzPickaxe ), this, Type.name() );
+	}
+
+}

items/tools/quartz/ToolQuartzSpade.java

@@ -0,0 +1,30 @@
+package appeng.items.tools.quartz;
+
+import java.util.EnumSet;
+
+import net.minecraft.item.EnumToolMaterial;
+import net.minecraft.item.ItemSpade;
+import net.minecraftforge.common.MinecraftForge;
+import appeng.core.Configuration;
+import appeng.core.features.AEFeature;
+import appeng.core.features.AEFeatureHandler;
+import appeng.core.features.IAEFeature;
+
+public class ToolQuartzSpade extends ItemSpade implements IAEFeature
+{
+
+	AEFeatureHandler feature;
+
+	@Override
+	public AEFeatureHandler feature()
+	{
+		return feature;
+	}
+
+	public ToolQuartzSpade(AEFeature Type) {
+		super( Configuration.instance.getItemID( ToolQuartzSpade.class, Type.name() ), EnumToolMaterial.IRON );
+		MinecraftForge.setToolClass( this, "shovel", EnumToolMaterial.IRON.getHarvestLevel() );
+		feature = new AEFeatureHandler( EnumSet.of( Type, AEFeature.QuartzSpade ), this, Type.name() );
+	}
+
+}

items/tools/quartz/ToolQuartzSword.java

@@ -0,0 +1,28 @@
+package appeng.items.tools.quartz;
+
+import java.util.EnumSet;
+
+import net.minecraft.item.EnumToolMaterial;
+import net.minecraft.item.ItemSword;
+import appeng.core.Configuration;
+import appeng.core.features.AEFeature;
+import appeng.core.features.AEFeatureHandler;
+import appeng.core.features.IAEFeature;
+
+public class ToolQuartzSword extends ItemSword implements IAEFeature
+{
+
+	AEFeatureHandler feature;
+
+	@Override
+	public AEFeatureHandler feature()
+	{
+		return feature;
+	}
+
+	public ToolQuartzSword(AEFeature Type) {
+		super( Configuration.instance.getItemID( ToolQuartzSword.class, Type.name() ), EnumToolMaterial.IRON );
+		feature = new AEFeatureHandler( EnumSet.of( Type, AEFeature.QuartzSword ), this, Type.name() );
+	}
+
+}

items/tools/quartz/ToolQuartzWrench.java

@@ -0,0 +1,68 @@
+package appeng.items.tools.quartz;
+
+import java.util.EnumSet;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.implementations.IAEWrench;
+import appeng.core.features.AEFeature;
+import appeng.items.AEBaseItem;
+import buildcraft.api.tools.IToolWrench;
+
+public class ToolQuartzWrench extends AEBaseItem implements IAEWrench, IToolWrench
+{
+
+	public ToolQuartzWrench(AEFeature type) {
+		super( ToolQuartzWrench.class, type.name() );
+		setfeature( EnumSet.of( type, AEFeature.QuartzWrench ) );
+		setMaxStackSize( 1 );
+	}
+
+	@Override
+	public boolean onItemUseFirst(ItemStack is, EntityPlayer player, World world, int x, int y, int z, int side, float hitX,
+			float hitY, float hitZ)
+	{
+		int id = world.getBlockId( x, y, z );
+		if ( id > 0 )
+		{
+			Block b = Block.blocksList[id];
+			if ( b != null )
+			{
+				if ( b.rotateBlock( world, x, y, z, ForgeDirection.getOrientation( side ) ) )
+				{
+					player.swingItem();
+					return !world.isRemote;
+				}
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public boolean shouldPassSneakingClickToBlock(World w, int x, int y, int z)
+	{
+		return true;
+	}
+
+	@Override
+	public boolean canWrench(ItemStack is, EntityPlayer player, int x, int y, int z)
+	{
+		return true;
+	}
+
+	@Override
+	public boolean canWrench(EntityPlayer player, int x, int y, int z)
+	{
+		return true;
+	}
+
+	@Override
+	public void wrenchUsed(EntityPlayer player, int x, int y, int z)
+	{
+		player.swingItem();
+	}
+
+}