Forge Energy support, added full functionality for Tesla

This commit is contained in:
aidancbrady committed 2017-03-29 12:56:20 -04:00
1 parent 5cea9502cb
commit 0e9f380bd7
27 files changed
+628 -133

No files matched your search

@@ -36,16 +36,19 @@ public class MekanismConfig
public static double TO_IC2;
public static double TO_RF;
public static double TO_TESLA;
public static double TO_FORGE;
public static double FROM_H2;
public static double FROM_IC2;
public static double FROM_RF;
public static double FROM_TESLA;
public static double FROM_FORGE;
public static int laserRange;
public static double laserEnergyNeededPerHardness;
public static double minerSilkMultiplier = 6;
public static boolean blacklistIC2;
public static boolean blacklistRF;
public static boolean blacklistTesla;
public static boolean blacklistForge;
public static boolean destroyDisabledBlocks;
public static boolean prefilledGasTanks;
public static double armoredJetpackDamageRatio;
@@ -250,6 +250,8 @@ public class CommonProxy implements IGuiProvider
general.TO_RF = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "RFToJoules", 0.4D).getDouble();
general.FROM_TESLA = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "JoulesToTesla", 2.5D).getDouble();
general.TO_TESLA = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "TeslaToJoules", 0.4D).getDouble();
general.FROM_FORGE = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "JoulesToForge", 2.5D).getDouble();
general.TO_FORGE = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "ForgeToJoules", 0.4D).getDouble();
general.FROM_H2 = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "HydrogenEnergyDensity", 200D, "Determines Electrolytic Separator usage").getDouble();
general.ETHENE_BURN_TIME = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "EthyleneBurnTime", 40).getInt();
general.ENERGY_PER_REDSTONE = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "EnergyPerRedstone", 10000D).getDouble();
@@ -285,6 +287,7 @@ public class CommonProxy implements IGuiProvider
general.blacklistIC2 = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "BlacklistIC2Power", false).getBoolean();
general.blacklistRF = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "BlacklistRFPower", false).getBoolean();
general.blacklistTesla = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "BlacklistTeslaPower", false).getBoolean();
general.blacklistForge = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "BlacklistForgePower", false).getBoolean();
String s = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "EnergyType", "J", null, new String[]{"J", "RF", "EU", "T"}).getString();
+9 -9
View File
@@ -161,15 +161,15 @@ import com.mojang.authlib.GameProfile;
*
*/
@Mod(modid = "mekanism", name = "Mekanism", version = "9.3.0", guiFactory = "mekanism.client.gui.ConfigGuiFactory",
dependencies = "required-after:mcmultipart;" +
"after:JEI;" +
"after:BuildCraft;" +
"after:BuildCraftAPI;" +
"after:IC2;" +
"after:CoFHCore;" +
"after:ComputerCraft;" +
"after:Galacticraft API;" +
"after:MetallurgyCore")
dependencies = "after:mcmultipart;" +
"after:jei;" +
"after:buildcraft;" +
"after:buildcraftapi;" +
"after:ic2;" +
"after:cofhcore;" +
"after:computercraft;" +
"after:galacticraft api;" +
"after:metallurgycore")
public class Mekanism
{
/** Mekanism Packet Pipeline */
@@ -12,6 +12,8 @@ import mekanism.common.util.MekanismUtils;
import net.darkhax.tesla.api.ITeslaConsumer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.energy.CapabilityEnergy;
import net.minecraftforge.energy.IEnergyStorage;
import cofh.api.energy.IEnergyReceiver;
public abstract class EnergyAcceptorWrapper implements IStrictEnergyAcceptor
@@ -35,6 +37,10 @@ public abstract class EnergyAcceptorWrapper implements IStrictEnergyAcceptor
{
wrapper = new TeslaAcceptor(CapabilityUtils.getCapability(tileEntity, Capabilities.TESLA_CONSUMER_CAPABILITY, side));
}
else if(MekanismUtils.useForge() && CapabilityUtils.hasCapability(tileEntity, CapabilityEnergy.ENERGY, side))
{
wrapper = new ForgeAcceptor(CapabilityUtils.getCapability(tileEntity, CapabilityEnergy.ENERGY, side));
}
else if(MekanismUtils.useRF() && tileEntity instanceof IEnergyReceiver)
{
wrapper = new RFAcceptor((IEnergyReceiver)tileEntity);
@@ -271,4 +277,57 @@ public abstract class EnergyAcceptorWrapper implements IStrictEnergyAcceptor
return tesla*general.FROM_TESLA;
}
}
public static class ForgeAcceptor extends EnergyAcceptorWrapper
{
private IEnergyStorage acceptor;
public ForgeAcceptor(IEnergyStorage forgeConsumer)
{
acceptor = forgeConsumer;
}
@Override
public double transferEnergyToAcceptor(EnumFacing side, double amount)
{
return fromForge(acceptor.receiveEnergy(Math.min(Integer.MAX_VALUE, toForge(amount)), false));
}
@Override
public boolean canReceiveEnergy(EnumFacing side)
{
return acceptor.canReceive();
}
@Override
public double getEnergy()
{
return 0;
}
@Override
public void setEnergy(double energy) {}
@Override
public double getMaxEnergy()
{
return 0;
}
@Override
public boolean needsEnergy(EnumFacing side)
{
return acceptor.canReceive();
}
public int toForge(double joules)
{
return (int)Math.round(joules*general.TO_FORGE);
}
public double fromForge(double forge)
{
return forge*general.FROM_FORGE;
}
}
}
@@ -14,6 +14,7 @@ import mekanism.api.energy.IEnergizedItem;
import mekanism.common.Mekanism;
import mekanism.common.MekanismItems;
import mekanism.common.base.ISustainedInventory;
import mekanism.common.capabilities.Capabilities;
import mekanism.common.entity.ai.RobitAIFollow;
import mekanism.common.entity.ai.RobitAIPickup;
import mekanism.common.item.ItemConfigurator;
@@ -22,6 +23,7 @@ import mekanism.common.tile.TileEntityChargepad;
import mekanism.common.util.InventoryUtils;
import mekanism.common.util.MekanismUtils;
import micdoodle8.mods.galacticraft.api.entity.IEntityBreathable;
import net.darkhax.tesla.api.ITeslaProducer;
import net.minecraft.entity.EntityCreature;
import net.minecraft.entity.SharedMonsterAttributes;
import net.minecraft.entity.ai.EntityAILookIdle;
@@ -51,6 +53,8 @@ import net.minecraft.util.math.Vec3d;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeHooks;
import net.minecraftforge.common.util.Constants;
import net.minecraftforge.energy.CapabilityEnergy;
import net.minecraftforge.energy.IEnergyStorage;
import net.minecraftforge.fml.common.FMLCommonHandler;
import net.minecraftforge.fml.common.Optional.Interface;
import cofh.api.energy.IEnergyContainerItem;
@@ -179,37 +183,53 @@ public class EntityRobit extends EntityCreature implements IInventory, ISustaine
{
goHome();
}
ItemStack stack = inventory.get(27);
if(!inventory.get(27).isEmpty() && getEnergy() < MAX_ELECTRICITY)
if(!stack.isEmpty() && getEnergy() < MAX_ELECTRICITY)
{
if(inventory.get(27).getItem() instanceof IEnergizedItem)
if(stack.getItem() instanceof IEnergizedItem)
{
setEnergy(getEnergy() + EnergizedItemManager.discharge(inventory.get(27), MAX_ELECTRICITY - getEnergy()));
setEnergy(getEnergy() + EnergizedItemManager.discharge(stack, MAX_ELECTRICITY - getEnergy()));
}
else if(MekanismUtils.useIC2() && inventory.get(27).getItem() instanceof IElectricItem)
else if(MekanismUtils.useTesla() && stack.hasCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null))
{
IElectricItem item = (IElectricItem)inventory.get(27).getItem();
if(item.canProvideEnergy(inventory.get(27)))
ITeslaProducer producer = stack.getCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null);
long needed = (long)Math.round((MAX_ELECTRICITY-getEnergy())*general.TO_TESLA);
setEnergy(getEnergy() + producer.takePower(needed, false)*general.FROM_TESLA);
}
else if(MekanismUtils.useForge() && stack.hasCapability(CapabilityEnergy.ENERGY, null))
{
IEnergyStorage storage = stack.getCapability(CapabilityEnergy.ENERGY, null);
if(storage.canExtract())
{
double gain = ElectricItem.manager.discharge(inventory.get(27), (MAX_ELECTRICITY - getEnergy())* general.TO_IC2, 4, true, true, false)*general.FROM_IC2;
int needed = (int)Math.round(Math.min(Integer.MAX_VALUE, (MAX_ELECTRICITY-getEnergy())*general.TO_FORGE));
setEnergy(getEnergy() + storage.extractEnergy(needed, false)*general.FROM_FORGE);
}
}
else if(MekanismUtils.useRF() && stack.getItem() instanceof IEnergyContainerItem)
{
IEnergyContainerItem item = (IEnergyContainerItem)stack.getItem();
int needed = (int)Math.round(Math.min(Integer.MAX_VALUE, (MAX_ELECTRICITY - getEnergy())*general.TO_RF));
setEnergy(getEnergy() + (item.extractEnergy(stack, needed, false)*general.FROM_RF));
}
else if(MekanismUtils.useIC2() && stack.getItem() instanceof IElectricItem)
{
IElectricItem item = (IElectricItem)stack.getItem();
if(item.canProvideEnergy(stack))
{
double gain = ElectricItem.manager.discharge(stack, (MAX_ELECTRICITY - getEnergy())*general.TO_IC2, 4, true, true, false)*general.FROM_IC2;
setEnergy(getEnergy() + gain);
}
}
else if(MekanismUtils.useRF() && inventory.get(27).getItem() instanceof IEnergyContainerItem)
{
ItemStack itemStack = inventory.get(27);
IEnergyContainerItem item = (IEnergyContainerItem)inventory.get(27).getItem();
int itemEnergy = (int)Math.round(Math.min(Math.sqrt(item.getMaxEnergyStored(itemStack)), item.getEnergyStored(itemStack)));
int toTransfer = (int)Math.round(Math.min(itemEnergy, ((MAX_ELECTRICITY - getEnergy())*general.TO_RF)));
setEnergy(getEnergy() + (item.extractEnergy(itemStack, toTransfer, false)* general.FROM_RF));
}
else if(inventory.get(27).getItem() == Items.REDSTONE && getEnergy()+ general.ENERGY_PER_REDSTONE <= MAX_ELECTRICITY)
else if(stack.getItem() == Items.REDSTONE && getEnergy()+general.ENERGY_PER_REDSTONE <= MAX_ELECTRICITY)
{
setEnergy(getEnergy() + general.ENERGY_PER_REDSTONE);
inventory.get(27).shrink(1);
stack.shrink(1);
}
}
@@ -0,0 +1,65 @@
package mekanism.common.integration.forgeenergy;
import mekanism.api.MekanismConfig.general;
import mekanism.common.tile.transmitter.TileEntityUniversalCable;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.energy.IEnergyStorage;
public class ForgeEnergyCableIntegration implements IEnergyStorage
{
public TileEntityUniversalCable tileEntity;
public EnumFacing side;
public ForgeEnergyCableIntegration(TileEntityUniversalCable tile, EnumFacing facing)
{
tileEntity = tile;
side = facing;
}
@Override
public int receiveEnergy(int maxReceive, boolean simulate)
{
return rfToForge(tileEntity.receiveEnergy(side, forgeToRF(maxReceive), simulate));
}
@Override
public int extractEnergy(int maxExtract, boolean simulate)
{
return 0;
}
@Override
public int getEnergyStored()
{
return (int)Math.round(Math.min(Integer.MAX_VALUE, tileEntity.getEnergy()*general.TO_FORGE));
}
@Override
public int getMaxEnergyStored()
{
return (int)Math.round(Math.min(Integer.MAX_VALUE, tileEntity.getMaxEnergy()*general.TO_FORGE));
}
@Override
public boolean canExtract()
{
return false;
}
@Override
public boolean canReceive()
{
return tileEntity.canReceiveEnergy(side);
}
public static int rfToForge(int rf)
{
return (int)Math.round(rf*general.FROM_RF*general.TO_FORGE);
}
public static int forgeToRF(int forge)
{
return (int)Math.round(forge*general.FROM_FORGE*general.TO_RF);
}
}
@@ -0,0 +1,65 @@
package mekanism.common.integration.forgeenergy;
import mekanism.api.MekanismConfig.general;
import mekanism.common.base.IEnergyWrapper;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.energy.IEnergyStorage;
public class ForgeEnergyIntegration implements IEnergyStorage
{
public IEnergyWrapper tileEntity;
public EnumFacing side;
public ForgeEnergyIntegration(IEnergyWrapper tile, EnumFacing facing)
{
tileEntity = tile;
side = facing;
}
@Override
public int receiveEnergy(int maxReceive, boolean simulate)
{
return rfToForge(tileEntity.receiveEnergy(side, forgeToRF(maxReceive), simulate));
}
@Override
public int extractEnergy(int maxExtract, boolean simulate)
{
return rfToForge(tileEntity.extractEnergy(side, forgeToRF(maxExtract), simulate));
}
@Override
public int getEnergyStored()
{
return (int)Math.round(Math.min(Integer.MAX_VALUE, tileEntity.getEnergy()*general.TO_FORGE));
}
@Override
public int getMaxEnergyStored()
{
return (int)Math.round(Math.min(Integer.MAX_VALUE, tileEntity.getMaxEnergy()*general.TO_FORGE));
}
@Override
public boolean canExtract()
{
return tileEntity.getOutputtingSides().contains(side);
}
@Override
public boolean canReceive()
{
return tileEntity.getConsumingSides().contains(side);
}
public static int rfToForge(int rf)
{
return (int)Math.round(rf*general.FROM_RF*general.TO_FORGE);
}
public static int forgeToRF(int forge)
{
return (int)Math.round(forge*general.FROM_FORGE*general.TO_RF);
}
}
@@ -0,0 +1,84 @@
package mekanism.common.integration.forgeenergy;
import mekanism.api.MekanismConfig.general;
import mekanism.api.energy.IEnergizedItem;
import mekanism.common.capabilities.ItemCapabilityWrapper.ItemCapability;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.energy.CapabilityEnergy;
import net.minecraftforge.energy.IEnergyStorage;
public class ForgeEnergyItemWrapper extends ItemCapability implements IEnergyStorage
{
@Override
public boolean canProcess(Capability capability)
{
return capability == CapabilityEnergy.ENERGY;
}
public IEnergizedItem getItem()
{
return (IEnergizedItem)getStack().getItem();
}
@Override
public int receiveEnergy(int maxReceive, boolean simulate)
{
if(getItem().canReceive(getStack()))
{
int energyNeeded = getMaxEnergyStored()-getEnergyStored();
int toReceive = Math.min(maxReceive, energyNeeded);
if(!simulate)
{
getItem().setEnergy(getStack(), getItem().getEnergy(getStack()) + toReceive*general.FROM_TESLA);
}
return toReceive;
}
return 0;
}
@Override
public int extractEnergy(int maxExtract, boolean simulate)
{
if(getItem().canSend(getStack()))
{
int energyRemaining = getEnergyStored();
int toSend = Math.min(maxExtract, energyRemaining);
if(!simulate)
{
getItem().setEnergy(getStack(), getItem().getEnergy(getStack()) - toSend*general.FROM_TESLA);
}
return toSend;
}
return 0;
}
@Override
public int getEnergyStored()
{
return (int)Math.round(getItem().getEnergy(getStack())*general.TO_FORGE);
}
@Override
public int getMaxEnergyStored()
{
return (int)Math.round(getItem().getMaxEnergy(getStack())*general.TO_FORGE);
}
@Override
public boolean canExtract()
{
return getItem().canSend(getStack());
}
@Override
public boolean canReceive()
{
return getItem().canReceive(getStack());
}
}
@@ -1,4 +1,4 @@
package mekanism.common.integration;
package mekanism.common.integration.ic2;
import ic2.api.energy.EnergyNet;
import ic2.api.energy.tile.IEnergySink;
@@ -1,4 +1,4 @@
package mekanism.common.integration;
package mekanism.common.integration.ic2;
import ic2.api.item.IElectricItemManager;
import mekanism.api.MekanismConfig.general;
@@ -0,0 +1,39 @@
package mekanism.common.integration.tesla;
import mekanism.api.MekanismConfig.general;
import mekanism.common.tile.transmitter.TileEntityUniversalCable;
import net.darkhax.tesla.api.ITeslaConsumer;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.fml.common.Optional.Interface;
import net.minecraftforge.fml.common.Optional.Method;
@Interface(iface = "net.darkhax.tesla.api.ITeslaConsumer", modid = "tesla")
public class TeslaCableIntegration implements ITeslaConsumer
{
public TileEntityUniversalCable tileEntity;
public EnumFacing side;
public TeslaCableIntegration(TileEntityUniversalCable tile, EnumFacing facing)
{
tileEntity = tile;
side = facing;
}
@Override
@Method(modid = "tesla")
public long givePower(long power, boolean simulated)
{
return rfToTesla(tileEntity.receiveEnergy(side, teslaToRF(power), simulated));
}
public long rfToTesla(int rf)
{
return (long)Math.round(rf*general.FROM_RF*general.TO_TESLA);
}
public int teslaToRF(long tesla)
{
return (int)Math.round(Math.min(Integer.MAX_VALUE, tesla*general.FROM_TESLA*general.TO_RF));
}
}
@@ -1,4 +1,4 @@
package mekanism.common.integration;
package mekanism.common.integration.tesla;
import mekanism.api.MekanismConfig.general;
import mekanism.common.base.IEnergyWrapper;
@@ -45,13 +45,23 @@ public class TeslaIntegration implements ITeslaHolder, ITeslaConsumer, ITeslaPro
@Method(modid = "tesla")
public long takePower(long power, boolean simulated)
{
return (long)(tileEntity.extractEnergy(side, (int)(power*general.FROM_TESLA*general.TO_RF), simulated)*general.FROM_RF*general.TO_TESLA);
return rfToTesla(tileEntity.extractEnergy(side, teslaToRF(power), simulated));
}
@Override
@Method(modid = "tesla")
public long givePower(long power, boolean simulated)
{
return (long)(tileEntity.receiveEnergy(side, (int)(power*general.FROM_TESLA*general.TO_RF), simulated)*general.FROM_RF*general.TO_TESLA);
return rfToTesla(tileEntity.receiveEnergy(side, teslaToRF(power), simulated));
}
public long rfToTesla(int rf)
{
return (long)Math.round(rf*general.FROM_RF*general.TO_TESLA);
}
public int teslaToRF(long tesla)
{
return (int)Math.round(Math.min(Integer.MAX_VALUE, tesla*general.FROM_TESLA*general.TO_RF));
}
}
@@ -1,4 +1,4 @@
package mekanism.common.integration;
package mekanism.common.integration.tesla;
import mekanism.api.MekanismConfig.general;
import mekanism.api.energy.IEnergizedItem;
@@ -21,8 +21,9 @@ import mekanism.common.base.ISideConfiguration;
import mekanism.common.base.ISustainedInventory;
import mekanism.common.base.ITierItem;
import mekanism.common.capabilities.ItemCapabilityWrapper;
import mekanism.common.integration.IC2ItemManager;
import mekanism.common.integration.TeslaItemWrapper;
import mekanism.common.integration.forgeenergy.ForgeEnergyItemWrapper;
import mekanism.common.integration.ic2.IC2ItemManager;
import mekanism.common.integration.tesla.TeslaItemWrapper;
import mekanism.common.network.PacketTileEntity.TileEntityMessage;
import mekanism.common.security.ISecurityItem;
import mekanism.common.security.ISecurityTile;
@@ -382,6 +383,6 @@ public class ItemBlockEnergyCube extends ItemBlock implements IEnergizedItem, IS
@Override
public ICapabilityProvider initCapabilities(ItemStack stack, NBTTagCompound nbt)
{
return new ItemCapabilityWrapper(stack, new TeslaItemWrapper());
return new ItemCapabilityWrapper(stack, new TeslaItemWrapper(), new ForgeEnergyItemWrapper());
}
}
@@ -31,8 +31,9 @@ import mekanism.common.base.ITierItem;
import mekanism.common.base.IUpgradeTile;
import mekanism.common.block.states.BlockStateMachine.MachineType;
import mekanism.common.capabilities.ItemCapabilityWrapper;
import mekanism.common.integration.IC2ItemManager;
import mekanism.common.integration.TeslaItemWrapper;
import mekanism.common.integration.forgeenergy.ForgeEnergyItemWrapper;
import mekanism.common.integration.ic2.IC2ItemManager;
import mekanism.common.integration.tesla.TeslaItemWrapper;
import mekanism.common.inventory.InventoryPersonalChest;
import mekanism.common.network.PacketTileEntity.TileEntityMessage;
import mekanism.common.security.ISecurityItem;
@@ -927,7 +928,7 @@ public class ItemBlockMachine extends ItemBlock implements IEnergizedItem, ISpec
@Override
public ICapabilityProvider initCapabilities(ItemStack stack, NBTTagCompound nbt)
{
return new ItemCapabilityWrapper(stack, new FluidItemWrapper(), new TeslaItemWrapper()) {
return new ItemCapabilityWrapper(stack, new TeslaItemWrapper(), new ForgeEnergyItemWrapper(), new FluidItemWrapper()) {
@Override
public boolean hasCapability(Capability<?> capability, EnumFacing facing)
{
@@ -10,8 +10,9 @@ import mekanism.api.MekanismConfig.general;
import mekanism.api.energy.IEnergizedItem;
import mekanism.common.Mekanism;
import mekanism.common.capabilities.ItemCapabilityWrapper;
import mekanism.common.integration.IC2ItemManager;
import mekanism.common.integration.TeslaItemWrapper;
import mekanism.common.integration.forgeenergy.ForgeEnergyItemWrapper;
import mekanism.common.integration.ic2.IC2ItemManager;
import mekanism.common.integration.tesla.TeslaItemWrapper;
import mekanism.common.util.ItemDataUtils;
import mekanism.common.util.LangUtils;
import mekanism.common.util.MekanismUtils;
@@ -179,6 +180,6 @@ public class ItemEnergized extends ItemMekanism implements IEnergizedItem, ISpec
@Override
public ICapabilityProvider initCapabilities(ItemStack stack, NBTTagCompound nbt)
{
return new ItemCapabilityWrapper(stack, new TeslaItemWrapper());
return new ItemCapabilityWrapper(stack, new TeslaItemWrapper(), new ForgeEnergyItemWrapper());
}
}
@@ -12,8 +12,9 @@ import mekanism.client.render.ModelCustomArmor;
import mekanism.client.render.ModelCustomArmor.ArmorModel;
import mekanism.common.Mekanism;
import mekanism.common.capabilities.ItemCapabilityWrapper;
import mekanism.common.integration.IC2ItemManager;
import mekanism.common.integration.TeslaItemWrapper;
import mekanism.common.integration.forgeenergy.ForgeEnergyItemWrapper;
import mekanism.common.integration.ic2.IC2ItemManager;
import mekanism.common.integration.tesla.TeslaItemWrapper;
import mekanism.common.util.ItemDataUtils;
import mekanism.common.util.LangUtils;
import mekanism.common.util.MekanismUtils;
@@ -231,6 +232,6 @@ public class ItemFreeRunners extends ItemArmor implements IEnergizedItem, ISpeci
@Override
public ICapabilityProvider initCapabilities(ItemStack stack, NBTTagCompound nbt)
{
return new ItemCapabilityWrapper(stack, new TeslaItemWrapper());
return new ItemCapabilityWrapper(stack, new TeslaItemWrapper(), new ForgeEnergyItemWrapper());
}
}
@@ -45,6 +45,8 @@ public class PacketConfigSync implements IMessageHandler<ConfigSyncMessage, IMes
dataStream.writeDouble(general.TO_RF);
dataStream.writeDouble(general.FROM_TESLA);
dataStream.writeDouble(general.TO_TESLA);
dataStream.writeDouble(general.FROM_FORGE);
dataStream.writeDouble(general.TO_FORGE);
dataStream.writeDouble(general.FROM_H2);
dataStream.writeInt(general.ETHENE_BURN_TIME);
dataStream.writeDouble(general.ENERGY_PER_REDSTONE);
@@ -56,6 +58,7 @@ public class PacketConfigSync implements IMessageHandler<ConfigSyncMessage, IMes
dataStream.writeBoolean(general.blacklistIC2);
dataStream.writeBoolean(general.blacklistRF);
dataStream.writeBoolean(general.blacklistTesla);
dataStream.writeBoolean(general.blacklistForge);
dataStream.writeDouble(general.armoredJetpackDamageRatio);
dataStream.writeInt(general.armoredJetpackDamageMax);
dataStream.writeBoolean(general.aestheticWorldDamage);
@@ -138,6 +141,8 @@ public class PacketConfigSync implements IMessageHandler<ConfigSyncMessage, IMes
general.TO_RF = dataStream.readDouble();
general.FROM_TESLA = dataStream.readDouble();
general.TO_TESLA = dataStream.readDouble();
general.FROM_FORGE = dataStream.readDouble();
general.TO_FORGE = dataStream.readDouble();
general.FROM_H2 = dataStream.readDouble();
general.ETHENE_BURN_TIME = dataStream.readInt();
general.ENERGY_PER_REDSTONE = dataStream.readDouble();
@@ -149,6 +154,7 @@ public class PacketConfigSync implements IMessageHandler<ConfigSyncMessage, IMes
general.blacklistIC2 = dataStream.readBoolean();
general.blacklistRF = dataStream.readBoolean();
general.blacklistTesla = dataStream.readBoolean();
general.blacklistForge = dataStream.readBoolean();
general.armoredJetpackDamageRatio = dataStream.readDouble();
general.armoredJetpackDamageMax = dataStream.readInt();
general.aestheticWorldDamage = dataStream.readBoolean();
@@ -16,9 +16,11 @@ import mekanism.api.energy.EnergizedItemManager;
import mekanism.api.energy.IEnergizedItem;
import mekanism.common.Mekanism;
import mekanism.common.block.states.BlockStateMachine;
import mekanism.common.capabilities.Capabilities;
import mekanism.common.entity.EntityRobit;
import mekanism.common.network.PacketTileEntity.TileEntityMessage;
import mekanism.common.util.MekanismUtils;
import net.darkhax.tesla.api.ITeslaConsumer;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.SoundEvents;
@@ -29,6 +31,8 @@ import net.minecraft.util.EnumParticleTypes;
import net.minecraft.util.NonNullList;
import net.minecraft.util.SoundCategory;
import net.minecraft.util.math.AxisAlignedBB;
import net.minecraftforge.energy.CapabilityEnergy;
import net.minecraftforge.energy.IEnergyStorage;
import net.minecraftforge.fml.common.FMLCommonHandler;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
@@ -132,20 +136,35 @@ public class TileEntityChargepad extends TileEntityNoisyElectricBlock
{
setEnergy(getEnergy() - EnergizedItemManager.charge(itemstack, getEnergy()));
}
else if(MekanismUtils.useIC2() && itemstack.getItem() instanceof IElectricItem)
else if(MekanismUtils.useTesla() && itemstack.hasCapability(Capabilities.TESLA_CONSUMER_CAPABILITY, null))
{
double sent = ElectricItem.manager.charge(itemstack, (int)(getEnergy()*general.TO_IC2), 4, true, false)*general.FROM_IC2;
setEnergy(getEnergy() - sent);
ITeslaConsumer consumer = itemstack.getCapability(Capabilities.TESLA_CONSUMER_CAPABILITY, null);
long stored = (long)Math.round(getEnergy()*general.TO_TESLA);
setEnergy(getEnergy() - consumer.givePower(stored, false)*general.FROM_TESLA);
}
else if(MekanismUtils.useForge() && itemstack.hasCapability(CapabilityEnergy.ENERGY, null))
{
IEnergyStorage storage = itemstack.getCapability(CapabilityEnergy.ENERGY, null);
if(storage.canReceive())
{
int stored = (int)Math.round(Math.min(Integer.MAX_VALUE, getEnergy()*general.TO_FORGE));
setEnergy(getEnergy() - storage.receiveEnergy(stored, false)*general.FROM_FORGE);
}
}
else if(MekanismUtils.useRF() && itemstack.getItem() instanceof IEnergyContainerItem)
{
IEnergyContainerItem item = (IEnergyContainerItem)itemstack.getItem();
int itemEnergy = (int)Math.round(Math.min(Math.sqrt(item.getMaxEnergyStored(itemstack)), item.getMaxEnergyStored(itemstack) - item.getEnergyStored(itemstack)));
int toTransfer = (int)Math.round(Math.min(itemEnergy, (getEnergy()*general.TO_RF)));
int toTransfer = (int)Math.round(getEnergy()*general.TO_RF);
setEnergy(getEnergy() - (item.receiveEnergy(itemstack, toTransfer, false)*general.FROM_RF));
}
else if(MekanismUtils.useIC2() && itemstack.getItem() instanceof IElectricItem)
{
double sent = ElectricItem.manager.charge(itemstack, getEnergy()*general.TO_IC2, 4, true, false)*general.FROM_IC2;
setEnergy(getEnergy() - sent);
}
}
}
@@ -17,13 +17,15 @@ import mekanism.api.util.CapabilityUtils;
import mekanism.common.base.IEnergyWrapper;
import mekanism.common.capabilities.Capabilities;
import mekanism.common.capabilities.CapabilityWrapperManager;
import mekanism.common.integration.TeslaIntegration;
import mekanism.common.integration.forgeenergy.ForgeEnergyIntegration;
import mekanism.common.integration.tesla.TeslaIntegration;
import mekanism.common.util.MekanismUtils;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.energy.CapabilityEnergy;
import net.minecraftforge.fml.common.FMLCommonHandler;
import net.minecraftforge.fml.common.Optional.Method;
@@ -263,13 +265,13 @@ public abstract class TileEntityElectricBlock extends TileEntityContainerBlock i
@Override
public int getEnergyStored(EnumFacing from)
{
return (int)Math.round(getEnergy()*general.TO_RF);
return (int)Math.round(Math.min(Integer.MAX_VALUE, getEnergy()*general.TO_RF));
}
@Override
public int getMaxEnergyStored(EnumFacing from)
{
return (int)Math.round(getMaxEnergy()*general.TO_RF);
return (int)Math.round(Math.min(Integer.MAX_VALUE, getMaxEnergy()*general.TO_RF));
}
@Override
@@ -434,10 +436,12 @@ public abstract class TileEntityElectricBlock extends TileEntityContainerBlock i
|| capability == Capabilities.TESLA_HOLDER_CAPABILITY
|| (capability == Capabilities.TESLA_CONSUMER_CAPABILITY && getConsumingSides().contains(facing))
|| (capability == Capabilities.TESLA_PRODUCER_CAPABILITY && getOutputtingSides().contains(facing))
|| capability == CapabilityEnergy.ENERGY
|| super.hasCapability(capability, facing);
}
private CapabilityWrapperManager teslaManager = new CapabilityWrapperManager(IEnergyWrapper.class, TeslaIntegration.class);
private CapabilityWrapperManager forgeEnergyManager = new CapabilityWrapperManager(IEnergyWrapper.class, ForgeEnergyIntegration.class);
@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing)
@@ -455,6 +459,11 @@ public abstract class TileEntityElectricBlock extends TileEntityContainerBlock i
return (T)teslaManager.getWrapper(this, facing);
}
if(capability == CapabilityEnergy.ENERGY)
{
return (T)forgeEnergyManager.getWrapper(this, facing);
}
return super.getCapability(capability, facing);
}
}
@@ -23,7 +23,8 @@ import mekanism.common.base.IActiveState;
import mekanism.common.base.IEnergyWrapper;
import mekanism.common.capabilities.Capabilities;
import mekanism.common.capabilities.CapabilityWrapperManager;
import mekanism.common.integration.TeslaIntegration;
import mekanism.common.integration.forgeenergy.ForgeEnergyIntegration;
import mekanism.common.integration.tesla.TeslaIntegration;
import mekanism.common.network.PacketTileEntity.TileEntityMessage;
import mekanism.common.util.CableUtils;
import mekanism.common.util.LangUtils;
@@ -36,6 +37,7 @@ import net.minecraft.util.EnumFacing;
import net.minecraft.util.text.TextComponentString;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.energy.CapabilityEnergy;
import net.minecraftforge.fml.common.FMLCommonHandler;
import net.minecraftforge.fml.common.Optional.Interface;
import net.minecraftforge.fml.common.Optional.InterfaceList;
@@ -508,10 +510,12 @@ public class TileEntityInductionPort extends TileEntityInductionCasing implement
|| capability == Capabilities.CONFIGURABLE_CAPABILITY
|| (capability == Capabilities.TESLA_CONSUMER_CAPABILITY && getConsumingSides().contains(facing))
|| (capability == Capabilities.TESLA_PRODUCER_CAPABILITY && getOutputtingSides().contains(facing))
|| capability == CapabilityEnergy.ENERGY
|| super.hasCapability(capability, facing);
}
private CapabilityWrapperManager teslaManager = new CapabilityWrapperManager(TileEntityElectricBlock.class, TeslaIntegration.class);
private CapabilityWrapperManager forgeEnergyManager = new CapabilityWrapperManager(TileEntityElectricBlock.class, ForgeEnergyIntegration.class);
@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing)
@@ -529,6 +533,11 @@ public class TileEntityInductionPort extends TileEntityInductionCasing implement
return (T)teslaManager.getWrapper(this, facing);
}
if(capability == CapabilityEnergy.ENERGY)
{
return (T)forgeEnergyManager.getWrapper(this, facing);
}
return super.getCapability(capability, facing);
}
}
@@ -22,24 +22,21 @@ import mekanism.common.Tier.CableTier;
import mekanism.common.base.EnergyAcceptorWrapper;
import mekanism.common.block.states.BlockStateTransmitter.TransmitterType;
import mekanism.common.capabilities.Capabilities;
import mekanism.common.capabilities.CapabilityWrapperManager;
import mekanism.common.integration.forgeenergy.ForgeEnergyCableIntegration;
import mekanism.common.integration.tesla.TeslaCableIntegration;
import mekanism.common.util.CableUtils;
import mekanism.common.util.MekanismUtils;
import net.darkhax.tesla.api.ITeslaConsumer;
import net.darkhax.tesla.api.ITeslaProducer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.fml.common.Optional.Interface;
import net.minecraftforge.fml.common.Optional.InterfaceList;
import net.minecraftforge.fml.common.Optional.Method;
import net.minecraftforge.energy.CapabilityEnergy;
import cofh.api.energy.IEnergyProvider;
import cofh.api.energy.IEnergyReceiver;
@InterfaceList({
@Interface(iface = "net.darkhax.tesla.api.ITeslaConsumer", modid = "tesla")
})
public class TileEntityUniversalCable extends TileEntityTransmitter<EnergyAcceptorWrapper, EnergyNetwork> implements IStrictEnergyAcceptor, IEnergyReceiver, IEnergyProvider, ITeslaConsumer
public class TileEntityUniversalCable extends TileEntityTransmitter<EnergyAcceptorWrapper, EnergyNetwork> implements IStrictEnergyAcceptor, IEnergyReceiver
{
public Tier.CableTier tier = CableTier.BASIC;
@@ -251,12 +248,6 @@ public class TileEntityUniversalCable extends TileEntityTransmitter<EnergyAccept
return maxReceive - (int)Math.round(takeEnergy(maxReceive*general.FROM_RF, !simulate)*general.TO_RF);
}
@Override
public int extractEnergy(EnumFacing from, int maxExtract, boolean simulate)
{
return 0;
}
@Override
public boolean canConnectEnergy(EnumFacing from)
{
@@ -336,13 +327,6 @@ public class TileEntityUniversalCable extends TileEntityTransmitter<EnergyAccept
buffer.amount = energy;
}
}
@Override
@Method(modid = "tesla")
public long givePower(long power, boolean simulated)
{
return power - (long)Math.round(takeEnergy(power*general.FROM_TESLA, !simulated)*general.TO_TESLA);
}
public double takeEnergy(double energy, boolean doEmit)
{
@@ -401,25 +385,38 @@ public class TileEntityUniversalCable extends TileEntityTransmitter<EnergyAccept
return data;
}
@Override
public boolean hasCapability(Capability<?> capability, EnumFacing facing)
{
return capability == Capabilities.ENERGY_STORAGE_CAPABILITY
|| capability == Capabilities.ENERGY_ACCEPTOR_CAPABILITY
|| capability == Capabilities.TESLA_CONSUMER_CAPABILITY
|| capability == CapabilityEnergy.ENERGY
|| super.hasCapability(capability, facing);
}
private CapabilityWrapperManager teslaManager = new CapabilityWrapperManager(getClass(), TeslaCableIntegration.class);
private CapabilityWrapperManager forgeEnergyManager = new CapabilityWrapperManager(getClass(), ForgeEnergyCableIntegration.class);
@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing)
{
if(capability == Capabilities.ENERGY_STORAGE_CAPABILITY || capability == Capabilities.ENERGY_ACCEPTOR_CAPABILITY ||
capability == Capabilities.TESLA_CONSUMER_CAPABILITY)
if(capability == Capabilities.ENERGY_STORAGE_CAPABILITY || capability == Capabilities.ENERGY_ACCEPTOR_CAPABILITY)
{
return (T)this;
}
if(capability == Capabilities.TESLA_CONSUMER_CAPABILITY)
{
return (T)teslaManager.getWrapper(this, facing);
}
if(capability == CapabilityEnergy.ENERGY)
{
return (T)forgeEnergyManager.getWrapper(this, facing);
}
return super.getCapability(capability, facing);
}
}
@@ -12,12 +12,14 @@ import mekanism.api.transmitters.TransmissionType;
import mekanism.api.util.CapabilityUtils;
import mekanism.common.base.IEnergyWrapper;
import mekanism.common.capabilities.Capabilities;
import mekanism.common.integration.IC2Integration;
import mekanism.common.integration.ic2.IC2Integration;
import net.darkhax.tesla.api.ITeslaConsumer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraftforge.energy.CapabilityEnergy;
import net.minecraftforge.energy.IEnergyStorage;
import cofh.api.energy.IEnergyConnection;
import cofh.api.energy.IEnergyProvider;
import cofh.api.energy.IEnergyReceiver;
@@ -122,6 +124,11 @@ public final class CableUtils
return true;
}
if(MekanismUtils.useForge() && CapabilityUtils.hasCapability(tileEntity, CapabilityEnergy.ENERGY, side.getOpposite()))
{
return CapabilityUtils.getCapability(tileEntity, CapabilityEnergy.ENERGY, side.getOpposite()).canExtract();
}
if(MekanismUtils.useRF() && tileEntity instanceof IEnergyProvider && ((IEnergyConnection)tileEntity).canConnectEnergy(side.getOpposite()))
{
return true;
@@ -149,10 +156,14 @@ public final class CableUtils
return true;
}
}
else if(CapabilityUtils.hasCapability(tileEntity, Capabilities.TESLA_CONSUMER_CAPABILITY, side.getOpposite()))
else if(MekanismUtils.useTesla() && CapabilityUtils.hasCapability(tileEntity, Capabilities.TESLA_CONSUMER_CAPABILITY, side.getOpposite()))
{
return true;
}
else if(MekanismUtils.useForge() && CapabilityUtils.hasCapability(tileEntity, CapabilityEnergy.ENERGY, side.getOpposite()))
{
return CapabilityUtils.getCapability(tileEntity, CapabilityEnergy.ENERGY, side.getOpposite()).canReceive();
}
else if(MekanismUtils.useIC2() && IC2Integration.isAcceptor(orig, tileEntity, side))
{
return true;
@@ -252,11 +263,16 @@ public final class CableUtils
sent += acceptor.transferEnergyToAcceptor(side.getOpposite(), currentSending);
}
}
else if(CapabilityUtils.hasCapability(tileEntity, Capabilities.TESLA_CONSUMER_CAPABILITY, side.getOpposite()))
else if(MekanismUtils.useTesla() && CapabilityUtils.hasCapability(tileEntity, Capabilities.TESLA_CONSUMER_CAPABILITY, side.getOpposite()))
{
ITeslaConsumer consumer = CapabilityUtils.getCapability(tileEntity, Capabilities.TESLA_CONSUMER_CAPABILITY, side.getOpposite());
sent += consumer.givePower((long)Math.round(currentSending*general.TO_TESLA), false)*general.FROM_TESLA;
}
else if(MekanismUtils.useForge() && CapabilityUtils.hasCapability(tileEntity, CapabilityEnergy.ENERGY, side.getOpposite()))
{
IEnergyStorage storage = CapabilityUtils.getCapability(tileEntity, CapabilityEnergy.ENERGY, side.getOpposite());
sent += storage.receiveEnergy((int)Math.round(Math.min(Integer.MAX_VALUE, currentSending*general.TO_FORGE)), false)*general.FROM_FORGE;
}
else if(MekanismUtils.useRF() && tileEntity instanceof IEnergyReceiver)
{
IEnergyReceiver handler = (IEnergyReceiver)tileEntity;
@@ -8,10 +8,15 @@ import mekanism.api.MekanismConfig.general;
import mekanism.api.energy.EnergizedItemManager;
import mekanism.api.energy.IEnergizedItem;
import mekanism.api.energy.IStrictEnergyStorage;
import mekanism.common.capabilities.Capabilities;
import mekanism.common.tile.TileEntityContainerBlock;
import net.darkhax.tesla.api.ITeslaConsumer;
import net.darkhax.tesla.api.ITeslaProducer;
import net.minecraft.init.Items;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraftforge.energy.CapabilityEnergy;
import net.minecraftforge.energy.IEnergyStorage;
import cofh.api.energy.IEnergyContainerItem;
public final class ChargeUtils
@@ -24,42 +29,52 @@ public final class ChargeUtils
public static void discharge(int slotID, IStrictEnergyStorage storer)
{
IInventory inv = (TileEntityContainerBlock)storer;
ItemStack stack = inv.getStackInSlot(slotID);
if(!inv.getStackInSlot(slotID).isEmpty() && storer.getEnergy() < storer.getMaxEnergy())
if(!stack.isEmpty() && storer.getEnergy() < storer.getMaxEnergy())
{
if(inv.getStackInSlot(slotID).getItem() instanceof IEnergizedItem)
if(stack.getItem() instanceof IEnergizedItem)
{
storer.setEnergy(storer.getEnergy() + EnergizedItemManager.discharge(inv.getStackInSlot(slotID), storer.getMaxEnergy() - storer.getEnergy()));
storer.setEnergy(storer.getEnergy() + EnergizedItemManager.discharge(stack, storer.getMaxEnergy() - storer.getEnergy()));
}
else if(MekanismUtils.useIC2() && inv.getStackInSlot(slotID).getItem() instanceof IElectricItem)
else if(MekanismUtils.useTesla() && stack.hasCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null))
{
IElectricItem item = (IElectricItem)inv.getStackInSlot(slotID).getItem();
if(item.canProvideEnergy(inv.getStackInSlot(slotID)))
ITeslaProducer producer = stack.getCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null);
long needed = (long)Math.round((storer.getMaxEnergy()-storer.getEnergy())*general.TO_TESLA);
storer.setEnergy(storer.getEnergy() + producer.takePower(needed, false)*general.FROM_TESLA);
}
else if(MekanismUtils.useForge() && stack.hasCapability(CapabilityEnergy.ENERGY, null))
{
IEnergyStorage storage = stack.getCapability(CapabilityEnergy.ENERGY, null);
if(storage.canExtract())
{
double gain = ElectricItem.manager.discharge(inv.getStackInSlot(slotID), (int)((storer.getMaxEnergy() - storer.getEnergy())* general.TO_IC2), 4, true, true, false)* general.FROM_IC2;
int needed = (int)Math.round(Math.min(Integer.MAX_VALUE, (storer.getMaxEnergy()-storer.getEnergy())*general.TO_FORGE));
storer.setEnergy(storer.getEnergy() + storage.extractEnergy(needed, false)*general.FROM_FORGE);
}
}
else if(MekanismUtils.useRF() && stack.getItem() instanceof IEnergyContainerItem)
{
IEnergyContainerItem item = (IEnergyContainerItem)stack.getItem();
int needed = (int)Math.round(Math.min(Integer.MAX_VALUE, (storer.getMaxEnergy() - storer.getEnergy())*general.TO_RF));
storer.setEnergy(storer.getEnergy() + (item.extractEnergy(stack, needed, false)*general.FROM_RF));
}
else if(MekanismUtils.useIC2() && stack.getItem() instanceof IElectricItem)
{
IElectricItem item = (IElectricItem)stack.getItem();
if(item.canProvideEnergy(stack))
{
double gain = ElectricItem.manager.discharge(stack, (storer.getMaxEnergy() - storer.getEnergy())*general.TO_IC2, 4, true, true, false)*general.FROM_IC2;
storer.setEnergy(storer.getEnergy() + gain);
}
}
else if(MekanismUtils.useRF() && inv.getStackInSlot(slotID).getItem() instanceof IEnergyContainerItem)
{
ItemStack itemStack = inv.getStackInSlot(slotID);
IEnergyContainerItem item = (IEnergyContainerItem)inv.getStackInSlot(slotID).getItem();
int itemEnergy = (int)Math.round(Math.min(Math.sqrt(item.getMaxEnergyStored(itemStack)), item.getEnergyStored(itemStack)));
int toTransfer = (int)Math.round(Math.min(itemEnergy, ((storer.getMaxEnergy() - storer.getEnergy())* general.TO_RF)));
storer.setEnergy(storer.getEnergy() + (item.extractEnergy(itemStack, toTransfer, false)* general.FROM_RF));
}
else if(inv.getStackInSlot(slotID).getItem() == Items.REDSTONE && storer.getEnergy()+general.ENERGY_PER_REDSTONE <= storer.getMaxEnergy())
else if(stack.getItem() == Items.REDSTONE && storer.getEnergy()+general.ENERGY_PER_REDSTONE <= storer.getMaxEnergy())
{
storer.setEnergy(storer.getEnergy() + general.ENERGY_PER_REDSTONE);
inv.getStackInSlot(slotID).shrink(1);
if(inv.getStackInSlot(slotID).getCount() <= 0)
{
inv.setInventorySlotContents(slotID, null);
}
stack.shrink(1);
}
}
}
@@ -72,28 +87,43 @@ public final class ChargeUtils
public static void charge(int slotID, IStrictEnergyStorage storer)
{
IInventory inv = (TileEntityContainerBlock)storer;
ItemStack stack = inv.getStackInSlot(slotID);
if(!inv.getStackInSlot(slotID).isEmpty() && storer.getEnergy() > 0)
if(!stack.isEmpty() && storer.getEnergy() > 0)
{
if(inv.getStackInSlot(slotID).getItem() instanceof IEnergizedItem)
if(stack.getItem() instanceof IEnergizedItem)
{
storer.setEnergy(storer.getEnergy() - EnergizedItemManager.charge(inv.getStackInSlot(slotID), storer.getEnergy()));
storer.setEnergy(storer.getEnergy() - EnergizedItemManager.charge(stack, storer.getEnergy()));
}
else if(MekanismUtils.useIC2() && inv.getStackInSlot(slotID).getItem() instanceof IElectricItem)
else if(MekanismUtils.useTesla() && stack.hasCapability(Capabilities.TESLA_CONSUMER_CAPABILITY, null))
{
double sent = ElectricItem.manager.charge(inv.getStackInSlot(slotID), (int)(storer.getEnergy()* general.TO_IC2), 4, true, false)* general.FROM_IC2;
ITeslaConsumer consumer = stack.getCapability(Capabilities.TESLA_CONSUMER_CAPABILITY, null);
long stored = (long)Math.round(storer.getEnergy()*general.TO_TESLA);
storer.setEnergy(storer.getEnergy() - consumer.givePower(stored, false)*general.FROM_TESLA);
}
else if(MekanismUtils.useForge() && stack.hasCapability(CapabilityEnergy.ENERGY, null))
{
IEnergyStorage storage = stack.getCapability(CapabilityEnergy.ENERGY, null);
if(storage.canReceive())
{
int stored = (int)Math.round(Math.min(Integer.MAX_VALUE, storer.getEnergy()*general.TO_FORGE));
storer.setEnergy(storer.getEnergy() - storage.receiveEnergy(stored, false)*general.FROM_FORGE);
}
}
else if(MekanismUtils.useRF() && stack.getItem() instanceof IEnergyContainerItem)
{
IEnergyContainerItem item = (IEnergyContainerItem)stack.getItem();
int toTransfer = (int)Math.round(storer.getEnergy()*general.TO_RF);
storer.setEnergy(storer.getEnergy() - (item.receiveEnergy(stack, toTransfer, false)*general.FROM_RF));
}
else if(MekanismUtils.useIC2() && stack.getItem() instanceof IElectricItem)
{
double sent = ElectricItem.manager.charge(stack, storer.getEnergy()*general.TO_IC2, 4, true, false)*general.FROM_IC2;
storer.setEnergy(storer.getEnergy() - sent);
}
else if(MekanismUtils.useRF() && inv.getStackInSlot(slotID).getItem() instanceof IEnergyContainerItem)
{
ItemStack itemStack = inv.getStackInSlot(slotID);
IEnergyContainerItem item = (IEnergyContainerItem)inv.getStackInSlot(slotID).getItem();
int itemEnergy = (int)Math.round(Math.min(Math.sqrt(item.getMaxEnergyStored(itemStack)), item.getMaxEnergyStored(itemStack) - item.getEnergyStored(itemStack)));
int toTransfer = (int)Math.round(Math.min(itemEnergy, (storer.getEnergy()* general.TO_RF)));
storer.setEnergy(storer.getEnergy() - (item.receiveEnergy(itemStack, toTransfer, false)* general.FROM_RF));
}
}
}
@@ -107,6 +137,8 @@ public final class ChargeUtils
return (MekanismUtils.useIC2() && itemstack.getItem() instanceof IElectricItem && ((IElectricItem)itemstack.getItem()).canProvideEnergy(itemstack)) ||
(itemstack.getItem() instanceof IEnergizedItem && ((IEnergizedItem)itemstack.getItem()).canSend(itemstack)) ||
(MekanismUtils.useRF() && itemstack.getItem() instanceof IEnergyContainerItem && ((IEnergyContainerItem)itemstack.getItem()).extractEnergy(itemstack, 1, true) != 0) ||
(MekanismUtils.useTesla() && itemstack.hasCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null) && itemstack.getCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null).takePower(1, true) > 0) ||
(MekanismUtils.useForge() && itemstack.hasCapability(CapabilityEnergy.ENERGY, null) && itemstack.getCapability(CapabilityEnergy.ENERGY, null).canExtract()) ||
itemstack.getItem() == Items.REDSTONE;
}
@@ -119,7 +151,9 @@ public final class ChargeUtils
{
return (MekanismUtils.useIC2() && itemstack.getItem() instanceof IElectricItem) ||
(itemstack.getItem() instanceof IEnergizedItem && ((IEnergizedItem)itemstack.getItem()).canReceive(itemstack)) ||
(MekanismUtils.useRF() && itemstack.getItem() instanceof IEnergyContainerItem && ((IEnergyContainerItem)itemstack.getItem()).receiveEnergy(itemstack, 1, true) != 0);
(MekanismUtils.useRF() && itemstack.getItem() instanceof IEnergyContainerItem && ((IEnergyContainerItem)itemstack.getItem()).receiveEnergy(itemstack, 1, true) != 0) ||
(MekanismUtils.useTesla() && itemstack.hasCapability(Capabilities.TESLA_CONSUMER_CAPABILITY, null) && itemstack.getCapability(Capabilities.TESLA_CONSUMER_CAPABILITY, null).givePower(1, true) > 0) ||
(MekanismUtils.useForge() && itemstack.hasCapability(CapabilityEnergy.ENERGY, null) && itemstack.getCapability(CapabilityEnergy.ENERGY, null).canReceive());
}
/**
@@ -143,16 +177,41 @@ public final class ChargeUtils
return energized.getEnergy(itemstack) == 0;
}
}
else if(itemstack.getItem() instanceof IEnergyContainerItem)
else if(MekanismUtils.useRF() && itemstack.getItem() instanceof IEnergyContainerItem)
{
IEnergyContainerItem energyContainer = (IEnergyContainerItem)itemstack.getItem();
if(chargeSlot)
{
return energyContainer.receiveEnergy(itemstack, 1, true) > 0;
return energyContainer.receiveEnergy(itemstack, 1, true) == 0;
}
else {
return energyContainer.extractEnergy(itemstack, 1, true) > 0;
return energyContainer.extractEnergy(itemstack, 1, true) == 0;
}
}
else if(MekanismUtils.useTesla())
{
if(chargeSlot && itemstack.hasCapability(Capabilities.TESLA_CONSUMER_CAPABILITY, null))
{
ITeslaConsumer consumer = itemstack.getCapability(Capabilities.TESLA_CONSUMER_CAPABILITY, null);
return consumer.givePower(1, true) == 0;
}
else if(!chargeSlot && itemstack.hasCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null))
{
ITeslaProducer producer = itemstack.getCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null);
return producer.takePower(1, true) == 0;
}
}
else if(MekanismUtils.useForge() && itemstack.hasCapability(CapabilityEnergy.ENERGY, null))
{
IEnergyStorage storage = itemstack.getCapability(CapabilityEnergy.ENERGY, null);
if(chargeSlot)
{
return !storage.canReceive() || storage.receiveEnergy(1, true) == 0;
}
else {
return !storage.canExtract() || storage.extractEnergy(1, true) == 0;
}
}
else if(MekanismUtils.useIC2() && itemstack.getItem() instanceof ISpecialElectricItem)
@@ -163,10 +222,10 @@ public final class ChargeUtils
{
if(chargeSlot)
{
return manager.charge(itemstack, 1, 3, true, true) > 0;
return manager.charge(itemstack, 1, 3, true, true) == 0;
}
else {
return manager.discharge(itemstack, 1, 3, true, true, true) > 0;
return manager.discharge(itemstack, 1, 3, true, true, true) == 0;
}
}
}
@@ -1190,6 +1190,15 @@ public final class MekanismUtils
{
return Mekanism.hooks.TeslaLoaded && !general.blacklistTesla;
}
/**
* Whether or not Forge power should be used.
* @return if Forge power should be used
*/
public static boolean useForge()
{
return !general.blacklistForge;
}
/**
* Gets a clean view of a coordinate value without the dimension ID.
@@ -13,7 +13,10 @@ import mekanism.client.MekanismKeyHandler;
import mekanism.common.base.ISustainedData;
import mekanism.common.base.ISustainedInventory;
import mekanism.common.base.ISustainedTank;
import mekanism.common.integration.IC2ItemManager;
import mekanism.common.capabilities.ItemCapabilityWrapper;
import mekanism.common.integration.forgeenergy.ForgeEnergyItemWrapper;
import mekanism.common.integration.ic2.IC2ItemManager;
import mekanism.common.integration.tesla.TeslaItemWrapper;
import mekanism.common.security.ISecurityItem;
import mekanism.common.security.ISecurityTile;
import mekanism.common.security.ISecurityTile.SecurityMode;
@@ -35,6 +38,7 @@ import net.minecraft.nbt.NBTTagList;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraftforge.common.capabilities.ICapabilityProvider;
import net.minecraftforge.fluids.FluidRegistry;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fml.common.Optional.Interface;
@@ -464,4 +468,10 @@ public class ItemBlockGenerator extends ItemBlock implements IEnergizedItem, ISp
{
return hasSecurity(stack);
}
@Override
public ICapabilityProvider initCapabilities(ItemStack stack, NBTTagCompound nbt)
{
return new ItemCapabilityWrapper(stack, new TeslaItemWrapper(), new ForgeEnergyItemWrapper());
}
}
@@ -17,7 +17,8 @@ import mekanism.common.base.IEnergyWrapper;
import mekanism.common.base.IFluidHandlerWrapper;
import mekanism.common.capabilities.Capabilities;
import mekanism.common.capabilities.CapabilityWrapperManager;
import mekanism.common.integration.TeslaIntegration;
import mekanism.common.integration.forgeenergy.ForgeEnergyIntegration;
import mekanism.common.integration.tesla.TeslaIntegration;
import mekanism.common.tile.TileEntityGasTank.GasMode;
import mekanism.common.util.CableUtils;
import mekanism.common.util.LangUtils;
@@ -27,6 +28,7 @@ import mekanism.generators.common.content.turbine.TurbineFluidTank;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.energy.CapabilityEnergy;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidRegistry;
import net.minecraftforge.fluids.FluidStack;
@@ -424,7 +426,8 @@ public class TileEntityTurbineValve extends TileEntityTurbineCasing implements I
|| capability == Capabilities.ENERGY_STORAGE_CAPABILITY
|| capability == Capabilities.CABLE_OUTPUTTER_CAPABILITY
|| capability == Capabilities.TESLA_HOLDER_CAPABILITY
|| (capability == Capabilities.TESLA_PRODUCER_CAPABILITY && getOutputtingSides().contains(facing)))
|| (capability == Capabilities.TESLA_PRODUCER_CAPABILITY && getOutputtingSides().contains(facing))
|| capability == CapabilityEnergy.ENERGY)
{
return true;
}
@@ -434,6 +437,7 @@ public class TileEntityTurbineValve extends TileEntityTurbineCasing implements I
}
private CapabilityWrapperManager teslaManager = new CapabilityWrapperManager(IEnergyWrapper.class, TeslaIntegration.class);
private CapabilityWrapperManager forgeEnergyManager = new CapabilityWrapperManager(IEnergyWrapper.class, ForgeEnergyIntegration.class);
@Override
public <T> T getCapability(Capability<T> capability, EnumFacing side)
@@ -455,6 +459,11 @@ public class TileEntityTurbineValve extends TileEntityTurbineCasing implements I
{
return (T)teslaManager.getWrapper(this, facing);
}
if(capability == CapabilityEnergy.ENERGY)
{
return (T)forgeEnergyManager.getWrapper(this, facing);
}
}
return super.getCapability(capability, side);