diff --git a/src/main/java/mekanism/api/MekanismConfig.java b/src/main/java/mekanism/api/MekanismConfig.java index a3c5b0c01..e44d62940 100644 --- a/src/main/java/mekanism/api/MekanismConfig.java +++ b/src/main/java/mekanism/api/MekanismConfig.java @@ -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; diff --git a/src/main/java/mekanism/common/CommonProxy.java b/src/main/java/mekanism/common/CommonProxy.java index b96e00efd..c441f3815 100644 --- a/src/main/java/mekanism/common/CommonProxy.java +++ b/src/main/java/mekanism/common/CommonProxy.java @@ -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(); diff --git a/src/main/java/mekanism/common/Mekanism.java b/src/main/java/mekanism/common/Mekanism.java index 3fd813a98..bf43c7541 100644 --- a/src/main/java/mekanism/common/Mekanism.java +++ b/src/main/java/mekanism/common/Mekanism.java @@ -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 */ diff --git a/src/main/java/mekanism/common/base/EnergyAcceptorWrapper.java b/src/main/java/mekanism/common/base/EnergyAcceptorWrapper.java index 3842678f3..8ce84dbbb 100644 --- a/src/main/java/mekanism/common/base/EnergyAcceptorWrapper.java +++ b/src/main/java/mekanism/common/base/EnergyAcceptorWrapper.java @@ -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; + } + } } \ No newline at end of file diff --git a/src/main/java/mekanism/common/entity/EntityRobit.java b/src/main/java/mekanism/common/entity/EntityRobit.java index 3231a071e..35ed3fd1f 100644 --- a/src/main/java/mekanism/common/entity/EntityRobit.java +++ b/src/main/java/mekanism/common/entity/EntityRobit.java @@ -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); } } diff --git a/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyCableIntegration.java b/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyCableIntegration.java new file mode 100644 index 000000000..c2f489e68 --- /dev/null +++ b/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyCableIntegration.java @@ -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); + } +} diff --git a/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyIntegration.java b/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyIntegration.java new file mode 100644 index 000000000..29c46cec3 --- /dev/null +++ b/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyIntegration.java @@ -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); + } +} diff --git a/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyItemWrapper.java b/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyItemWrapper.java new file mode 100644 index 000000000..6b822d0fb --- /dev/null +++ b/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyItemWrapper.java @@ -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()); + } +} diff --git a/src/main/java/mekanism/common/integration/IC2Integration.java b/src/main/java/mekanism/common/integration/ic2/IC2Integration.java similarity index 97% rename from src/main/java/mekanism/common/integration/IC2Integration.java rename to src/main/java/mekanism/common/integration/ic2/IC2Integration.java index 2ae2731cc..dad6560ff 100644 --- a/src/main/java/mekanism/common/integration/IC2Integration.java +++ b/src/main/java/mekanism/common/integration/ic2/IC2Integration.java @@ -1,4 +1,4 @@ -package mekanism.common.integration; +package mekanism.common.integration.ic2; import ic2.api.energy.EnergyNet; import ic2.api.energy.tile.IEnergySink; diff --git a/src/main/java/mekanism/common/integration/IC2ItemManager.java b/src/main/java/mekanism/common/integration/ic2/IC2ItemManager.java similarity index 98% rename from src/main/java/mekanism/common/integration/IC2ItemManager.java rename to src/main/java/mekanism/common/integration/ic2/IC2ItemManager.java index 3dd1e921b..88f85e140 100644 --- a/src/main/java/mekanism/common/integration/IC2ItemManager.java +++ b/src/main/java/mekanism/common/integration/ic2/IC2ItemManager.java @@ -1,4 +1,4 @@ -package mekanism.common.integration; +package mekanism.common.integration.ic2; import ic2.api.item.IElectricItemManager; import mekanism.api.MekanismConfig.general; diff --git a/src/main/java/mekanism/common/integration/tesla/TeslaCableIntegration.java b/src/main/java/mekanism/common/integration/tesla/TeslaCableIntegration.java new file mode 100644 index 000000000..9e3fe61d6 --- /dev/null +++ b/src/main/java/mekanism/common/integration/tesla/TeslaCableIntegration.java @@ -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)); + } +} diff --git a/src/main/java/mekanism/common/integration/TeslaIntegration.java b/src/main/java/mekanism/common/integration/tesla/TeslaIntegration.java similarity index 76% rename from src/main/java/mekanism/common/integration/TeslaIntegration.java rename to src/main/java/mekanism/common/integration/tesla/TeslaIntegration.java index 81b730f58..6a9f5cd07 100644 --- a/src/main/java/mekanism/common/integration/TeslaIntegration.java +++ b/src/main/java/mekanism/common/integration/tesla/TeslaIntegration.java @@ -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)); } } diff --git a/src/main/java/mekanism/common/integration/TeslaItemWrapper.java b/src/main/java/mekanism/common/integration/tesla/TeslaItemWrapper.java similarity index 98% rename from src/main/java/mekanism/common/integration/TeslaItemWrapper.java rename to src/main/java/mekanism/common/integration/tesla/TeslaItemWrapper.java index 33fa8232f..3ff3e4385 100644 --- a/src/main/java/mekanism/common/integration/TeslaItemWrapper.java +++ b/src/main/java/mekanism/common/integration/tesla/TeslaItemWrapper.java @@ -1,4 +1,4 @@ -package mekanism.common.integration; +package mekanism.common.integration.tesla; import mekanism.api.MekanismConfig.general; import mekanism.api.energy.IEnergizedItem; diff --git a/src/main/java/mekanism/common/item/ItemBlockEnergyCube.java b/src/main/java/mekanism/common/item/ItemBlockEnergyCube.java index 6b68605d4..1d385b0c2 100644 --- a/src/main/java/mekanism/common/item/ItemBlockEnergyCube.java +++ b/src/main/java/mekanism/common/item/ItemBlockEnergyCube.java @@ -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()); } } diff --git a/src/main/java/mekanism/common/item/ItemBlockMachine.java b/src/main/java/mekanism/common/item/ItemBlockMachine.java index bc8f249a7..9b09f1b4d 100644 --- a/src/main/java/mekanism/common/item/ItemBlockMachine.java +++ b/src/main/java/mekanism/common/item/ItemBlockMachine.java @@ -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) { diff --git a/src/main/java/mekanism/common/item/ItemEnergized.java b/src/main/java/mekanism/common/item/ItemEnergized.java index e384f697a..f24f638e1 100644 --- a/src/main/java/mekanism/common/item/ItemEnergized.java +++ b/src/main/java/mekanism/common/item/ItemEnergized.java @@ -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()); } } diff --git a/src/main/java/mekanism/common/item/ItemFreeRunners.java b/src/main/java/mekanism/common/item/ItemFreeRunners.java index 0add4b69e..f56608e8a 100644 --- a/src/main/java/mekanism/common/item/ItemFreeRunners.java +++ b/src/main/java/mekanism/common/item/ItemFreeRunners.java @@ -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()); } } diff --git a/src/main/java/mekanism/common/network/PacketConfigSync.java b/src/main/java/mekanism/common/network/PacketConfigSync.java index 5074a2846..fca2a9ddb 100644 --- a/src/main/java/mekanism/common/network/PacketConfigSync.java +++ b/src/main/java/mekanism/common/network/PacketConfigSync.java @@ -45,6 +45,8 @@ public class PacketConfigSync implements IMessageHandler T getCapability(Capability 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); } } diff --git a/src/main/java/mekanism/common/tile/TileEntityInductionPort.java b/src/main/java/mekanism/common/tile/TileEntityInductionPort.java index 5049d17f3..dbb90b482 100644 --- a/src/main/java/mekanism/common/tile/TileEntityInductionPort.java +++ b/src/main/java/mekanism/common/tile/TileEntityInductionPort.java @@ -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 getCapability(Capability 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); } } \ No newline at end of file diff --git a/src/main/java/mekanism/common/tile/transmitter/TileEntityUniversalCable.java b/src/main/java/mekanism/common/tile/transmitter/TileEntityUniversalCable.java index 80515b20d..143323714 100644 --- a/src/main/java/mekanism/common/tile/transmitter/TileEntityUniversalCable.java +++ b/src/main/java/mekanism/common/tile/transmitter/TileEntityUniversalCable.java @@ -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 implements IStrictEnergyAcceptor, IEnergyReceiver, IEnergyProvider, ITeslaConsumer +public class TileEntityUniversalCable extends TileEntityTransmitter implements IStrictEnergyAcceptor, IEnergyReceiver { public Tier.CableTier tier = CableTier.BASIC; @@ -251,12 +248,6 @@ public class TileEntityUniversalCable extends TileEntityTransmitter 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 getCapability(Capability 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); } } diff --git a/src/main/java/mekanism/common/util/CableUtils.java b/src/main/java/mekanism/common/util/CableUtils.java index 804417a76..6ac883947 100644 --- a/src/main/java/mekanism/common/util/CableUtils.java +++ b/src/main/java/mekanism/common/util/CableUtils.java @@ -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; diff --git a/src/main/java/mekanism/common/util/ChargeUtils.java b/src/main/java/mekanism/common/util/ChargeUtils.java index 84bf064c3..4a1bf4852 100644 --- a/src/main/java/mekanism/common/util/ChargeUtils.java +++ b/src/main/java/mekanism/common/util/ChargeUtils.java @@ -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; } } } diff --git a/src/main/java/mekanism/common/util/MekanismUtils.java b/src/main/java/mekanism/common/util/MekanismUtils.java index 147e068be..b0b92abb0 100644 --- a/src/main/java/mekanism/common/util/MekanismUtils.java +++ b/src/main/java/mekanism/common/util/MekanismUtils.java @@ -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. diff --git a/src/main/java/mekanism/generators/common/item/ItemBlockGenerator.java b/src/main/java/mekanism/generators/common/item/ItemBlockGenerator.java index 08056c7f0..a48d84619 100644 --- a/src/main/java/mekanism/generators/common/item/ItemBlockGenerator.java +++ b/src/main/java/mekanism/generators/common/item/ItemBlockGenerator.java @@ -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()); + } } diff --git a/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineValve.java b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineValve.java index 7f34255e8..89a94c93f 100644 --- a/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineValve.java +++ b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineValve.java @@ -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 getCapability(Capability 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);