Mekanism-tilera-Edition/common/buildcraft/api/power/PowerHandler.java

/**
 * Copyright (c) SpaceToad, 2011 http://www.mod-buildcraft.com
 *
 * BuildCraft is distributed under the terms of the Minecraft Mod Public License
 * 1.0, or MMPL. Please check the contents of the license located in
 * http://www.mod-buildcraft.com/MMPL-1.0.txt
 */
package buildcraft.api.power;

import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.common.ForgeDirection;
import buildcraft.api.core.SafeTimeTracker;

public final class PowerHandler
{

	public static enum Type
	{

		ENGINE, GATE, MACHINE, PIPE, STORAGE;

		public boolean canReceiveFromPipes()
		{
			switch (this)
			{
				case MACHINE:
				case STORAGE:
					return true;
				default:
					return false;
			}
		}

		public boolean eatsEngineExcess()
		{
			switch (this)
			{
				case MACHINE:
				case STORAGE:
					return true;
				default:
					return false;
			}
		}
	}

	public static class PerditionCalculator
	{

		public static final float DEFAULT_POWERLOSS = 1F;
		public static final float MIN_POWERLOSS = 0.01F;
		private final float powerLoss;

		public PerditionCalculator()
		{
			powerLoss = DEFAULT_POWERLOSS;
		}

		public PerditionCalculator(float powerLoss)
		{
			if (powerLoss < MIN_POWERLOSS)
			{
				powerLoss = MIN_POWERLOSS;
			}
			this.powerLoss = powerLoss;
		}

		/**
		 * Apply the perdition algorithm to the current stored energy. This function can only be
		 * called once per tick, but it might not be called every tick. It is triggered by any
		 * manipulation of the stored energy.
		 * 
		 * @param powerHandler the PowerHandler requesting the perdition update
		 * @param current the current stored energy
		 * @param ticksPassed ticks since the last time this function was called
		 * @return
		 */
		public float applyPerdition(PowerHandler powerHandler, float current, long ticksPassed)
		{
			current -= powerLoss * ticksPassed;
			if (current < 0)
			{
				current = 0;
			}
			return current;
		}
	}

	public static final PerditionCalculator DEFAULT_PERDITION = new PerditionCalculator();
	private float minEnergyReceived;
	private float maxEnergyReceived;
	private float maxEnergyStored;
	private float activationEnergy;
	private float energyStored = 0;
	private final SafeTimeTracker doWorkTracker = new SafeTimeTracker();
	private final SafeTimeTracker sourcesTracker = new SafeTimeTracker();
	private final SafeTimeTracker perditionTracker = new SafeTimeTracker();
	public final int[] powerSources = new int[6];
	public final IPowerReceptor receptor;
	private PerditionCalculator perdition;
	private final PowerReceiver receiver;
	private final Type type;

	public PowerHandler(IPowerReceptor receptor, Type type)
	{
		this.receptor = receptor;
		this.type = type;
		this.receiver = new PowerReceiver();
		this.perdition = DEFAULT_PERDITION;
	}

	public PowerReceiver getPowerReceiver()
	{
		return receiver;
	}

	public float getMinEnergyReceived()
	{
		return minEnergyReceived;
	}

	public float getMaxEnergyReceived()
	{
		return maxEnergyReceived;
	}

	public float getMaxEnergyStored()
	{
		return maxEnergyStored;
	}

	public float getActivationEnergy()
	{
		return activationEnergy;
	}

	public float getEnergyStored()
	{
		return energyStored;
	}

	/**
	 * Setup your PowerHandler's settings.
	 * 
	 * @param minEnergyReceived This is the minimum about of power that will be accepted by the
	 * PowerHandler. This should generally be greater than the activationEnergy if you plan to use
	 * the doWork() callback. Anything greater than 1 will prevent Redstone Engines from powering
	 * this Provider.
	 * @param maxEnergyReceived The maximum amount of power accepted by the PowerHandler. This
	 * should generally be less than 500. Too low and larger engines will overheat while trying to
	 * power the machine. Too high, and the engines will never warm up. Greater values also place
	 * greater strain on the power net.
	 * @param activationEnergy If the stored energy is greater than this value, the doWork()
	 * callback is called (once per tick).
	 * @param maxStoredEnergy The maximum amount of power this PowerHandler can store. Values tend
	 * to range between 100 and 5000. With 1000 and 1500 being common.
	 */
	public void configure(float minEnergyReceived, float maxEnergyReceived, float activationEnergy, float maxStoredEnergy)
	{
		if (minEnergyReceived > maxEnergyReceived)
		{
			maxEnergyReceived = minEnergyReceived;
		}
		this.minEnergyReceived = minEnergyReceived;
		this.maxEnergyReceived = maxEnergyReceived;
		this.maxEnergyStored = maxStoredEnergy;
		this.activationEnergy = activationEnergy;
	}

	public void configurePowerPerdition(int powerLoss, int powerLossRegularity)
	{
		if (powerLoss == 0 || powerLossRegularity == 0)
		{
			perdition = new PerditionCalculator(0);
			return;
		}
		perdition = new PerditionCalculator((float) powerLoss / (float) powerLossRegularity);
	}

	/**
	 * Allows you to define a new PerditionCalculator class to handler perdition calculations.
	 * 
	 * For example if you want exponentially increasing loss based on amount stored.
	 * 
	 * @param perdition
	 */
	public void setPerdition(PerditionCalculator perdition)
	{
		if (perdition == null)
			perdition = DEFAULT_PERDITION;
		this.perdition = perdition;
	}

	public PerditionCalculator getPerdition()
	{
		if (perdition == null)
			return DEFAULT_PERDITION;
		return perdition;
	}

	/**
	 * Ticks the power handler. You should call this if you can, but its not required.
	 * 
	 * If you don't call it, the possibility exists for some weirdness with the perdition algorithm
	 * and work callback as its possible they will not be called on every tick they otherwise would
	 * be. You should be able to design around this though if you are aware of the limitations.
	 */
	public void update()
	{
		applyPerdition();
		applyWork();
		validateEnergy();
	}

	private void applyPerdition()
	{
		if (perditionTracker.markTimeIfDelay(receptor.getWorld(), 1) && energyStored > 0)
		{
			float newEnergy = getPerdition().applyPerdition(this, energyStored, perditionTracker.durationOfLastDelay());
			if (newEnergy == 0 || newEnergy < energyStored)
				energyStored = newEnergy;
			else
				energyStored = DEFAULT_PERDITION.applyPerdition(this, energyStored, perditionTracker.durationOfLastDelay());
			validateEnergy();
		}
	}

	private void applyWork()
	{
		if (energyStored >= activationEnergy)
		{
			if (doWorkTracker.markTimeIfDelay(receptor.getWorld(), 1))
			{
				receptor.doWork(this);
			}
		}
	}

	private void updateSources(ForgeDirection source)
	{
		if (sourcesTracker.markTimeIfDelay(receptor.getWorld(), 1))
		{
			for (int i = 0; i < 6; ++i)
			{
				powerSources[i] -= sourcesTracker.durationOfLastDelay();
				if (powerSources[i] < 0)
				{
					powerSources[i] = 0;
				}
			}
		}

		if (source != null)
			powerSources[source.ordinal()] = 10;
	}

	/**
	 * Extract energy from the PowerHandler. You must call this even if doWork() triggers.
	 * 
	 * @param min
	 * @param max
	 * @param doUse
	 * @return amount used
	 */
	public float useEnergy(float min, float max, boolean doUse)
	{
		applyPerdition();

		float result = 0;

		if (energyStored >= min)
		{
			if (energyStored <= max)
			{
				result = energyStored;
				if (doUse)
				{
					energyStored = 0;
				}
			}
			else
			{
				result = max;
				if (doUse)
				{
					energyStored -= max;
				}
			}
		}

		validateEnergy();

		return result;
	}

	public void readFromNBT(NBTTagCompound data)
	{
		readFromNBT(data, "powerProvider");
	}

	public void readFromNBT(NBTTagCompound data, String tag)
	{
		NBTTagCompound nbt = data.getCompoundTag(tag);
		energyStored = nbt.getFloat("storedEnergy");
	}

	public void writeToNBT(NBTTagCompound data)
	{
		writeToNBT(data, "powerProvider");
	}

	public void writeToNBT(NBTTagCompound data, String tag)
	{
		NBTTagCompound nbt = new NBTTagCompound();
		nbt.setFloat("storedEnergy", energyStored);
		data.setCompoundTag(tag, nbt);
	}

	public final class PowerReceiver
	{

		private PowerReceiver()
		{
		}

		public float getMinEnergyReceived()
		{
			return minEnergyReceived;
		}

		public float getMaxEnergyReceived()
		{
			return maxEnergyReceived;
		}

		public float getMaxEnergyStored()
		{
			return maxEnergyStored;
		}

		public float getActivationEnergy()
		{
			return activationEnergy;
		}

		public float getEnergyStored()
		{
			return energyStored;
		}

		public Type getType()
		{
			return type;
		}

		public void update()
		{
			PowerHandler.this.update();
		}

		/**
		 * The amount of power that this PowerHandler currently needs.
		 * 
		 * @return
		 */
		public float powerRequest()
		{
			update();
			return Math.min(maxEnergyReceived, maxEnergyStored - energyStored);
		}

		/**
		 * Add power to the PowerReceiver from an external source.
		 * 
		 * @param quantity
		 * @param from
		 * @return the amount of power used
		 */
		public float receiveEnergy(Type source, final float quantity, ForgeDirection from)
		{
			float used = quantity;
			if (source == Type.ENGINE)
			{
				if (used < minEnergyReceived)
				{
					return 0;
				}
				else if (used > maxEnergyReceived)
				{
					used = maxEnergyReceived;
				}
			}

			updateSources(from);

			used = addEnergy(used);

			applyWork();

			if (source == Type.ENGINE && type.eatsEngineExcess())
			{
				return Math.min(quantity, maxEnergyReceived);
			}

			return used;
		}
	}

	/**
	 * 
	 * @return the amount the power changed by
	 */
	public float addEnergy(float quantity)
	{
		energyStored += quantity;

		if (energyStored > maxEnergyStored)
		{
			quantity -= energyStored - maxEnergyStored;
			energyStored = maxEnergyStored;
		}
		else if (energyStored < 0)
		{
			quantity -= energyStored;
			energyStored = 0;
		}

		applyPerdition();

		return quantity;
	}

	public void setEnergy(float quantity)
	{
		this.energyStored = quantity;
		validateEnergy();
	}

	public boolean isPowerSource(ForgeDirection from)
	{
		return powerSources[from.ordinal()] != 0;
	}

	private void validateEnergy()
	{
		if (energyStored < 0)
		{
			energyStored = 0;
		}
		if (energyStored > maxEnergyStored)
		{
			energyStored = maxEnergyStored;
		}
	}
}