Ok so I have a generator but how can I make it so each block stores its own energy and not the same amount and how can I save it with nbt data

heres my code so far

 

 

package com.linumhost.TileEntity;

import com.linumhost.Blocks.AirGenerator;
import com.linumhost.Energy.IEnergyHandler;
import com.linumhost.Energy.IEnergyProvider;
import com.linumhost.Energy.IEnergyReceiver;
import com.linumhost.lib.RefStrings;

import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.Entity;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;

public class TileEntityAirGeneratorBlock extends TileEntity implements IEnergyProvider{

TileEntity entity;


TileEntityServerCaseBlock server = (TileEntityServerCaseBlock) entity;

public static int energyAmount = 0;
public int energyGenerated = 0;

public static boolean isActive = false;

public boolean canGen = false;

    private static final int MAX_EXTRACTABLE_ENERGY = 200;
private static final int MAX_STORABLE_ENERGY = 100000;

public int delay = 5;

@Override
public void updateEntity() {
	if(delay > 0) {
		delay--;
		return;
	}
	delay = 5;
	if(energyAmount != MAX_STORABLE_ENERGY){
		canGen = true;
            this.energyAmount = Math.min(this.energyAmount + this.energyGenerated, MAX_STORABLE_ENERGY);
            //System.out.println(energyAmount);
	}else if(energyAmount > MAX_STORABLE_ENERGY){
		energyGenerated = 0;
		isActive = false;
	}

	if(canGen){
		isActive = true;
		this.energyGenerated = 80;
	}

        if( this.energyAmount > 0 ) {
            int maxExtractable = MAX_EXTRACTABLE_ENERGY;
            for( ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS ) {
                TileEntity te = this.worldObj.getTileEntity(this.xCoord + direction.offsetX, this.yCoord + direction.offsetY, this.zCoord + direction.offsetZ);

                if( te instanceof IEnergyReceiver ) {
                    IEnergyReceiver receiver = (IEnergyReceiver) te;

                    if( !receiver.canConnectEnergy(direction) ) {
                        continue;
                    }

                    int extractable = this.extractEnergy(direction, maxExtractable, true);
                    int receivable = receiver.receiveEnergy(direction.getOpposite(), extractable, false);

                    maxExtractable -= receivable;
                    this.extractEnergy(direction, receivable, false);
                }

                if( maxExtractable == 0 ) {
                    break;
                }
            }
        }
}

    @Override
    public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) {
        int energyExtracted = Math.min(this.energyAmount, Math.min(MAX_EXTRACTABLE_ENERGY, maxExtract));

        if( !simulate ) {
            this.energyAmount -= energyExtracted;
        }

        return energyExtracted;
    }

    @Override
    public int getEnergyStored(ForgeDirection from) {
        return this.energyAmount;
    }

    @Override
    public int getMaxEnergyStored(ForgeDirection from) {
        return MAX_STORABLE_ENERGY;
    }

    @Override
    public boolean canConnectEnergy(ForgeDirection from) {
        return true;
    }


}
[code]

[code]package com.linumhost.Blocks;

import org.lwjgl.input.Keyboard;

import com.linumhost.CreativeTab.ServerCreativeTab;
import com.linumhost.Gui.AirGeneratorGui;
import com.linumhost.TileEntity.TileEntityAirGeneratorBlock;
import com.linumhost.TileEntity.TileEntityServerCaseBlock;
import com.linumhost.lib.RefStrings;

import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.minecraft.block.BlockContainer;
import net.minecraft.block.material.Material;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.util.MathHelper;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;

public class AirGenerator extends BlockContainer{

public AirGenerator(Material material) {
	super(material);
	setCreativeTab(ServerCreativeTab.tabBlocks);
	setHardness(5F);
	setResistance(10F);
	//this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 2.0F, 0.0F);
}

IIcon activeIcon;
IIcon unactiveIcon;

public Minecraft mc = Minecraft.getMinecraft();

TileEntity entity;

TileEntityAirGeneratorBlock tile = new TileEntityAirGeneratorBlock();


public static IIcon[] icons = new IIcon[6];

@SideOnly(Side.CLIENT)
public static IIcon topIcon;
@SideOnly(Side.CLIENT)
public static IIcon sideIcon;
@SideOnly(Side.CLIENT)
public static IIcon frontIcon;

public void registerBlockIcons(IIconRegister reg, IBlockAccess blockAccess, int x, int y, int z) {
    activeIcon = reg.registerIcon(RefStrings.MODID + ":airGeneratorFrontActivated");
    unactiveIcon = reg.registerIcon(RefStrings.MODID + ":airGeneratorFrontDeactivated");

	for (int side = 0; side < 6; side ++) {
        //this.icons[side] = reg.registerIcon(this.textureName + "_" + i);
        if(side == 0 || side == 1) {
        	//return topIcon;
	        this.icons[side] = reg.registerIcon(RefStrings.MODID + ":airGeneratorTop");
        } else if(side == 1 || side == 4 || side == 3 || side == 5) {
        	//return sideIcon;
	        this.icons[side] = reg.registerIcon(RefStrings.MODID + ":airGeneratorSide");
        } else if(side == 2){
        	this.icons[side] = getIcon();
        }
    }
}


    public IIcon getIcon(){
    	if(TileEntityAirGeneratorBlock.isActive == true){
    		return activeIcon;
    	}
	return unactiveIcon;
}


@Override
public IIcon getIcon(int side, int meta) {
    return this.icons[side];
}


public boolean onBlockActivated(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer, int par6, float par7, float par8, float par9){
	if (!par1World.isRemote){
		//DO STUFF HERE
		mc.displayGuiScreen(new AirGeneratorGui(tile));
		return true;
	}

	return false;
}


@Override
public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase entity, ItemStack itemStack) {
	if(entity == null){
		return;
	}

	//TileEntityAngleVentPipe2Block tile = (TileEntityAngleVentPipe2Block) world.getTileEntity(x,y,z);
	int rotation = MathHelper.floor_double((double)(entity.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;

	if(rotation == 0) {
		world.setBlockMetadataWithNotify(x, y, z, 2, 2);
	}

	if(rotation == 1) {
		world.setBlockMetadataWithNotify(x, y, z, 5, 2);
	}

	if(rotation == 2) {
		world.setBlockMetadataWithNotify(x, y, z, 3, 2);
	}

	if(rotation == 3) {
		world.setBlockMetadataWithNotify(x, y, z, 4, 2);
	}
}

@Override
public TileEntity createNewTileEntity(World p_149915_1_, int p_149915_2_) {
	return new TileEntityAirGeneratorBlock();
}

}