ForestryMC/src/main/java/forestry/energy/EnergyManager.java

package forestry.energy;

import java.io.IOException;

import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;

import cofh.api.energy.EnergyStorage;
import cofh.api.energy.IEnergyHandler;
import cofh.api.energy.IEnergyReceiver;
import forestry.api.core.ForestryAPI;
import forestry.core.network.DataInputStreamForestry;
import forestry.core.network.DataOutputStreamForestry;
import forestry.core.network.IStreamable;
import forestry.core.tiles.TileEngine;
import forestry.core.utils.BlockUtil;

public class EnergyManager implements IEnergyHandler, IStreamable {

    private enum EnergyTransferMode {
        EXTRACT,
        RECEIVE,
        BOTH
    }

    private final EnergyStorage energyStorage;
    private EnergyTransferMode mode = EnergyTransferMode.BOTH;

    public EnergyManager(int maxTransfer, int capacity) {
        this.energyStorage = new EnergyStorage(
                scaleForDifficulty(capacity),
                scaleForDifficulty(maxTransfer),
                scaleForDifficulty(maxTransfer));
    }

    public static int scaleForDifficulty(int energyPerUse) {
        return Math.round(energyPerUse * ForestryAPI.activeMode.getFloatSetting("energy.demand.modifier"));
    }

    public void setExtractOnly() {
        mode = EnergyTransferMode.EXTRACT;
    }

    public void setReceiveOnly() {
        mode = EnergyTransferMode.RECEIVE;
    }

    private boolean canExtract() {
        switch (mode) {
            case EXTRACT:
            case BOTH:
                return true;
        }
        return false;
    }

    private boolean canReceive() {
        switch (mode) {
            case RECEIVE:
            case BOTH:
                return true;
        }
        return false;
    }

    /* NBT */
    public EnergyManager readFromNBT(NBTTagCompound nbt) {

        NBTTagCompound energyManagerNBT = nbt.getCompoundTag("EnergyManager");
        NBTTagCompound energyStorageNBT = energyManagerNBT.getCompoundTag("EnergyStorage");
        energyStorage.readFromNBT(energyStorageNBT);

        return this;
    }

    public NBTTagCompound writeToNBT(NBTTagCompound nbt) {

        NBTTagCompound energyStorageNBT = new NBTTagCompound();
        energyStorage.writeToNBT(energyStorageNBT);

        NBTTagCompound energyManagerNBT = new NBTTagCompound();
        energyManagerNBT.setTag("EnergyStorage", energyStorageNBT);
        nbt.setTag("EnergyManager", energyManagerNBT);

        return nbt;
    }

    /* Packets */
    @Override
    public void writeData(DataOutputStreamForestry data) throws IOException {
        int energyStored = energyStorage.getEnergyStored();
        data.writeInt(energyStored);
    }

    @Override
    public void readData(DataInputStreamForestry data) throws IOException {
        int energyStored = data.readInt();
        energyStorage.setEnergyStored(energyStored);
    }

    public int toGuiInt() {
        return energyStorage.getEnergyStored();
    }

    public void fromGuiInt(int packetInt) {
        energyStorage.setEnergyStored(packetInt);
    }

    /* IEnergyHandler */
    @Override
    public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) {
        if (!canReceive()) {
            return 0;
        }
        return energyStorage.receiveEnergy(maxReceive, simulate);
    }

    @Override
    public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) {
        if (!canExtract()) {
            return 0;
        }
        return energyStorage.extractEnergy(maxExtract, simulate);
    }

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

    public int getTotalEnergyStored() {
        return energyStorage.getEnergyStored();
    }

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

    public int getMaxEnergyStored() {
        return energyStorage.getMaxEnergyStored();
    }

    public int getMaxEnergyReceived() {
        return energyStorage.getMaxReceive();
    }

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

    /**
     * Consumes one work cycle's worth of energy.
     *
     * @return true if the energy to do work was consumed
     */
    public boolean consumeEnergyToDoWork(int ticksPerWorkCycle, int energyPerWorkCycle) {
        int energyPerCycle = (int) Math.ceil(energyPerWorkCycle / (float) ticksPerWorkCycle);
        if (energyStorage.getEnergyStored() < energyPerCycle) {
            return false;
        }

        energyStorage.modifyEnergyStored(-energyPerCycle);
        return true;
    }

    /**
     * @return whether this can send energy to the target tile
     */
    public boolean canSendEnergy(ForgeDirection orientation, TileEntity tile) {
        return sendEnergy(orientation, tile, Integer.MAX_VALUE, true) > 0;
    }

    /**
     * Sends as much energy as it can to the tile at orientation. For power sources. Ignores canExtract()
     *
     * @return amount sent
     */
    public int sendEnergy(ForgeDirection orientation, TileEntity tile) {
        return sendEnergy(orientation, tile, Integer.MAX_VALUE, false);
    }

    /**
     * Sends amount of energy to the tile at orientation. For power sources. Ignores canExtract()
     *
     * @return amount sent
     */
    public int sendEnergy(ForgeDirection orientation, TileEntity tile, int amount, boolean simulate) {
        int sent = 0;
        if (BlockUtil.isEnergyReceiverOrEngine(orientation.getOpposite(), tile)) {
            int extractable = energyStorage.extractEnergy(amount, true);
            if (extractable > 0) {

                if (tile instanceof IEnergyReceiver) {
                    IEnergyReceiver receptor = (IEnergyReceiver) tile;
                    sent = receptor.receiveEnergy(orientation.getOpposite(), extractable, simulate);
                } else if (tile instanceof TileEngine) {
                    TileEngine receptor = (TileEngine) tile;
                    sent = receptor.getEnergyManager().receiveEnergy(orientation.getOpposite(), extractable, simulate);
                }

                energyStorage.extractEnergy(sent, simulate);
            }
        }
        return sent;
    }

    /**
     * Drains an amount of energy, due to decay from lack of work or other factors
     */
    public void drainEnergy(int amount) {
        energyStorage.modifyEnergyStored(-amount);
    }

    /**
     * Creates an amount of energy, generated by engines
     */
    public void generateEnergy(int amount) {
        energyStorage.modifyEnergyStored(amount);
    }
}