TileEntity

package net.asdfowkw.tech.blocks.windgenerator;

import net.asdfowkw.tech.common.EnergyBuffer;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.ITickable;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.common.capabilities.CapabilityInject;
import net.minecraftforge.energy.CapabilityEnergy;
import net.minecraftforge.energy.IEnergyStorage;
import net.minecraftforge.items.CapabilityItemHandler;
import net.minecraftforge.items.ItemStackHandler;

import javax.annotation.Nullable;

public class TileEntityWindGenerator extends TileEntity implements ITickable {

    public static final int SLOT_COUNT = 3;
    public static final int POWER_LIMIT = 16000;
    public static final int POWERGEN = 40;
    public static final int POWER_TRANSFER_MAX = 320;

    @CapabilityInject(IEnergyStorage.class)
    public static Capability<IEnergyStorage> ENERGY = null;

    public EnergyBuffer buffer = new EnergyBuffer(POWER_LIMIT);
    private final ItemStackHandler fuelSlot = new ItemStackHandler(SLOT_COUNT);

    @Override
    public void update(){
        if (world.isRemote){
            return;
        }
        boolean anyChanged;
        anyChanged = generatePower();
        anyChanged |= transferPower();
        if(anyChanged){
            this.markDirty();
        }
    }

    public int getPowerLevel(){
        return buffer.getEnergyStored();
    }

    private boolean generatePower() {
        boolean anyChanged = false;
        if (buffer.getEnergyStored() < POWER_LIMIT){
            buffer.setEnergy(buffer.getEnergyStored() + POWERGEN);
            System.out.println(getPowerLevel());
            anyChanged = true;
        }
        return anyChanged;
    }

    private boolean transferPower() {
        boolean anyChanged = false;

        int sendPower = Math.min(POWER_TRANSFER_MAX, buffer.getEnergyStored());
        if(sendPower > 0){
            IEnergyStorage[] handlers = new IEnergyStorage[6];
            int[] wantedSide = new int[6];
            int accepted = 0;
            for(EnumFacing neighbor : EnumFacing.VALUES){
                TileEntity e = world.getTileEntity(pos.offset(neighbor));
                EnumFacing from = neighbor.getOpposite();

                if(e == null){
                    continue;
                }

                IEnergyStorage handler = null;
                if (e.hasCapability(CapabilityEnergy.ENERGY, from)) {
                    handler = e.getCapability(CapabilityEnergy.ENERGY, from);
                    if(!handler.canReceive()){
                        handler = null;
                    }
                }
                if(handler != null){
                    handlers[from.ordinal()] = handler;
                    int wanted = handler.receiveEnergy(sendPower, true);
                    wantedSide[from.ordinal()] = wanted;
                    accepted += wanted;
                }
            }

            if(accepted > 0){
                for(EnumFacing from : EnumFacing.VALUES){
                    IEnergyStorage handler = handlers[from.ordinal()];
                    int wanted = wantedSide[from.ordinal()];
                    if(handler == null || wanted == 0){
                        continue;
                    }
                    int given = Math.min(Math.min(buffer.getEnergyStored(), wanted), wanted * accepted / sendPower);
                    int received = Math.min(given, handler.receiveEnergy(given, false));
                    buffer.setEnergy(buffer.getEnergyStored() - received);
                    if(buffer.getEnergyStored() <= 0){
                        break;
                    }
                }
                anyChanged = true;
            }
        }
        return anyChanged;
    }

    //hasCapability is checking if the current block can accept energy from XX face.
    @Override
    public boolean hasCapability(Capability<?> capability, @Nullable EnumFacing facing) {
        if (capability == ENERGY) {
            return true;
        }
        if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY){
            return true;
        }
        return super.hasCapability(capability, facing);
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> T getCapability(Capability<T> capability, @Nullable EnumFacing facing) {
        if (capability == ENERGY){
            return (T) buffer;
        }
        if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY){
            return (T) fuelSlot;
        }
        return super.getCapability(capability, facing);
    }

    @Override
    public NBTTagCompound writeToNBT(NBTTagCompound nbt) {
        nbt.setTag("storedEnergy", CapabilityEnergy.ENERGY.writeNBT(buffer, null));
        //nbt.setTag("ItemStackHandler", this.fuelSlot.serializeNBT());
        return super.writeToNBT(nbt);
    }

    @Override
    public void readFromNBT(NBTTagCompound nbt) {
        CapabilityEnergy.ENERGY.readNBT(buffer, null, nbt.getTag("storedEnergy"));
        super.readFromNBT(nbt);
    }

    public boolean isUseableByPlayer(EntityPlayer player) {
        return world.getTileEntity(pos) == this
                && player.getDistanceSq(pos.getX() + 0.5D, pos.getY() + 0.5D, pos.getZ() + 0.5D) <= 64.0D;
    }

    public int[] getFields()
    {
        return new int[]{buffer.getEnergyStored()};
    }

    public void setFields(int[] values)
    {
        buffer.setEnergy(values[0]);
    }

}