adds power to receptor

build.gradle

@@ -31,10 +31,6 @@ buildProps.withReader {
 }
 
 repositories {
-    maven {
-    name 'Calclavia Maven'
-    url 'http://calclavia.com/maven'
-    }
     maven {
     name = "forge"
     url = "http://files.minecraftforge.net/maven"
@@ -49,12 +45,7 @@ repositories {
     }
 }
 
-dependencies {
-
-    // Would really like to switch to using the new method, so I can update to gradle 2
-    //compile group: 'universalelectricity', name: 'Universal-Electricity', version: "${config.version.universalelectricity}", ext: 'jar', classifier: "dev"
-    compile 'dev.calclavia.universalelectricity:universal-electricity:+:dev'
-
+dependencies {    
     compile group: 'codechicken', name: 'NotEnoughItems', version: "${config.version.minecraft}-${config.version.nei}", ext: 'jar', classifier: "dev"
     compile group: 'codechicken', name: 'CodeChickenCore', version: "${config.version.minecraft}-${config.version.cccore}", ext: 'jar', classifier: "dev"
     compile group: 'codechicken', name: 'CodeChickenLib', version: "${config.version.minecraft}-${config.version.cclib}", ext: 'jar', classifier: "dev"

build.properties

@@ -1,9 +1,8 @@
-version.cccore=1.0.3.26
-version.cclib=1.1.1.98
-version.forge=10.13.0.1208
+version.cccore=1.0.4.29
+version.cclib=1.1.1.104
+version.forge=10.13.2.1231
 version.minecraft=1.7.10
 version.mod.major=1
 version.mod.minor=0
 version.mod.revis=2
-version.nei=1.0.3.56
-version.universalelectricity=4.0.0.63
+version.nei=1.0.3.62

src/main/java/cofh/api/CoFHAPIProps.java

@@ -0,0 +1,13 @@
+package cofh.api;
+
+public class CoFHAPIProps
+{
+
+	private CoFHAPIProps()
+	{
+
+	}
+
+	public static final String VERSION = "1.7.10R1.0.0";
+
+}

src/main/java/cofh/api/energy/EnergyStorage.java

@@ -0,0 +1,184 @@
+package cofh.api.energy;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+/**
+ * Reference implementation of {@link IEnergyStorage}. Use/extend this or implement your own.
+ *
+ * @author King Lemming
+ *
+ */
+public class EnergyStorage implements IEnergyStorage
+{
+
+	protected int energy;
+	protected int capacity;
+	protected int maxReceive;
+	protected int maxExtract;
+
+	public EnergyStorage(int capacity)
+	{
+
+		this(capacity, capacity, capacity);
+	}
+
+	public EnergyStorage(int capacity, int maxTransfer)
+	{
+
+		this(capacity, maxTransfer, maxTransfer);
+	}
+
+	public EnergyStorage(int capacity, int maxReceive, int maxExtract)
+	{
+
+		this.capacity = capacity;
+		this.maxReceive = maxReceive;
+		this.maxExtract = maxExtract;
+	}
+
+	public EnergyStorage readFromNBT(NBTTagCompound nbt)
+	{
+
+		this.energy = nbt.getInteger("Energy");
+
+		if (energy > capacity)
+		{
+			energy = capacity;
+		}
+		return this;
+	}
+
+	public NBTTagCompound writeToNBT(NBTTagCompound nbt)
+	{
+
+		if (energy < 0)
+		{
+			energy = 0;
+		}
+		nbt.setInteger("Energy", energy);
+		return nbt;
+	}
+
+	public void setCapacity(int capacity)
+	{
+
+		this.capacity = capacity;
+
+		if (energy > capacity)
+		{
+			energy = capacity;
+		}
+	}
+
+	public void setMaxTransfer(int maxTransfer)
+	{
+
+		setMaxReceive(maxTransfer);
+		setMaxExtract(maxTransfer);
+	}
+
+	public void setMaxReceive(int maxReceive)
+	{
+
+		this.maxReceive = maxReceive;
+	}
+
+	public void setMaxExtract(int maxExtract)
+	{
+
+		this.maxExtract = maxExtract;
+	}
+
+	public int getMaxReceive()
+	{
+
+		return maxReceive;
+	}
+
+	public int getMaxExtract()
+	{
+
+		return maxExtract;
+	}
+
+	/**
+	 * This function is included to allow for server -> client sync. Do not call this externally to the containing Tile Entity, as not all IEnergyHandlers are guaranteed to have it.
+	 *
+	 * @param energy
+	 */
+	public void setEnergyStored(int energy)
+	{
+
+		this.energy = energy;
+
+		if (this.energy > capacity)
+		{
+			this.energy = capacity;
+		} else if (this.energy < 0)
+		{
+			this.energy = 0;
+		}
+	}
+
+	/**
+	 * This function is included to allow the containing tile to directly and efficiently modify the energy contained in the EnergyStorage. Do not rely on this externally, as not all IEnergyHandlers
+	 * are guaranteed to have it.
+	 *
+	 * @param energy
+	 */
+	public void modifyEnergyStored(int energy)
+	{
+
+		this.energy += energy;
+
+		if (this.energy > capacity)
+		{
+			this.energy = capacity;
+		} else if (this.energy < 0)
+		{
+			this.energy = 0;
+		}
+	}
+
+	/* IEnergyStorage */
+	@Override
+	public int receiveEnergy(int maxReceive, boolean simulate)
+	{
+
+		int energyReceived = Math.min(capacity - energy, Math.min(this.maxReceive, maxReceive));
+
+		if (!simulate)
+		{
+			energy += energyReceived;
+		}
+		return energyReceived;
+	}
+
+	@Override
+	public int extractEnergy(int maxExtract, boolean simulate)
+	{
+
+		int energyExtracted = Math.min(energy, Math.min(this.maxExtract, maxExtract));
+
+		if (!simulate)
+		{
+			energy -= energyExtracted;
+		}
+		return energyExtracted;
+	}
+
+	@Override
+	public int getEnergyStored()
+	{
+
+		return energy;
+	}
+
+	@Override
+	public int getMaxEnergyStored()
+	{
+
+		return capacity;
+	}
+
+}

src/main/java/cofh/api/energy/IEnergyConnection.java

@@ -0,0 +1,22 @@
+package cofh.api.energy;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+/**
+ * Implement this interface on TileEntities which should connect to energy transportation blocks. This is intended for blocks which generate energy but do not accept it; otherwise just use
+ * IEnergyHandler.
+ *
+ * Note that {@link IEnergyHandler} is an extension of this.
+ *
+ * @author King Lemming
+ *
+ */
+public interface IEnergyConnection
+{
+
+	/**
+	 * Returns TRUE if the TileEntity can connect on a given side.
+	 */
+	boolean canConnectEnergy(ForgeDirection from);
+
+}

src/main/java/cofh/api/energy/IEnergyContainerItem.java

@@ -0,0 +1,46 @@
+package cofh.api.energy;
+
+import net.minecraft.item.ItemStack;
+
+/**
+ * Implement this interface on Item classes that support external manipulation of their internal energy storages.
+ *
+ * A reference implementation is provided {@link ItemEnergyContainer}.
+ *
+ * @author King Lemming
+ *
+ */
+public interface IEnergyContainerItem
+{
+
+	/**
+	 * Adds energy to a container item. Returns the quantity of energy that was accepted. This should always return 0 if the item cannot be externally charged.
+	 *
+	 * @param container ItemStack to be charged.
+	 * @param maxReceive Maximum amount of energy to be sent into the item.
+	 * @param simulate If TRUE, the charge will only be simulated.
+	 * @return Amount of energy that was (or would have been, if simulated) received by the item.
+	 */
+	int receiveEnergy(ItemStack container, int maxReceive, boolean simulate);
+
+	/**
+	 * Removes energy from a container item. Returns the quantity of energy that was removed. This should always return 0 if the item cannot be externally discharged.
+	 *
+	 * @param container ItemStack to be discharged.
+	 * @param maxExtract Maximum amount of energy to be extracted from the item.
+	 * @param simulate If TRUE, the discharge will only be simulated.
+	 * @return Amount of energy that was (or would have been, if simulated) extracted from the item.
+	 */
+	int extractEnergy(ItemStack container, int maxExtract, boolean simulate);
+
+	/**
+	 * Get the amount of energy currently stored in the container item.
+	 */
+	int getEnergyStored(ItemStack container);
+
+	/**
+	 * Get the max amount of energy that can be stored in the container item.
+	 */
+	int getMaxEnergyStored(ItemStack container);
+
+}

src/main/java/cofh/api/energy/IEnergyHandler.java

@@ -0,0 +1,46 @@
+package cofh.api.energy;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+/**
+ * Implement this interface on Tile Entities which should handle energy, generally storing it in one or more internal {@link IEnergyStorage} objects.
+ *
+ * A reference implementation is provided {@link TileEnergyHandler}.
+ *
+ * @author King Lemming
+ *
+ */
+public interface IEnergyHandler extends IEnergyConnection
+{
+
+	/**
+	 * Add energy to an IEnergyHandler, internal distribution is left entirely to the IEnergyHandler.
+	 *
+	 * @param from Orientation the energy is received from.
+	 * @param maxReceive Maximum amount of energy to receive.
+	 * @param simulate If TRUE, the charge will only be simulated.
+	 * @return Amount of energy that was (or would have been, if simulated) received.
+	 */
+	int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate);
+
+	/**
+	 * Remove energy from an IEnergyHandler, internal distribution is left entirely to the IEnergyHandler.
+	 *
+	 * @param from Orientation the energy is extracted from.
+	 * @param maxExtract Maximum amount of energy to extract.
+	 * @param simulate If TRUE, the extraction will only be simulated.
+	 * @return Amount of energy that was (or would have been, if simulated) extracted.
+	 */
+	int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate);
+
+	/**
+	 * Returns the amount of energy currently stored.
+	 */
+	int getEnergyStored(ForgeDirection from);
+
+	/**
+	 * Returns the maximum amount of energy that can be stored.
+	 */
+	int getMaxEnergyStored(ForgeDirection from);
+
+}

src/main/java/cofh/api/energy/IEnergyStorage.java

@@ -0,0 +1,42 @@
+package cofh.api.energy;
+
+/**
+ * An energy storage is the unit of interaction with Energy inventories.
+ *
+ * A reference implementation can be found at {@link EnergyStorage}.
+ *
+ * @author King Lemming
+ *
+ */
+public interface IEnergyStorage
+{
+
+	/**
+	 * Adds energy to the storage. Returns quantity of energy that was accepted.
+	 *
+	 * @param maxReceive Maximum amount of energy to be inserted.
+	 * @param simulate If TRUE, the insertion will only be simulated.
+	 * @return Amount of energy that was (or would have been, if simulated) accepted by the storage.
+	 */
+	int receiveEnergy(int maxReceive, boolean simulate);
+
+	/**
+	 * Removes energy from the storage. Returns quantity of energy that was removed.
+	 *
+	 * @param maxExtract Maximum amount of energy to be extracted.
+	 * @param simulate If TRUE, the extraction will only be simulated.
+	 * @return Amount of energy that was (or would have been, if simulated) extracted from the storage.
+	 */
+	int extractEnergy(int maxExtract, boolean simulate);
+
+	/**
+	 * Returns the amount of energy currently stored.
+	 */
+	int getEnergyStored();
+
+	/**
+	 * Returns the maximum amount of energy that can be stored.
+	 */
+	int getMaxEnergyStored();
+
+}