Added Mekanism API and supporting its power system directly.

Conflicts:
	src/main/scala/li/cil/oc/Settings.scala
	src/main/scala/li/cil/oc/util/mods/Mods.scala

src/api/java/mekanism/api/energy/EnergizedItemManager.java

@@ -0,0 +1,60 @@
+package mekanism.api.energy;
+
+import net.minecraft.item.ItemStack;
+
+public class EnergizedItemManager
+{
+	/**
+	 * Discharges an IEnergizedItem with the defined amount of energy.
+	 * @param itemStack - ItemStack to discharge
+	 * @param amount - amount of energy to discharge from the item, usually the total amount of energy needed in a TileEntity
+	 * @return amount of energy discharged
+	 */
+	public static double discharge(ItemStack itemStack, double amount)
+	{
+		if(itemStack != null)
+		{
+			if(itemStack.getItem() instanceof IEnergizedItem)
+			{
+				IEnergizedItem energizedItem = (IEnergizedItem)itemStack.getItem();
+
+				if(energizedItem.canSend(itemStack))
+				{
+					double energyToUse = Math.min(energizedItem.getMaxTransfer(itemStack), Math.min(energizedItem.getEnergy(itemStack), amount));
+					energizedItem.setEnergy(itemStack, energizedItem.getEnergy(itemStack) - energyToUse);
+
+					return energyToUse;
+				}
+			}
+		}
+
+		return 0;
+	}
+
+	/**
+	 * Charges an IEnergizedItem with the defined amount of energy.
+	 * @param itemStack - ItemStack to charge
+	 * @param amount - amount of energy to charge the item with, usually the total amount of energy stored in a TileEntity
+	 * @return amount of energy charged
+	 */
+	public static double charge(ItemStack itemStack, double amount)
+	{
+		if(itemStack != null)
+		{
+			if(itemStack.getItem() instanceof IEnergizedItem)
+			{
+				IEnergizedItem energizedItem = (IEnergizedItem)itemStack.getItem();
+
+				if(energizedItem.canReceive(itemStack))
+				{
+					double energyToSend = Math.min(energizedItem.getMaxTransfer(itemStack), Math.min(energizedItem.getMaxEnergy(itemStack) - energizedItem.getEnergy(itemStack), amount));
+					energizedItem.setEnergy(itemStack, energizedItem.getEnergy(itemStack) + energyToSend);
+
+					return energyToSend;
+				}
+			}
+		}
+
+		return 0;
+	}
+}

src/api/java/mekanism/api/energy/ICableOutputter.java

@@ -0,0 +1,18 @@
+package mekanism.api.energy;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+/**
+ * Implement this if your TileEntity is capable of outputting energy to cables, overriding Mekanism's default implementation.
+ * @author AidanBrady
+ *
+ */
+public interface ICableOutputter
+{
+	/**
+	 * Whether or not this block can output to a cable on a specific side.
+	 * @param side - side to check
+	 * @return if the block can output
+	 */
+	public boolean canOutputTo(ForgeDirection side);
+}

src/api/java/mekanism/api/energy/IEnergizedItem.java

@@ -0,0 +1,59 @@
+package mekanism.api.energy;
+
+import net.minecraft.item.ItemStack;
+
+/**
+ * Implement this in an item's class if it should be able to store electricity.
+ * @author aidancbrady
+ *
+ */
+public interface IEnergizedItem
+{
+	/**
+	 * Gets and returns the amount of energy stored in this item.
+	 * @param itemStack - the ItemStack to check
+	 * @return energy stored
+	 */
+	public double getEnergy(ItemStack itemStack);
+
+	/**
+	 * Sets this item's stored energy value to a new amount.
+	 * @param itemStack - the ItemStack who's energy value is to be change
+	 * @param amount - new amount of energy
+	 */
+	public void setEnergy(ItemStack itemStack, double amount);
+
+	/**
+	 * Gets and returns this item's maximum amount of energy that can be stored.
+	 * @param itemStack - the ItemStack to check
+	 * @return maximum energy
+	 */
+	public double getMaxEnergy(ItemStack itemStack);
+
+	/**
+	 * Gets and returns how much energy this item can transfer to and from charging slots.
+	 * @param itemStack - the ItemStack to check
+	 * @return transfer amount
+	 */
+	public double getMaxTransfer(ItemStack itemStack);
+
+	/**
+	 * Gets and returns whether or not this item can receive energy from a charging slot.
+	 * @param itemStack - the ItemStack to check
+	 * @return if the item can receive energy
+	 */
+	public boolean canReceive(ItemStack itemStack);
+
+	/**
+	 * Gets and returns whether or not this item can send energy to a charging slot.
+	 * @param itemStack - the ItemStack to check
+	 * @return if the item can send energy
+	 */
+	public boolean canSend(ItemStack itemStack);
+
+	/**
+	 * Returns whether or not this item contains metadata-specific subtypes instead of using metadata for damage display.
+	 * @return if the item contains metadata-specific subtypes
+	 */
+	public boolean isMetadataSpecific(ItemStack itemStack);
+}

src/api/java/mekanism/api/energy/IStrictEnergyAcceptor.java

@@ -0,0 +1,25 @@
+package mekanism.api.energy;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+/**
+ * Implement this if your TileEntity can accept energy at a floating-point double value from Universal Cables.
+ * @author AidanBrady
+ *
+ */
+public interface IStrictEnergyAcceptor extends IStrictEnergyStorage
+{
+	/**
+	 * Transfer a certain amount of energy to this acceptor.
+	 * @param amount - amount to transfer
+	 * @return energy used
+	 */
+	public double transferEnergyToAcceptor(ForgeDirection side, double amount);
+
+	/**
+	 * Whether or not this tile entity accepts energy from a certain side.
+	 * @param side - side to check
+	 * @return if tile entity accepts energy
+	 */
+	public boolean canReceiveEnergy(ForgeDirection side);
+}

src/api/java/mekanism/api/energy/IStrictEnergyStorage.java

@@ -0,0 +1,27 @@
+package mekanism.api.energy;
+
+/**
+ * Mekanism-specific energy storage for TileEntities, already implemented in IStrictEnergyAcceptor.
+ * @author aidancbrady
+ *
+ */
+public interface IStrictEnergyStorage
+{
+	/**
+	 * Gets the amount of energy this TileEntity is currently storing.
+	 * @return stored energy
+	 */
+	public double getEnergy();
+
+	/**
+	 * Sets the amount of stored energy of this TileEntity to a new amount.
+	 * @param energy - new energy value
+	 */
+	public void setEnergy(double energy);
+
+	/**
+	 * Gets the maximum amount of energy this TileEntity can store.
+	 * @return maximum energy
+	 */
+	public double getMaxEnergy();
+}

src/main/scala/li/cil/oc/Settings.scala

@@ -249,15 +249,17 @@ object Settings {
 
   // Power conversion values. These are the same values used by Universal
   // Electricity to provide global power support.
-  val valueBC = 56280.0
-  val valueIC2 = 22512.0
-  val valueTE = 5628.0
+  val valueBC = 500.0
+  val valueIC2 = 200.0
+  val valueMek = 2000.0 / 3.0
+  val valueTE = 50.0
   val valueUE = 1.0
 
   val valueOC = valueBC
 
   val ratioBC = valueBC / valueOC
   val ratioIC2 = valueIC2 / valueOC
+  val ratioMek = valueMek / valueOC
   val ratioTE = valueTE / valueOC
   val ratioUE = valueUE / valueOC
 

src/main/scala/li/cil/oc/common/tileentity/traits/PowerAcceptor.scala

@@ -4,5 +4,6 @@ trait PowerAcceptor
   extends power.Common
   with power.BuildCraft
   with power.IndustrialCraft2
+  with power.Mekanism
   with power.ThermalExpansion
   with power.UniversalElectricity

src/main/scala/li/cil/oc/common/tileentity/traits/power/Mekanism.scala

@@ -0,0 +1,25 @@
+package li.cil.oc.common.tileentity.traits.power
+
+import cpw.mods.fml.common.Optional
+import li.cil.oc.Settings
+import li.cil.oc.util.mods.Mods
+import mekanism.api.energy.IStrictEnergyAcceptor
+import net.minecraftforge.common.util.ForgeDirection
+
+@Optional.Interface(iface = "mekanism.api.energy.IStrictEnergyAcceptor", modid = Mods.IDs.Mekanism)
+trait Mekanism extends Common with IStrictEnergyAcceptor {
+  @Optional.Method(modid = Mods.IDs.Mekanism)
+  override def canReceiveEnergy(side: ForgeDirection) = canConnectPower(side)
+
+  @Optional.Method(modid = Mods.IDs.Mekanism)
+  override def transferEnergyToAcceptor(side: ForgeDirection, amount: Double) = tryChangeBuffer(side, amount * Settings.ratioMek) / Settings.ratioMek
+
+  @Optional.Method(modid = Mods.IDs.Mekanism)
+  override def getMaxEnergy = ForgeDirection.VALID_DIRECTIONS.map(globalBufferSize).max / Settings.ratioMek
+
+  @Optional.Method(modid = Mods.IDs.Mekanism)
+  override def getEnergy = ForgeDirection.VALID_DIRECTIONS.map(globalBuffer).max / Settings.ratioMek
+
+  @Optional.Method(modid = Mods.IDs.Mekanism)
+  override def setEnergy(energy: Double) {}
+}

src/main/scala/li/cil/oc/util/mods/Mods.scala

@@ -12,6 +12,7 @@ object Mods {
     final val ForgeMultipart = "ForgeMultipart"
     final val GregTech = "gregtech_addon"
     final val IndustrialCraft2 = "IC2"
+    final val Mekanism = "Mekanism"
     final val MineFactoryReloaded = "MineFactoryReloaded"
     final val NotEnoughItems = "NotEnoughItems"
     final val PortalGun = "PortalGun"