Tile Entity Purifier

public class TileEntityPurifier extends TileEntity implements ITickable {

    private ItemStackHandler inventory;
    public EnergyStorage energyStorage;

    private int progress;
    private int currentProgress;

    public TileEntityPurifier() {
        inventory = new ItemStackHandler(2);
        energyStorage = new EnergyStorage(100000, 80, 0);
    }

    public IItemHandler getInventory() {
        return inventory;
    }

    public boolean canProcess() {
        if(inventory.getStackInSlot(0).isEmpty()) {
            return false;
        } else {
            Item itemInSlot = inventory.getStackInSlot(0).getItem();

            return itemInSlot == Item.getItemFromBlock(Blocks.SAND) || itemInSlot == Item.getItemFromBlock(Blocks.SOUL_SAND);
        }
    }

    public List<BlockPos> scanForGenerators(EnumFacing.Plane plane) {
        List<BlockPos> posList = Lists.newArrayList();
        BlockPos pos = getPos();

        if(plane == EnumFacing.Plane.HORIZONTAL) {
            BlockPos[] blockPoses = {
                    pos.north(),
                    pos.east(),
                    pos.south(),
                    pos.west()
            };

            for(BlockPos blockPos : blockPoses) {
                if(blockPos != null) {
                    TileEntity te = world.getTileEntity(blockPos);

                    if(te != null)
                        if(te.hasCapability(CapabilityEnergy.ENERGY, null)) {
                            EnergyStorage es = (EnergyStorage)te.getCapability(CapabilityEnergy.ENERGY, null);

                            if(es.canExtract()) {
                                posList.add(blockPos);
                            }
                        }
                }
            }
        } else {
            BlockPos[] blockPoses = {
                    pos.up(),
                    pos.down()
            };

            for(BlockPos blockPos : blockPoses) {
                if(blockPos != null) {
                    TileEntity te = world.getTileEntity(blockPos);

                    if(te.hasCapability(CapabilityEnergy.ENERGY, null)) {
                        EnergyStorage es = (EnergyStorage)te.getCapability(CapabilityEnergy.ENERGY, null);

                        if(es.canExtract()) {
                            posList.add(blockPos);
                        }
                    }
                }
            }
        }

        return posList;
    }

    //ITickable

    @Override
    public void update() {
        if(!world.isRemote) {
            //Gather power
            List<BlockPos> generators = scanForGenerators(EnumFacing.Plane.HORIZONTAL);

            for(BlockPos gen : generators) {
                TileEntity te = world.getTileEntity(gen);
                EnergyStorage es = (EnergyStorage)te.getCapability(CapabilityEnergy.ENERGY, null);

                int storedEnergy = energyStorage.getEnergyStored();
                int maxEnergy = energyStorage.getMaxEnergyStored();

                if(storedEnergy + 80 <= maxEnergy) {
                    int received = energyStorage.receiveEnergy(es.extractEnergy(80, false), false);

                    if(received > 0) {
                        markDirty();
                    }
                } else if(storedEnergy + 80 > maxEnergy) {
                    int receivable = (storedEnergy + 80) - maxEnergy;
                    int received = energyStorage.receiveEnergy(es.extractEnergy(receivable, false), false);

                    if(received > 0) {
                        markDirty();
                    }
                }
            }
        }
    }

    public int getField(int id) {
        return id == 0 ? progress : id == 1 ? currentProgress : id == 2 ? energyStorage.getEnergyStored() : 0;
    }

    public void setField(int id, int value) {
        progress = id == 0 ? value : progress;
        currentProgress = id == 1 ? value : currentProgress;
        if(id == 2) {
            energyStorage.extractEnergy(energyStorage.getEnergyStored(), false);
            energyStorage.receiveEnergy(value, false);
            markDirty();
        }

        markDirty();
    }

    //NBT/Capability

    @Override
    public NBTTagCompound writeToNBT(NBTTagCompound compound) {
        compound.setTag("inventory", inventory.serializeNBT());
        compound.setInteger("storedEnergy", energyStorage.getEnergyStored());
        return super.writeToNBT(compound);
    }

    @Override
    public void readFromNBT(NBTTagCompound compound) {
        inventory.deserializeNBT(compound.getCompoundTag("inventory"));

        energyStorage = new EnergyStorage(100000);
        energyStorage.receiveEnergy(compound.getInteger("storedEnergy"), false);

        super.readFromNBT(compound);
    }

    @Override
    public boolean hasCapability(Capability<?> capability, @Nullable EnumFacing facing) {
        return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY || capability == CapabilityEnergy.ENERGY ||
                super.hasCapability(capability, facing);
    }

    @Nullable
    @Override
    public <T> T getCapability(Capability<T> capability, @Nullable EnumFacing facing) {
        return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY ? (T)inventory : capability == CapabilityEnergy.ENERGY ? (T)energyStorage :
                super.getCapability(capability, facing);
    }
}