Err too much.

items/materials/ItemMaterial.java

@@ -1,24 +1,33 @@
 package appeng.items.materials;
 
+import java.util.Collections;
+import java.util.Comparator;
 import java.util.EnumSet;
 import java.util.HashMap;
+import java.util.LinkedList;
 import java.util.List;
+import java.util.Map.Entry;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import net.minecraft.client.renderer.texture.IconRegister;
 import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.Icon;
 import net.minecraft.world.World;
 import net.minecraftforge.oredict.OreDictionary;
 import appeng.api.config.Upgrades;
+import appeng.api.implementations.IItemGroup;
 import appeng.api.implementations.IStorageComponent;
 import appeng.api.implementations.IUpgradeModule;
 import appeng.core.Configuration;
 import appeng.core.features.AEFeature;
 import appeng.core.features.AEFeatureHandler;
 import appeng.items.AEBaseItem;
+import appeng.util.Platform;
 
 public class ItemMaterial extends AEBaseItem implements IStorageComponent, IUpgradeModule
 {
@@ -28,6 +37,75 @@ public class ItemMaterial extends AEBaseItem implements IStorageComponent, IUpgr
 	public ItemMaterial() {
 		super( ItemMaterial.class );
 		setfeature( EnumSet.of( AEFeature.Core ) );
+		setHasSubtypes( true );
+	}
+
+	class SlightlyBetterSort implements Comparator<String>
+	{
+
+		Pattern p;
+
+		public SlightlyBetterSort(Pattern p) {
+			this.p = p;
+		}
+
+		@Override
+		public int compare(String o1, String o2)
+		{
+			try
+			{
+				Matcher a = p.matcher( o1 );
+				Matcher b = p.matcher( o2 );
+				if ( a.find() && b.find() )
+				{
+					int ia = Integer.parseInt( a.group( 1 ) );
+					int ib = Integer.parseInt( b.group( 1 ) );
+					return Integer.compare( ia, ib );
+				}
+			}
+			catch (Throwable t)
+			{
+				// ek!
+			}
+			return o1.compareTo( o2 );
+		}
+	}
+
+	@Override
+	public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+	{
+		super.addInformation( par1ItemStack, par2EntityPlayer, par3List, par4 );
+
+		Upgrades u = getType( par1ItemStack );
+		if ( u != null )
+		{
+			List<String> textList = new LinkedList();
+			for (Entry<ItemStack, Integer> j : u.getSupported().entrySet())
+			{
+				String name = null;
+
+				int limit = j.getValue();
+
+				if ( j.getKey().getItem() instanceof IItemGroup )
+				{
+					IItemGroup ig = (IItemGroup) j.getKey().getItem();
+					String str = ig.getUnlocalizedGroupName( j.getKey() );
+					if ( str != null )
+						name = Platform.gui_localize( str ) + (limit > 1 ? " (" + limit + ")" : "");
+				}
+
+				if ( name == null )
+					name = j.getKey().getDisplayName() + (limit > 1 ? " (" + limit + ")" : "");
+
+				if ( !textList.contains( name ) )
+					textList.add( name );
+			}
+
+			Pattern p = Pattern.compile( "(\\d+)[^\\d]" );
+			SlightlyBetterSort s = new SlightlyBetterSort( p );
+			Collections.sort( textList, s );
+			par3List.addAll( textList );
+		}
 	}
 
 	public ItemStack createMaterial(MaterialType mat)
@@ -72,21 +150,26 @@ public class ItemMaterial extends AEBaseItem implements IStorageComponent, IUpgr
 		return dmgToMaterial.get( dmg ).icon;
 	}
 
-	@Override
-	public String getUnlocalizedName(ItemStack is)
+	private String nameOf(ItemStack is)
 	{
 		return AEFeatureHandler.getName( ItemMaterial.class, getTypeByStack( is ).name() );
 	}
 
 	@Override
-	public void registerIcons(IconRegister par1IconRegister)
+	public String getUnlocalizedName(ItemStack is)
+	{
+		return "item.appliedenergistics2." + nameOf( is );
+	}
+
+	@Override
+	public void registerIcons(IconRegister icoRegister)
 	{
 		for (MaterialType mat : MaterialType.values())
 		{
 			if ( mat.damageValue != -1 )
 			{
-				String tex = "appliedenergistics2:" + getUnlocalizedName( new ItemStack( this, 1, mat.damageValue ) );
-				mat.icon = par1IconRegister.registerIcon( tex );
+				String tex = "appliedenergistics2:" + nameOf( new ItemStack( this, 1, mat.damageValue ) );
+				mat.icon = icoRegister.registerIcon( tex );
 			}
 		}
 	}
@@ -169,6 +252,8 @@ public class ItemMaterial extends AEBaseItem implements IStorageComponent, IUpgr
 			return Upgrades.REDSTONE;
 		case CardSpeed:
 			return Upgrades.SPEED;
+		case CardInverter:
+			return Upgrades.INVERTER;
 		default:
 			return null;
 		}

items/materials/MaterialType.java

@@ -35,7 +35,7 @@ public enum MaterialType
 	BasicCard, CardRedstone, CardCapacity,
 
 	// Adv Cards
-	AdvCard, CardFuzzy, CardSpeed,
+	AdvCard, CardFuzzy, CardSpeed, CardInverter,
 
 	Cell2SpatialPart(AEFeature.SpatialIO), Cell16SpatialPart(AEFeature.SpatialIO), Cell128SpatialPart(AEFeature.SpatialIO),
 
@@ -48,8 +48,8 @@ public enum MaterialType
 
 	BlankPattern, FormationCore, AnnihilationCore,
 
-	EnderDust(AEFeature.QuantumNetworkBridge, "dustEnder"), Singularity(AEFeature.QuantumNetworkBridge), QESingularity(AEFeature.QuantumNetworkBridge,
-			EntitySingularity.class);
+	EnderDust(AEFeature.QuantumNetworkBridge, "dustEnder", EntitySingularity.class), Singularity(AEFeature.QuantumNetworkBridge, EntitySingularity.class), QESingularity(
+			AEFeature.QuantumNetworkBridge, EntitySingularity.class);
 
 	private String oreName;
 	private EnumSet<AEFeature> features;
@@ -75,6 +75,16 @@ public enum MaterialType
 		EntityRegistry.registerModEntity( droppedEntity, droppedEntity.getSimpleName(), EntityIds.get( droppedEntity ), AppEng.instance, 16, 4, true );
 	}
 
+	MaterialType(AEFeature part, String oreDictionary, Class<? extends Entity> c) {
+		features = EnumSet.of( part );
+		oreName = oreDictionary;
+		if ( OreDictionary.getOres( oreDictionary ).size() > 0 )
+			features.add( AEFeature.DuplicateItems );
+
+		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;

items/parts/ItemPart.java

@@ -12,16 +12,18 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.util.Icon;
 import net.minecraft.world.World;
 import appeng.api.AEApi;
+import appeng.api.implementations.IItemGroup;
 import appeng.api.parts.IPart;
 import appeng.api.parts.IPartItem;
 import appeng.core.Configuration;
 import appeng.core.features.AEFeature;
 import appeng.core.features.AEFeatureHandler;
+import appeng.core.localization.GuiText;
 import appeng.items.AEBaseItem;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
-public class ItemPart extends AEBaseItem implements IPartItem
+public class ItemPart extends AEBaseItem implements IPartItem, IItemGroup
 {
 
 	class PartTypeIst
@@ -98,16 +100,32 @@ public class ItemPart extends AEBaseItem implements IPartItem
 
 	@Override
 	public String getUnlocalizedName(ItemStack is)
+	{
+		return "item.appliedenergistics2." + getname( is );
+	}
+
+	public String getname(ItemStack is)
 	{
 		return AEFeatureHandler.getName( ItemPart.class, getTypeByStack( is ).name() );
 	}
 
+	@Override
+	public String getItemDisplayName(ItemStack is)
+	{
+		Enum[] varients = getTypeByStack( is ).getVarients();
+
+		if ( varients != null )
+			return super.getItemDisplayName( is ) + " - " + varients[dmgToPart.get( is.getItemDamage() ).varient].toString();
+
+		return super.getItemDisplayName( is );
+	}
+
 	@Override
 	public void registerIcons(IconRegister par1IconRegister)
 	{
 		for (Entry<Integer, PartTypeIst> part : dmgToPart.entrySet())
 		{
-			String tex = "appliedenergistics2:" + getUnlocalizedName( new ItemStack( this, 1, part.getKey() ) );
+			String tex = "appliedenergistics2:" + getname( new ItemStack( this, 1, part.getKey() ) );
 			part.getValue().ico = par1IconRegister.registerIcon( tex );
 		}
 	}
@@ -145,4 +163,17 @@ public class ItemPart extends AEBaseItem implements IPartItem
 		return dmgToPart.get( itemDamage ).varient;
 	}
 
+	@Override
+	public String getUnlocalizedGroupName(ItemStack is)
+	{
+		switch (getTypeByStack( is ))
+		{
+		case ImportBus:
+		case ExportBus:
+			return GuiText.IOBuses.getUnlocalized();
+		default:
+		}
+		return null;
+	}
+
 }

items/parts/PartType.java

@@ -13,13 +13,19 @@ import appeng.parts.automation.PartLevelEmitter;
 import appeng.parts.misc.PartCableAnchor;
 import appeng.parts.misc.PartInterface;
 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.PartDenseCable;
 import appeng.parts.networking.PartQuartzFiber;
+import appeng.parts.p2p.PartP2PBCPower;
+import appeng.parts.p2p.PartP2PIC2Power;
+import appeng.parts.p2p.PartP2PItems;
+import appeng.parts.p2p.PartP2PLiquids;
+import appeng.parts.p2p.PartP2PRedstone;
+import appeng.parts.p2p.PartP2PTunnelME;
 import appeng.parts.reporting.PartConversionMonitor;
 import appeng.parts.reporting.PartCraftingMonitor;
 import appeng.parts.reporting.PartCraftingTerminal;
@@ -38,6 +44,8 @@ public enum PartType
 
 	CableSmart(AEFeature.Core, PartCableSmart.class), CableCovered(AEFeature.Core, PartCableCovered.class), CableGlass(AEFeature.Core, PartCableGlass.class),
 
+	CableDense(AEFeature.DenseCables, PartDenseCable.class),
+
 	CableAnchor(AEFeature.Core, PartCableAnchor.class),
 
 	QuartzFiber(AEFeature.Core, PartQuartzFiber.class),
@@ -60,7 +68,17 @@ public enum PartType
 
 	FormationPlane(AEFeature.FormationPlane, PartFormationPlane.class),
 
-	P2PTunnel(AEFeature.P2PTunnel, PartP2PTunnel.class),
+	P2PTunnelME(AEFeature.P2PTunnelME, PartP2PTunnelME.class),
+
+	P2PTunnelRedstone(AEFeature.P2PTunnelRedstone, PartP2PRedstone.class),
+
+	P2PTunnelItems(AEFeature.P2PTunnelItems, PartP2PItems.class),
+
+	P2PTunnelLiquids(AEFeature.P2PTunnelLiquids, PartP2PLiquids.class),
+
+	P2PTunnelMJ(AEFeature.P2PTunnelMJ, PartP2PBCPower.class),
+
+	P2PTunnelEU(AEFeature.P2PTunnelEU, PartP2PIC2Power.class),
 
 	CraftingMonitor(AEFeature.Crafting, PartCraftingMonitor.class),
 
@@ -86,7 +104,7 @@ public enum PartType
 
 	public Enum[] getVarients()
 	{
-		return (this == CableSmart || this == CableCovered || this == CableGlass) ? AEColor.values() : null;
+		return (this == CableSmart || this == CableCovered || this == CableGlass || this == CableDense) ? AEColor.values() : null;
 	}
 
 	public EnumSet<AEFeature> getFeature()

items/storage/CellConfig.java

@@ -0,0 +1,24 @@
+package appeng.items.storage;
+
+import net.minecraft.item.ItemStack;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.util.Platform;
+
+public class CellConfig extends AppEngInternalInventory
+{
+
+	final ItemStack is;
+
+	public CellConfig(ItemStack is) {
+		super( null, 63 );
+		this.is = is;
+		readFromNBT( Platform.openNbtData( is ), "list" );
+	}
+
+	@Override
+	public void onInventoryChanged()
+	{
+		writeToNBT( Platform.openNbtData( is ), "list" );
+	}
+
+}

items/storage/CellUpgrades.java

@@ -0,0 +1,24 @@
+package appeng.items.storage;
+
+import net.minecraft.item.ItemStack;
+import appeng.parts.automation.UpgradeInventory;
+import appeng.util.Platform;
+
+public class CellUpgrades extends UpgradeInventory
+{
+
+	final ItemStack is;
+
+	public CellUpgrades(ItemStack is, int upgrades) {
+		super( is.getItem(), null, upgrades );
+		this.is = is;
+		readFromNBT( Platform.openNbtData( is ), "upgrades" );
+	}
+
+	@Override
+	public void onInventoryChanged()
+	{
+		writeToNBT( Platform.openNbtData( is ), "upgrades" );
+	}
+
+}

items/storage/ItemBasicStorageCell.java

@@ -4,18 +4,25 @@ import java.util.EnumSet;
 import java.util.List;
 
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
-import net.minecraft.util.StatCollector;
+import appeng.api.AEApi;
+import appeng.api.config.FuzzyMode;
+import appeng.api.implementations.IItemGroup;
 import appeng.api.implementations.IStorageCell;
+import appeng.api.storage.IMEInventory;
+import appeng.api.storage.StorageChannel;
 import appeng.api.storage.data.IAEItemStack;
 import appeng.core.features.AEFeature;
+import appeng.core.localization.GuiText;
 import appeng.items.AEBaseItem;
 import appeng.items.materials.MaterialType;
 import appeng.me.storage.CellInventory;
 import appeng.me.storage.CellInventoryHandler;
+import appeng.util.Platform;
 
-public class ItemBasicStorageCell extends AEBaseItem implements IStorageCell
+public class ItemBasicStorageCell extends AEBaseItem implements IStorageCell, IItemGroup
 {
 
 	final MaterialType component;
@@ -25,7 +32,7 @@ public class ItemBasicStorageCell extends AEBaseItem implements IStorageCell
 	public ItemBasicStorageCell(MaterialType whichCell, int Kilobytes) {
 		super( ItemBasicStorageCell.class, Kilobytes + "k" );
 		setfeature( EnumSet.of( AEFeature.StorageCells ) );
-		maxStackSize = 1;
+		setMaxStackSize( 1 );
 		totalBytes = Kilobytes * 1024;
 		component = whichCell;
 
@@ -51,22 +58,24 @@ public class ItemBasicStorageCell extends AEBaseItem implements IStorageCell
 	@Override
 	public void addInformation(ItemStack i, EntityPlayer p, List l, boolean b)
 	{
-		CellInventory cd = ((CellInventoryHandler) CellInventory.getCell( i )).getCellInv();
+		IMEInventory<IAEItemStack> cdi = AEApi.instance().registries().cell().getCellInventory( i, StorageChannel.ITEMS );
 
-		if ( cd != null )
+		if ( cdi instanceof CellInventoryHandler )
 		{
-			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" ) ); }
-			 */
+			CellInventory cd = ((CellInventoryHandler) cdi).getCellInv();
+			if ( cd != null )
+			{
+				l.add( cd.usedBytes() + " " + GuiText.Of.getLocal() + " " + cd.totalBytes() + " " + GuiText.BytesUsed.getLocal() );
+				l.add( cd.storedItemTypes() + " " + GuiText.Of.getLocal() + " " + cd.getTotalItemTypes() + " " + GuiText.Types.getLocal() );
+				/*
+				 * 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" ) ); }
+				 */
+			}
 		}
 	}
 
@@ -116,4 +125,49 @@ public class ItemBasicStorageCell extends AEBaseItem implements IStorageCell
 	{
 		return idleDrain;
 	}
+
+	@Override
+	public IInventory getUpgradesInventory(ItemStack is)
+	{
+		return new CellUpgrades( is, 2 );
+	}
+
+	@Override
+	public IInventory getConfigInventory(ItemStack is)
+	{
+		return new CellConfig( is );
+	}
+
+	@Override
+	public FuzzyMode getFuzzyMode(ItemStack is)
+	{
+		String fz = Platform.openNbtData( is ).getString( "FuzzyMode" );
+		try
+		{
+			return FuzzyMode.valueOf( fz );
+		}
+		catch (Throwable t)
+		{
+			return FuzzyMode.IGNORE_ALL;
+		}
+	}
+
+	@Override
+	public void setFuzzyMode(ItemStack is, FuzzyMode fzMode)
+	{
+		Platform.openNbtData( is ).setString( "FuzzyMode", fzMode.name() );
+	}
+
+	@Override
+	public String getUnlocalizedGroupName(ItemStack is)
+	{
+		return GuiText.StorageCells.getUnlocalized();
+	}
+
+	@Override
+	public boolean isEditable(ItemStack is)
+	{
+		return true;
+	}
+
 }

items/storage/ItemCreativeStorageCell.java

@@ -2,16 +2,49 @@ package appeng.items.storage;
 
 import java.util.EnumSet;
 
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import appeng.api.config.FuzzyMode;
+import appeng.api.storage.ICellWorkbenchItem;
 import appeng.core.features.AEFeature;
 import appeng.items.AEBaseItem;
 
-public class ItemCreativeStorageCell extends AEBaseItem
+public class ItemCreativeStorageCell extends AEBaseItem implements ICellWorkbenchItem
 {
 
 	public ItemCreativeStorageCell() {
 		super( ItemCreativeStorageCell.class );
 		setfeature( EnumSet.of( AEFeature.StorageCells, AEFeature.Creative ) );
-		maxStackSize = 1;
+		setMaxStackSize( 1 );
 	}
 
+	@Override
+	public boolean isEditable(ItemStack is)
+	{
+		return true;
+	}
+
+	@Override
+	public IInventory getUpgradesInventory(ItemStack is)
+	{
+		return null;
+	}
+
+	@Override
+	public IInventory getConfigInventory(ItemStack is)
+	{
+		return new CellConfig( is );
+	}
+
+	@Override
+	public FuzzyMode getFuzzyMode(ItemStack is)
+	{
+		return FuzzyMode.IGNORE_ALL;
+	}
+
+	@Override
+	public void setFuzzyMode(ItemStack is, FuzzyMode fzMode)
+	{
+
+	}
 }

items/storage/ItemSpatialStorageCell.java

@@ -8,12 +8,14 @@ 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 ) );
+		setMaxStackSize( 1 );
 		maxRegion = spatialScale;
 		component = whichCell;
 	}

items/tools/ToolMemoryCard.java

@@ -21,6 +21,7 @@ public class ToolMemoryCard extends AEBaseItem implements IMemoryCard
 	public ToolMemoryCard() {
 		super( ToolMemoryCard.class );
 		setfeature( EnumSet.of( AEFeature.Core ) );
+		setMaxStackSize( 1 );
 	}
 
 	@Override
@@ -39,7 +40,6 @@ public class ToolMemoryCard extends AEBaseItem implements IMemoryCard
 	{
 		NBTTagCompound c = Platform.openNbtData( is );
 		c.setString( "Config", SettingsName );
-		;
 		c.setCompoundTag( "Data", data );
 	}
 
@@ -64,6 +64,9 @@ public class ToolMemoryCard extends AEBaseItem implements IMemoryCard
 	@Override
 	public void notifyUser(Block blk, EntityPlayer player, MemoryCardMessages msg)
 	{
+		if ( Platform.isClient() )
+			return;
+
 		switch (msg)
 		{
 		case INVALID_MACHINE:

items/tools/powered/ToolMassCannon.java

@@ -1,11 +1,48 @@
 package appeng.items.tools.powered;
 
 import java.util.EnumSet;
+import java.util.List;
 
+import net.minecraft.block.Block;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.EnumMovingObjectType;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import appeng.api.AEApi;
+import appeng.api.config.Actionable;
+import appeng.api.config.FuzzyMode;
+import appeng.api.config.Upgrades;
+import appeng.api.implementations.IStorageCell;
+import appeng.api.networking.security.PlayerSource;
+import appeng.api.storage.IMEInventory;
+import appeng.api.storage.StorageChannel;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.api.storage.data.IAEStack;
+import appeng.api.storage.data.IItemList;
+import appeng.core.CommonHelper;
+import appeng.core.Configuration;
 import appeng.core.features.AEFeature;
+import appeng.core.localization.GuiText;
+import appeng.core.localization.PlayerMessages;
+import appeng.core.sync.packets.PacketMatterCannon;
+import appeng.items.storage.CellConfig;
+import appeng.items.storage.CellUpgrades;
 import appeng.items.tools.powered.powersink.AEBasePoweredItem;
+import appeng.me.storage.CellInventory;
+import appeng.me.storage.CellInventoryHandler;
+import appeng.util.Platform;
+import appeng.util.item.ItemList;
 
-public class ToolMassCannon extends AEBasePoweredItem
+public class ToolMassCannon extends AEBasePoweredItem implements IStorageCell
 {
 
 	public ToolMassCannon() {
@@ -13,4 +50,291 @@ public class ToolMassCannon extends AEBasePoweredItem
 		setfeature( EnumSet.of( AEFeature.MatterCannon, AEFeature.PoweredTools ) );
 	}
 
+	@Override
+	public void addInformation(ItemStack is, EntityPlayer player, List lines, boolean advancedItemTooltips)
+	{
+		super.addInformation( is, player, lines, advancedItemTooltips );
+
+		IMEInventory<IAEItemStack> cdi = AEApi.instance().registries().cell().getCellInventory( is, StorageChannel.ITEMS );
+
+		if ( cdi instanceof CellInventoryHandler )
+		{
+			CellInventory cd = ((CellInventoryHandler) cdi).getCellInv();
+			if ( cd != null )
+			{
+				lines.add( cd.usedBytes() + " " + GuiText.Of.getLocal() + " " + cd.totalBytes() + " " + GuiText.BytesUsed.getLocal() );
+				lines.add( cd.storedItemTypes() + " " + GuiText.Of.getLocal() + " " + cd.getTotalItemTypes() + " " + GuiText.Types.getLocal() );
+			}
+		}
+	}
+
+	@Override
+	public ItemStack onItemRightClick(ItemStack item, World w, EntityPlayer p)
+	{
+		if ( this.getAECurrentPower( item ) > 1600 )
+		{
+			int shots = 1;
+
+			CellUpgrades cu = (CellUpgrades) getUpgradesInventory( item );
+			if ( cu != null )
+				shots += cu.getInstalledUpgrades( Upgrades.SPEED );
+
+			for (int sh = 0; sh < shots; sh++)
+			{
+				extractAEPower( item, 1600 );
+
+				if ( Platform.isClient() )
+					return item;
+
+				IMEInventory inv = AEApi.instance().registries().cell().getCellInventory( item, StorageChannel.ITEMS );
+				if ( inv != null )
+				{
+					IItemList itemList = inv.getAvailableItems( new ItemList() );
+					IAEStack aeammo = itemList.getFirstItem();
+					if ( aeammo instanceof IAEItemStack )
+					{
+						aeammo.setStackSize( 1 );
+						ItemStack ammo = ((IAEItemStack) aeammo).getItemStack();
+						if ( ammo == null )
+							return item;
+
+						ammo.stackSize = 1;
+						aeammo = inv.extractItems( aeammo, Actionable.MODULATE, new PlayerSource( p, null ) );
+						if ( aeammo == null )
+							return item;
+
+						float f = 1.0F;
+						float f1 = p.prevRotationPitch + (p.rotationPitch - p.prevRotationPitch) * f;
+						float f2 = p.prevRotationYaw + (p.rotationYaw - p.prevRotationYaw) * f;
+						double d0 = p.prevPosX + (p.posX - p.prevPosX) * (double) f;
+						double d1 = p.prevPosY + (p.posY - p.prevPosY) * (double) f + 1.62D - (double) p.yOffset;
+						double d2 = p.prevPosZ + (p.posZ - p.prevPosZ) * (double) f;
+						Vec3 vec3 = w.getWorldVec3Pool().getVecFromPool( d0, d1, d2 );
+						float f3 = MathHelper.cos( -f2 * 0.017453292F - (float) Math.PI );
+						float f4 = MathHelper.sin( -f2 * 0.017453292F - (float) Math.PI );
+						float f5 = -MathHelper.cos( -f1 * 0.017453292F );
+						float f6 = MathHelper.sin( -f1 * 0.017453292F );
+						float f7 = f4 * f5;
+						float f8 = f3 * f5;
+						double d3 = 32.0D;
+
+						float penitration = AEApi.instance().registries().matterCannon().getPenetration( ammo ); // 196.96655f;
+						boolean hasDestroyedSomething = true;
+						while (penitration > 0 && hasDestroyedSomething)
+						{
+							hasDestroyedSomething = false;
+
+							Vec3 vec31 = vec3.addVector( (double) f7 * d3, (double) f6 * d3, (double) f8 * d3 );
+
+							AxisAlignedBB bb = AxisAlignedBB
+									.getAABBPool()
+									.getAABB( Math.min( vec3.xCoord, vec31.xCoord ), Math.min( vec3.yCoord, vec31.yCoord ),
+											Math.min( vec3.zCoord, vec31.zCoord ), Math.max( vec3.xCoord, vec31.xCoord ),
+											Math.max( vec3.yCoord, vec31.yCoord ), Math.max( vec3.zCoord, vec31.zCoord ) ).expand( 16, 16, 16 );
+
+							Entity entity = null;
+							List list = w.getEntitiesWithinAABBExcludingEntity( p, bb );
+							double Closeest = 9999999.0D;
+							int l;
+
+							for (l = 0; l < list.size(); ++l)
+							{
+								Entity entity1 = (Entity) list.get( l );
+
+								if ( entity1.isDead == false && entity1 != p && !(entity1 instanceof EntityItem) )
+								{
+									if ( entity1.isEntityAlive() )
+									{
+										// prevent killing / flying of mounts.
+										if ( entity1.riddenByEntity == p )
+											continue;
+
+										f1 = 0.3F;
+										AxisAlignedBB axisalignedbb1 = entity1.boundingBox.expand( (double) f1, (double) f1, (double) f1 );
+										MovingObjectPosition movingobjectposition1 = axisalignedbb1.calculateIntercept( vec3, vec31 );
+
+										if ( movingobjectposition1 != null )
+										{
+											double nd = vec3.squareDistanceTo( movingobjectposition1.hitVec );
+
+											if ( nd < Closeest )
+											{
+												entity = entity1;
+												Closeest = nd;
+											}
+										}
+									}
+								}
+							}
+
+							Vec3 Srec = w.getWorldVec3Pool().getVecFromPool( d0, d1, d2 );
+							MovingObjectPosition pos = w.rayTraceBlocks_do_do( vec3, vec31, true, false );
+							if ( entity != null && pos != null && pos.hitVec.squareDistanceTo( Srec ) > Closeest )
+							{
+								pos = new MovingObjectPosition( entity );
+							}
+							else if ( entity != null && pos == null )
+							{
+								pos = new MovingObjectPosition( entity );
+							}
+
+							try
+							{
+								CommonHelper.proxy.sendToAllNearExcept( null, d0, d1, d2, 128, w, (new PacketMatterCannon( d0, d1, d2, (float) (f7 * d3),
+										(float) (f6 * d3), (float) (f8 * d3), (byte) (pos == null ? 32 : pos.hitVec.squareDistanceTo( Srec ) + 1) ))
+										.getPacket() );
+
+							}
+							catch (Exception err)
+							{
+								err.printStackTrace();
+							}
+
+							if ( pos != null )
+							{
+								DamageSource dmgSrc = DamageSource.causePlayerDamage( p );
+								dmgSrc.damageType = "masscannon";
+
+								if ( pos.typeOfHit == EnumMovingObjectType.ENTITY )
+								{
+									int dmg = (int) Math.ceil( penitration / 20.0f );
+									if ( pos.entityHit instanceof EntityLivingBase )
+									{
+										EntityLivingBase el = (EntityLivingBase) pos.entityHit;
+										penitration -= dmg;
+										el.knockBack( p, 0, (double) f7 * d3, (double) f8 * d3 );
+										// el.knockBack( p, 0, vec3.xCoord, vec3.zCoord );
+										el.attackEntityFrom( dmgSrc, dmg );
+										if ( !el.isEntityAlive() )
+											hasDestroyedSomething = true;
+									}
+									else if ( pos.entityHit instanceof EntityItem )
+									{
+										hasDestroyedSomething = true;
+										pos.entityHit.setDead();
+									}
+									else if ( pos.entityHit.attackEntityFrom( dmgSrc, dmg ) )
+									{
+										hasDestroyedSomething = true;
+									}
+								}
+								else if ( pos.typeOfHit == EnumMovingObjectType.TILE )
+								{
+									if ( !Configuration.instance.isFeatureEnabled( AEFeature.MassCannonBlockDamage ) )
+										penitration = 0;
+									else
+									{
+										int bid = w.getBlockId( pos.blockX, pos.blockY, pos.blockZ );
+										// int meta = w.getBlockMetadata( pos.blockX, pos.blockY, pos.blockZ );
+
+										if ( bid > 0 )
+										{
+											Block b = Block.blocksList[bid];
+											float hardness = b.getBlockHardness( w, pos.blockX, pos.blockY, pos.blockZ ) * 9.0f;
+											if ( hardness >= 0.0 )
+											{
+												if ( penitration > hardness )
+												{
+													hasDestroyedSomething = true;
+													penitration -= hardness;
+													penitration *= 0.60;
+													w.destroyBlock( pos.blockX, pos.blockY, pos.blockZ, true );
+												}
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+				else
+				{
+					p.sendChatToPlayer( PlayerMessages.AmmoDepleted.get() );
+					return item;
+				}
+			}
+		}
+		return item;
+	}
+
+	@Override
+	public boolean storableInStorageCell()
+	{
+		return true;
+	}
+
+	@Override
+	public boolean isStorageCell(ItemStack i)
+	{
+		return true;
+	}
+
+	@Override
+	public double getIdleDrain()
+	{
+		return 0.5;
+	}
+
+	@Override
+	public IInventory getUpgradesInventory(ItemStack is)
+	{
+		return new CellUpgrades( is, 4 );
+	}
+
+	@Override
+	public IInventory getConfigInventory(ItemStack is)
+	{
+		return new CellConfig( is );
+	}
+
+	@Override
+	public FuzzyMode getFuzzyMode(ItemStack is)
+	{
+		String fz = Platform.openNbtData( is ).getString( "FuzzyMode" );
+		try
+		{
+			return FuzzyMode.valueOf( fz );
+		}
+		catch (Throwable t)
+		{
+			return FuzzyMode.IGNORE_ALL;
+		}
+	}
+
+	@Override
+	public void setFuzzyMode(ItemStack is, FuzzyMode fzMode)
+	{
+		Platform.openNbtData( is ).setString( "FuzzyMode", fzMode.name() );
+	}
+
+	@Override
+	public boolean isEditable(ItemStack is)
+	{
+		return true;
+	}
+
+	@Override
+	public int getBytes(ItemStack cellItem)
+	{
+		return 512;
+	}
+
+	@Override
+	public int BytePerType(ItemStack iscellItem)
+	{
+		return 8;
+	}
+
+	@Override
+	public int getTotalTypes(ItemStack cellItem)
+	{
+		return 1;
+	}
+
+	@Override
+	public boolean isBlackListed(ItemStack cellItem, IAEItemStack requsetedAddition)
+	{
+		return AEApi.instance().registries().matterCannon().getPenetration( requsetedAddition.getItemStack() ) == 0;
+	}
 }

items/tools/powered/ToolNetworkTool.java

@@ -0,0 +1,26 @@
+package appeng.items.tools.powered;
+
+import java.util.EnumSet;
+
+import net.minecraft.item.ItemStack;
+import appeng.core.features.AEFeature;
+import appeng.helpers.IGuiItem;
+import appeng.items.tools.powered.powersink.AEBasePoweredItem;
+
+public class ToolNetworkTool extends AEBasePoweredItem implements IGuiItem
+{
+
+	public ToolNetworkTool() {
+		super( ToolNetworkTool.class, null );
+		setfeature( EnumSet.of( AEFeature.NetworkTool, AEFeature.PoweredTools ) );
+		maxStoredPower = 100000;
+	}
+
+	@Override
+	public Object getGuiObject(ItemStack is)
+	{
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+}

items/tools/powered/ToolPortableCell.java

@@ -0,0 +1,154 @@
+package appeng.items.tools.powered;
+
+import java.util.EnumSet;
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.AEApi;
+import appeng.api.config.FuzzyMode;
+import appeng.api.implementations.IStorageCell;
+import appeng.api.storage.IMEInventory;
+import appeng.api.storage.StorageChannel;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.core.features.AEFeature;
+import appeng.core.localization.GuiText;
+import appeng.core.sync.GuiBridge;
+import appeng.helpers.CellItemViewer;
+import appeng.helpers.IGuiItem;
+import appeng.items.storage.CellConfig;
+import appeng.items.storage.CellUpgrades;
+import appeng.items.tools.powered.powersink.AEBasePoweredItem;
+import appeng.me.storage.CellInventory;
+import appeng.me.storage.CellInventoryHandler;
+import appeng.util.Platform;
+
+public class ToolPortableCell extends AEBasePoweredItem implements IStorageCell, IGuiItem
+{
+
+	public ToolPortableCell() {
+		super( ToolPortableCell.class, null );
+		setfeature( EnumSet.of( AEFeature.PortableCell, AEFeature.StorageCells, AEFeature.PoweredTools ) );
+		maxStoredPower = 20000;
+	}
+
+	@Override
+	public ItemStack onItemRightClick(ItemStack item, World w, EntityPlayer player)
+	{
+		Platform.openGUI( player, null, ForgeDirection.UNKNOWN, GuiBridge.GUI_PORTABLE_CELL );
+		return item;
+	}
+
+	@Override
+	public void addInformation(ItemStack is, EntityPlayer player, List lines, boolean advancedItemTooltips)
+	{
+		super.addInformation( is, player, lines, advancedItemTooltips );
+
+		IMEInventory<IAEItemStack> cdi = AEApi.instance().registries().cell().getCellInventory( is, StorageChannel.ITEMS );
+
+		if ( cdi instanceof CellInventoryHandler )
+		{
+			CellInventory cd = ((CellInventoryHandler) cdi).getCellInv();
+			if ( cd != null )
+			{
+				lines.add( cd.usedBytes() + " " + GuiText.Of.getLocal() + " " + cd.totalBytes() + " " + GuiText.BytesUsed.getLocal() );
+				lines.add( cd.storedItemTypes() + " " + GuiText.Of.getLocal() + " " + cd.getTotalItemTypes() + " " + GuiText.Types.getLocal() );
+			}
+		}
+	}
+
+	@Override
+	public int getBytes(ItemStack cellItem)
+	{
+		return 512;
+	}
+
+	@Override
+	public int BytePerType(ItemStack iscellItem)
+	{
+		return 8;
+	}
+
+	@Override
+	public int getTotalTypes(ItemStack cellItem)
+	{
+		return 27;
+	}
+
+	@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 0.5;
+	}
+
+	@Override
+	public IInventory getUpgradesInventory(ItemStack is)
+	{
+		return new CellUpgrades( is, 2 );
+	}
+
+	@Override
+	public IInventory getConfigInventory(ItemStack is)
+	{
+		return new CellConfig( is );
+	}
+
+	@Override
+	public FuzzyMode getFuzzyMode(ItemStack is)
+	{
+		String fz = Platform.openNbtData( is ).getString( "FuzzyMode" );
+		try
+		{
+			return FuzzyMode.valueOf( fz );
+		}
+		catch (Throwable t)
+		{
+			return FuzzyMode.IGNORE_ALL;
+		}
+	}
+
+	@Override
+	public void setFuzzyMode(ItemStack is, FuzzyMode fzMode)
+	{
+		Platform.openNbtData( is ).setString( "FuzzyMode", fzMode.name() );
+	}
+
+	@Override
+	public boolean isEditable(ItemStack is)
+	{
+		return true;
+	}
+
+	@Override
+	public Object getGuiObject(ItemStack is)
+	{
+		return new CellItemViewer( is );
+	}
+}

items/tools/powered/powersink/AEBasePoweredItem.java

@@ -5,6 +5,6 @@ public class AEBasePoweredItem extends UniversalElectricity
 
 	public AEBasePoweredItem(Class c, String subname) {
 		super( c, subname );
+		setMaxStackSize( 1 );
 	}
-
 }

items/tools/powered/powersink/AERootPoweredItem.java

@@ -10,6 +10,7 @@ import net.minecraft.nbt.NBTTagCompound;
 import appeng.api.config.AccessRestriction;
 import appeng.api.config.PowerUnits;
 import appeng.api.implementations.IAEItemPowerStorage;
+import appeng.core.localization.GuiText;
 import appeng.items.AEBaseItem;
 import appeng.util.Platform;
 
@@ -43,7 +44,7 @@ public class AERootPoweredItem extends AEBaseItem implements IAEItemPowerStorage
 
 		double percent = internalCurrentPower / internalMaxPower;
 
-		lines.add( Platform.gui_localize( "Stored Energy" ) + ":" + MessageFormat.format( " {0,number,#} ", internalCurrentPower )
+		lines.add( GuiText.StoredEnergy.getLocal() + ":" + MessageFormat.format( " {0,number,#} ", internalCurrentPower )
 				+ Platform.gui_localize( PowerUnits.AE.unlocalizedName ) + " - " + MessageFormat.format( " {0,number,#.##%} ", percent ) );
 
 	}