diff --git a/etc/core/mcmod.info b/etc/core/mcmod.info index 0a0159e4165..c1cd2a3f586 100755 --- a/etc/core/mcmod.info +++ b/etc/core/mcmod.info @@ -19,8 +19,7 @@ "redstoneflux", "mcmultipart", "jei", - "buildcraft", - "buildcraftapi", + "buildcraftcore", "ic2", "computercraft", "galaticraft api", diff --git a/src/main/java/mekanism/common/base/EnergyAcceptorWrapper.java b/src/main/java/mekanism/common/base/EnergyAcceptorWrapper.java index 4d803f2b528..59cca3b0c8d 100644 --- a/src/main/java/mekanism/common/base/EnergyAcceptorWrapper.java +++ b/src/main/java/mekanism/common/base/EnergyAcceptorWrapper.java @@ -9,6 +9,8 @@ import mekanism.api.energy.IStrictEnergyAcceptor; import mekanism.common.capabilities.Capabilities; import mekanism.common.config.MekanismConfig; +import mekanism.common.integration.forgeenergy.ForgeEnergyIntegration; +import mekanism.common.integration.tesla.TeslaIntegration; import mekanism.common.util.CapabilityUtils; import mekanism.common.util.MekanismUtils; import net.darkhax.tesla.api.ITeslaConsumer; @@ -32,12 +34,12 @@ public static EnergyAcceptorWrapper get(TileEntity tileEntity, EnumFacing side) EnergyAcceptorWrapper wrapper = null; if (CapabilityUtils.hasCapability(tileEntity, Capabilities.ENERGY_ACCEPTOR_CAPABILITY, side)) { wrapper = fromCapability(tileEntity, Capabilities.ENERGY_ACCEPTOR_CAPABILITY, side, MekanismAcceptor::new); + } else if (MekanismUtils.useTesla() && CapabilityUtils.hasCapability(tileEntity, Capabilities.TESLA_CONSUMER_CAPABILITY, side)) { + wrapper = fromCapability(tileEntity, Capabilities.TESLA_CONSUMER_CAPABILITY, side, TeslaAcceptor::new); } else if (MekanismUtils.useForge() && CapabilityUtils.hasCapability(tileEntity, CapabilityEnergy.ENERGY, side)) { wrapper = fromCapability(tileEntity, CapabilityEnergy.ENERGY, side, ForgeAcceptor::new); } else if (MekanismUtils.useRF() && tileEntity instanceof IEnergyReceiver) { wrapper = new RFAcceptor((IEnergyReceiver) tileEntity); - } else if (MekanismUtils.useTesla() && CapabilityUtils.hasCapability(tileEntity, Capabilities.TESLA_CONSUMER_CAPABILITY, side)) { - wrapper = fromCapability(tileEntity, Capabilities.TESLA_CONSUMER_CAPABILITY, side, TeslaAcceptor::new); } else if (MekanismUtils.useIC2()) { IEnergyTile tile = EnergyNet.instance.getSubTile(tileEntity.getWorld(), tileEntity.getPos()); if (tile instanceof IEnergySink) { @@ -53,8 +55,7 @@ public static EnergyAcceptorWrapper get(TileEntity tileEntity, EnumFacing side) /** * Note: It is assumed that a check for hasCapability was already ran. */ - private static EnergyAcceptorWrapper fromCapability(TileEntity tileEntity, Capability capability, - EnumFacing side, Function makeAcceptor) { + private static EnergyAcceptorWrapper fromCapability(TileEntity tileEntity, Capability capability, EnumFacing side, Function makeAcceptor) { T acceptor = CapabilityUtils.getCapability(tileEntity, capability, side); if (acceptor != null) { return makeAcceptor.apply(acceptor); @@ -170,7 +171,7 @@ public TeslaAcceptor(ITeslaConsumer teslaConsumer) { @Override public double acceptEnergy(EnumFacing side, double amount, boolean simulate) { - return fromTesla(acceptor.givePower(toTesla(amount), simulate)); + return TeslaIntegration.fromTesla(acceptor.givePower(TeslaIntegration.toTesla(amount), simulate)); } @Override @@ -182,14 +183,6 @@ public boolean canReceiveEnergy(EnumFacing side) { public boolean needsEnergy(EnumFacing side) { return canReceiveEnergy(side); } - - public long toTesla(double joules) { - return Math.round(joules * MekanismConfig.current().general.TO_TESLA.val()); - } - - public double fromTesla(double tesla) { - return tesla * MekanismConfig.current().general.FROM_TESLA.val(); - } } public static class ForgeAcceptor extends EnergyAcceptorWrapper { @@ -202,7 +195,7 @@ public ForgeAcceptor(IEnergyStorage forgeConsumer) { @Override public double acceptEnergy(EnumFacing side, double amount, boolean simulate) { - return fromForge(acceptor.receiveEnergy(toForge(amount), simulate)); + return ForgeEnergyIntegration.fromForge(acceptor.receiveEnergy(ForgeEnergyIntegration.toForge(amount), simulate)); } @Override @@ -212,15 +205,7 @@ public boolean canReceiveEnergy(EnumFacing side) { @Override public boolean needsEnergy(EnumFacing side) { - return acceptor.canReceive(); - } - - public int toForge(double joules) { - return MekanismUtils.clampToInt(joules * MekanismConfig.current().general.TO_FORGE.val()); - } - - public double fromForge(double forge) { - return forge * MekanismConfig.current().general.FROM_FORGE.val(); + return acceptor.receiveEnergy(1, true) > 0; } } } \ 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 e5c9a9ae3a4..a88419dc977 100644 --- a/src/main/java/mekanism/common/entity/EntityRobit.java +++ b/src/main/java/mekanism/common/entity/EntityRobit.java @@ -19,6 +19,8 @@ import mekanism.common.entity.ai.RobitAIFollow; import mekanism.common.entity.ai.RobitAIPickup; import mekanism.common.integration.MekanismHooks; +import mekanism.common.integration.forgeenergy.ForgeEnergyIntegration; +import mekanism.common.integration.tesla.TeslaIntegration; import mekanism.common.item.ItemConfigurator; import mekanism.common.item.ItemRobit; import mekanism.common.tile.TileEntityChargepad; @@ -168,13 +170,13 @@ public void onEntityUpdate() { setEnergy(getEnergy() + EnergizedItemManager.discharge(stack, MAX_ELECTRICITY - getEnergy())); } else if (MekanismUtils.useTesla() && stack.hasCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null)) { ITeslaProducer producer = stack.getCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null); - long needed = Math.round((MAX_ELECTRICITY - getEnergy()) * MekanismConfig.current().general.TO_TESLA.val()); - setEnergy(getEnergy() + producer.takePower(needed, false) * MekanismConfig.current().general.FROM_TESLA.val()); + long needed = TeslaIntegration.toTesla(MAX_ELECTRICITY - getEnergy()); + setEnergy(getEnergy() + TeslaIntegration.fromTesla(producer.takePower(needed, false))); } else if (MekanismUtils.useForge() && stack.hasCapability(CapabilityEnergy.ENERGY, null)) { IEnergyStorage storage = stack.getCapability(CapabilityEnergy.ENERGY, null); if (storage.canExtract()) { - int needed = MekanismUtils.clampToInt((MAX_ELECTRICITY - getEnergy()) * MekanismConfig.current().general.TO_FORGE.val()); - setEnergy(getEnergy() + storage.extractEnergy(needed, false) * MekanismConfig.current().general.FROM_FORGE.val()); + int needed = ForgeEnergyIntegration.toForge(MAX_ELECTRICITY - getEnergy()); + setEnergy(getEnergy() + ForgeEnergyIntegration.fromForge(storage.extractEnergy(needed, false))); } } else if (MekanismUtils.useRF() && stack.getItem() instanceof IEnergyContainerItem) { IEnergyContainerItem item = (IEnergyContainerItem) stack.getItem(); diff --git a/src/main/java/mekanism/common/integration/MekanismHooks.java b/src/main/java/mekanism/common/integration/MekanismHooks.java index 7a073c3cdf2..0300c037135 100644 --- a/src/main/java/mekanism/common/integration/MekanismHooks.java +++ b/src/main/java/mekanism/common/integration/MekanismHooks.java @@ -60,57 +60,37 @@ public final class MekanismHooks { public static final String GALACTICRAFT_MOD_ID = "Galacticraft API"; public static final String WAILA_MOD_ID = "Waila"; public static final String TOP_MOD_ID = "theoneprobe"; - public static final String BUILDCRAFT_MOD_ID = "BuildCraft"; + public static final String BUILDCRAFT_MOD_ID = "buildcraftcore"; public static final String CYCLIC_MOD_ID = "cyclicmagic"; public static final String MYSTICALAGRICULTURE_MOD_ID = "mysticalagriculture"; public static final String CRAFTTWEAKER_MOD_ID = "crafttweaker"; - public boolean IC2Loaded = false; - public boolean CCLoaded = false; public boolean AE2Loaded = false; - public boolean TeslaLoaded = false; + public boolean BuildCraftLoaded = false; + public boolean CCLoaded = false; + public boolean CraftTweakerLoaded = false; + public boolean CyclicLoaded = false; + public boolean IC2Loaded = false; + public boolean MALoaded = false; public boolean MCMPLoaded = false; - public boolean RFLoaded = false; public boolean MetallurgyLoaded = false; - public boolean CyclicLoaded = false; public boolean OCLoaded = false; - public boolean MALoaded = false; - public boolean CraftTweakerLoaded = false; + public boolean RFLoaded = false; + public boolean TeslaLoaded = false; public void hookPreInit() { - if (Loader.isModLoaded(IC2_MOD_ID)) { - IC2Loaded = true; - } - if (Loader.isModLoaded(COMPUTERCRAFT_MOD_ID)) { - CCLoaded = true; - } - if (Loader.isModLoaded(APPLIED_ENERGISTICS_2_MOD_ID)) { - AE2Loaded = true; - } - if (Loader.isModLoaded(OPENCOMPUTERS_MOD_ID)) { - OCLoaded = true; - } - if (Loader.isModLoaded(TESLA_MOD_ID)) { - TeslaLoaded = true; - } - if (Loader.isModLoaded(MCMULTIPART_MOD_ID)) { - MCMPLoaded = true; - } - if (Loader.isModLoaded(REDSTONEFLUX_MOD_ID)) { - RFLoaded = true; - } - if (Loader.isModLoaded(CYCLIC_MOD_ID)) { - CyclicLoaded = true; - } - if (Loader.isModLoaded(METALLURGY_MOD_ID)) { - MetallurgyLoaded = true; - } - if (Loader.isModLoaded(MYSTICALAGRICULTURE_MOD_ID)) { - MALoaded = true; - } - if (Loader.isModLoaded(CRAFTTWEAKER_MOD_ID)) { - CraftTweakerLoaded = true; - } + AE2Loaded = Loader.isModLoaded(APPLIED_ENERGISTICS_2_MOD_ID); + BuildCraftLoaded = Loader.isModLoaded(BUILDCRAFT_MOD_ID); + CCLoaded = Loader.isModLoaded(COMPUTERCRAFT_MOD_ID); + CraftTweakerLoaded = Loader.isModLoaded(CRAFTTWEAKER_MOD_ID); + CyclicLoaded = Loader.isModLoaded(CYCLIC_MOD_ID); + IC2Loaded = Loader.isModLoaded(IC2_MOD_ID); + MCMPLoaded = Loader.isModLoaded(MCMULTIPART_MOD_ID); + MetallurgyLoaded = Loader.isModLoaded(METALLURGY_MOD_ID); + MALoaded = Loader.isModLoaded(MYSTICALAGRICULTURE_MOD_ID); + OCLoaded = Loader.isModLoaded(OPENCOMPUTERS_MOD_ID); + RFLoaded = Loader.isModLoaded(REDSTONEFLUX_MOD_ID); + TeslaLoaded = Loader.isModLoaded(TESLA_MOD_ID); } public void hookInit() { diff --git a/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyCableIntegration.java b/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyCableIntegration.java index b7c575cf1d8..c27a5da8fab 100644 --- a/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyCableIntegration.java +++ b/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyCableIntegration.java @@ -19,8 +19,7 @@ public ForgeEnergyCableIntegration(TileEntityUniversalCable tile, EnumFacing fac @Override public int receiveEnergy(int maxReceive, boolean simulate) { - return MekanismUtils.clampToInt(tileEntity.acceptEnergy(side, maxReceive * MekanismConfig.current().general.FROM_FORGE.val(), simulate) - * MekanismConfig.current().general.TO_FORGE.val()); + return ForgeEnergyIntegration.toForge(tileEntity.acceptEnergy(side, ForgeEnergyIntegration.fromForge(maxReceive), simulate)); } @Override @@ -30,12 +29,12 @@ public int extractEnergy(int maxExtract, boolean simulate) { @Override public int getEnergyStored() { - return MekanismUtils.clampToInt(tileEntity.getEnergy() * MekanismConfig.current().general.TO_FORGE.val()); + return ForgeEnergyIntegration.toForge(tileEntity.getEnergy()); } @Override public int getMaxEnergyStored() { - return MekanismUtils.clampToInt(tileEntity.getMaxEnergy() * MekanismConfig.current().general.TO_FORGE.val()); + return ForgeEnergyIntegration.toForge(tileEntity.getMaxEnergy()); } @Override diff --git a/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyIntegration.java b/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyIntegration.java index deea61384e0..82b4d91979e 100644 --- a/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyIntegration.java +++ b/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyIntegration.java @@ -17,32 +17,32 @@ public ForgeEnergyIntegration(IEnergyWrapper tile, EnumFacing facing) { side = facing; } - public static double forgeToMek(int forge) { + public static double fromForge(int forge) { return forge * MekanismConfig.current().general.FROM_FORGE.val(); } - public static int mekToForge(double mek) { - return MekanismUtils.clampToInt(mek * MekanismConfig.current().general.TO_FORGE.val()); + public static int toForge(double joules) { + return MekanismUtils.clampToInt(joules * MekanismConfig.current().general.TO_FORGE.val()); } @Override public int receiveEnergy(int maxReceive, boolean simulate) { - return mekToForge(tileEntity.acceptEnergy(side, forgeToMek(maxReceive), simulate)); + return toForge(tileEntity.acceptEnergy(side, fromForge(maxReceive), simulate)); } @Override public int extractEnergy(int maxExtract, boolean simulate) { - return mekToForge(tileEntity.pullEnergy(side, forgeToMek(maxExtract), simulate)); + return toForge(tileEntity.pullEnergy(side, fromForge(maxExtract), simulate)); } @Override public int getEnergyStored() { - return Math.min(Integer.MAX_VALUE, mekToForge(tileEntity.getEnergy())); + return toForge(tileEntity.getEnergy()); } @Override public int getMaxEnergyStored() { - return Math.min(Integer.MAX_VALUE, mekToForge(tileEntity.getMaxEnergy())); + return toForge(tileEntity.getMaxEnergy()); } @Override diff --git a/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyItemWrapper.java b/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyItemWrapper.java index 678582e2929..eb195c8b71e 100644 --- a/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyItemWrapper.java +++ b/src/main/java/mekanism/common/integration/forgeenergy/ForgeEnergyItemWrapper.java @@ -2,8 +2,6 @@ import mekanism.api.energy.IEnergizedItem; import mekanism.common.capabilities.ItemCapabilityWrapper.ItemCapability; -import mekanism.common.config.MekanismConfig; -import mekanism.common.util.MekanismUtils; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.energy.CapabilityEnergy; import net.minecraftforge.energy.IEnergyStorage; @@ -25,7 +23,7 @@ public int receiveEnergy(int maxReceive, boolean simulate) { int energyNeeded = getMaxEnergyStored() - getEnergyStored(); int toReceive = Math.min(maxReceive, energyNeeded); if (!simulate) { - getItem().setEnergy(getStack(), getItem().getEnergy(getStack()) + toReceive * MekanismConfig.current().general.FROM_TESLA.val()); + getItem().setEnergy(getStack(), getItem().getEnergy(getStack()) + ForgeEnergyIntegration.fromForge(toReceive)); } return toReceive; } @@ -38,7 +36,7 @@ public int extractEnergy(int maxExtract, boolean simulate) { int energyRemaining = getEnergyStored(); int toSend = Math.min(maxExtract, energyRemaining); if (!simulate) { - getItem().setEnergy(getStack(), getItem().getEnergy(getStack()) - toSend * MekanismConfig.current().general.FROM_TESLA.val()); + getItem().setEnergy(getStack(), getItem().getEnergy(getStack()) - ForgeEnergyIntegration.fromForge(toSend)); } return toSend; } @@ -47,12 +45,12 @@ public int extractEnergy(int maxExtract, boolean simulate) { @Override public int getEnergyStored() { - return MekanismUtils.clampToInt(Math.round(getItem().getEnergy(getStack()) * MekanismConfig.current().general.TO_FORGE.val())); + return ForgeEnergyIntegration.toForge(getItem().getEnergy(getStack())); } @Override public int getMaxEnergyStored() { - return MekanismUtils.clampToInt(Math.round(getItem().getMaxEnergy(getStack()) * MekanismConfig.current().general.TO_FORGE.val())); + return ForgeEnergyIntegration.toForge(getItem().getMaxEnergy(getStack())); } @Override diff --git a/src/main/java/mekanism/common/integration/ic2/IC2Integration.java b/src/main/java/mekanism/common/integration/ic2/IC2Integration.java index c091889a436..95c6a3fa4bc 100644 --- a/src/main/java/mekanism/common/integration/ic2/IC2Integration.java +++ b/src/main/java/mekanism/common/integration/ic2/IC2Integration.java @@ -4,8 +4,6 @@ import ic2.api.energy.tile.IEnergySink; import ic2.api.energy.tile.IEnergySource; import ic2.api.energy.tile.IEnergyTile; -import mekanism.common.base.IEnergyWrapper; -import mekanism.common.config.MekanismConfig; import mekanism.common.integration.MekanismHooks; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.EnumFacing; @@ -21,23 +19,11 @@ public static boolean isOutputter(TileEntity tileEntity, EnumFacing side) { } @Method(modid = MekanismHooks.IC2_MOD_ID) - public static boolean isAcceptor(TileEntity orig, TileEntity tileEntity, EnumFacing side) { + public static boolean isAcceptor(TileEntity tileEntity, EnumFacing side) { IEnergyTile tile = EnergyNet.instance.getSubTile(tileEntity.getWorld(), tileEntity.getPos()); if (tile instanceof IEnergySink) { return ((IEnergySink) tile).acceptsEnergyFrom(null, side.getOpposite()); } return false; } - - @Method(modid = MekanismHooks.IC2_MOD_ID) - public static double emitEnergy(IEnergyWrapper from, TileEntity tileEntity, EnumFacing side, double currentSending) { - IEnergyTile tile = EnergyNet.instance.getSubTile(tileEntity.getWorld(), tileEntity.getPos()); - if (tile instanceof IEnergySink && ((IEnergySink) tile).acceptsEnergyFrom(from, side.getOpposite())) { - double toSend = Math.min(currentSending * MekanismConfig.current().general.TO_IC2.val(), - EnergyNet.instance.getPowerFromTier(((IEnergySink) tile).getSinkTier())); - toSend = Math.min(toSend, ((IEnergySink) tile).getDemandedEnergy()); - return (toSend - ((IEnergySink) tile).injectEnergy(side.getOpposite(), toSend, 0)) * MekanismConfig.current().general.FROM_IC2.val(); - } - return 0; - } } \ No newline at end of file diff --git a/src/main/java/mekanism/common/integration/tesla/TeslaCableIntegration.java b/src/main/java/mekanism/common/integration/tesla/TeslaCableIntegration.java index 104e5cc0ab9..1eb39d32a18 100644 --- a/src/main/java/mekanism/common/integration/tesla/TeslaCableIntegration.java +++ b/src/main/java/mekanism/common/integration/tesla/TeslaCableIntegration.java @@ -22,7 +22,7 @@ public TeslaCableIntegration(TileEntityUniversalCable tile, EnumFacing facing) { @Override @Method(modid = MekanismHooks.TESLA_MOD_ID) - public long givePower(long power, boolean simulated) { - return Math.round(tileEntity.acceptEnergy(side, power * MekanismConfig.current().general.FROM_TESLA.val(), simulated) * MekanismConfig.current().general.TO_TESLA.val()); + public long givePower(long power, boolean simulate) { + return TeslaIntegration.toTesla(tileEntity.acceptEnergy(side, TeslaIntegration.fromTesla(power), simulate)); } } \ No newline at end of file diff --git a/src/main/java/mekanism/common/integration/tesla/TeslaIntegration.java b/src/main/java/mekanism/common/integration/tesla/TeslaIntegration.java index 2c8b4c74aff..d1abc19190b 100644 --- a/src/main/java/mekanism/common/integration/tesla/TeslaIntegration.java +++ b/src/main/java/mekanism/common/integration/tesla/TeslaIntegration.java @@ -3,7 +3,6 @@ import mekanism.common.base.IEnergyWrapper; import mekanism.common.config.MekanismConfig; import mekanism.common.integration.MekanismHooks; -import mekanism.common.util.MekanismUtils; import net.darkhax.tesla.api.ITeslaConsumer; import net.darkhax.tesla.api.ITeslaHolder; import net.darkhax.tesla.api.ITeslaProducer; @@ -28,35 +27,35 @@ public TeslaIntegration(IEnergyWrapper tile, EnumFacing facing) { side = facing; } + public static long toTesla(double joules) { + return Math.round(joules * MekanismConfig.current().general.TO_TESLA.val()); + } + + public static double fromTesla(long tesla) { + return tesla * MekanismConfig.current().general.FROM_TESLA.val(); + } + @Override @Method(modid = MekanismHooks.TESLA_MOD_ID) public long getStoredPower() { - return Math.round(tileEntity.getEnergy() * MekanismConfig.current().general.TO_TESLA.val()); + return toTesla(tileEntity.getEnergy()); } @Override @Method(modid = MekanismHooks.TESLA_MOD_ID) public long getCapacity() { - return Math.round(tileEntity.getMaxEnergy() * MekanismConfig.current().general.TO_TESLA.val()); + return toTesla(tileEntity.getMaxEnergy()); } @Override @Method(modid = MekanismHooks.TESLA_MOD_ID) - public long takePower(long power, boolean simulated) { - return rfToTesla(tileEntity.extractEnergy(side, teslaToRF(power), simulated)); + public long takePower(long power, boolean simulate) { + return toTesla(tileEntity.pullEnergy(side, fromTesla(power), simulate)); } @Override @Method(modid = MekanismHooks.TESLA_MOD_ID) - public long givePower(long power, boolean simulated) { - return rfToTesla(tileEntity.receiveEnergy(side, teslaToRF(power), simulated)); - } - - public long rfToTesla(int rf) { - return Math.round(rf * MekanismConfig.current().general.FROM_RF.val() * MekanismConfig.current().general.TO_TESLA.val()); - } - - public int teslaToRF(long tesla) { - return MekanismUtils.clampToInt(tesla * MekanismConfig.current().general.FROM_TESLA.val() * MekanismConfig.current().general.TO_RF.val()); + public long givePower(long power, boolean simulate) { + return toTesla(tileEntity.acceptEnergy(side, fromTesla(power), simulate)); } } \ No newline at end of file diff --git a/src/main/java/mekanism/common/integration/tesla/TeslaItemWrapper.java b/src/main/java/mekanism/common/integration/tesla/TeslaItemWrapper.java index bea5e798e2c..23ce445be18 100644 --- a/src/main/java/mekanism/common/integration/tesla/TeslaItemWrapper.java +++ b/src/main/java/mekanism/common/integration/tesla/TeslaItemWrapper.java @@ -3,7 +3,6 @@ import mekanism.api.energy.IEnergizedItem; import mekanism.common.capabilities.Capabilities; import mekanism.common.capabilities.ItemCapabilityWrapper.ItemCapability; -import mekanism.common.config.MekanismConfig; import mekanism.common.integration.MekanismHooks; import net.darkhax.tesla.api.ITeslaConsumer; import net.darkhax.tesla.api.ITeslaHolder; @@ -32,12 +31,12 @@ public IEnergizedItem getItem() { @Override @Method(modid = MekanismHooks.TESLA_MOD_ID) - public long takePower(long power, boolean simulated) { + public long takePower(long power, boolean simulate) { if (getItem().canSend(getStack())) { long energyRemaining = getStoredPower(); long toSend = Math.min(power, energyRemaining); - if (!simulated) { - getItem().setEnergy(getStack(), getItem().getEnergy(getStack()) - toSend * MekanismConfig.current().general.FROM_TESLA.val()); + if (!simulate) { + getItem().setEnergy(getStack(), getItem().getEnergy(getStack()) - TeslaIntegration.fromTesla(toSend)); } return toSend; } @@ -46,12 +45,12 @@ public long takePower(long power, boolean simulated) { @Override @Method(modid = MekanismHooks.TESLA_MOD_ID) - public long givePower(long power, boolean simulated) { + public long givePower(long power, boolean simulate) { if (getItem().canReceive(getStack())) { long energyNeeded = getCapacity() - getStoredPower(); long toReceive = Math.min(power, energyNeeded); - if (!simulated) { - getItem().setEnergy(getStack(), getItem().getEnergy(getStack()) + toReceive * MekanismConfig.current().general.FROM_TESLA.val()); + if (!simulate) { + getItem().setEnergy(getStack(), getItem().getEnergy(getStack()) + TeslaIntegration.fromTesla(toReceive)); } return toReceive; } @@ -61,12 +60,12 @@ public long givePower(long power, boolean simulated) { @Override @Method(modid = MekanismHooks.TESLA_MOD_ID) public long getStoredPower() { - return Math.round(getItem().getEnergy(getStack()) * MekanismConfig.current().general.TO_TESLA.val()); + return TeslaIntegration.toTesla(getItem().getEnergy(getStack())); } @Override @Method(modid = MekanismHooks.TESLA_MOD_ID) public long getCapacity() { - return Math.round(getItem().getEnergy(getStack()) * MekanismConfig.current().general.TO_TESLA.val()); + return TeslaIntegration.toTesla(getItem().getMaxEnergy(getStack())); } } \ No newline at end of file diff --git a/src/main/java/mekanism/common/tile/TileEntityDigitalMiner.java b/src/main/java/mekanism/common/tile/TileEntityDigitalMiner.java index 1b6ad29df9e..bcde4ec5d08 100644 --- a/src/main/java/mekanism/common/tile/TileEntityDigitalMiner.java +++ b/src/main/java/mekanism/common/tile/TileEntityDigitalMiner.java @@ -1165,10 +1165,10 @@ public T getOffsetCapability(@Nonnull Capability capability, EnumFacing s return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast(getItemHandler(side)); } else if (isStrictEnergy(capability)) { return (T) this; - } else if (capability == CapabilityEnergy.ENERGY) { - return CapabilityEnergy.ENERGY.cast(getForgeEnergyWrapper(side)); } else if (isTesla(capability, side)) { return (T) getTeslaEnergyWrapper(side); + } else if (capability == CapabilityEnergy.ENERGY) { + return CapabilityEnergy.ENERGY.cast(getForgeEnergyWrapper(side)); } return getCapability(capability, side); } diff --git a/src/main/java/mekanism/common/tile/TileEntityInductionPort.java b/src/main/java/mekanism/common/tile/TileEntityInductionPort.java index c834241b5e6..4011a9f57c5 100644 --- a/src/main/java/mekanism/common/tile/TileEntityInductionPort.java +++ b/src/main/java/mekanism/common/tile/TileEntityInductionPort.java @@ -381,11 +381,8 @@ public boolean lightUpdate() { @Override public boolean hasCapability(@Nonnull Capability capability, EnumFacing facing) { return capability == Capabilities.ENERGY_STORAGE_CAPABILITY || capability == Capabilities.ENERGY_ACCEPTOR_CAPABILITY - || capability == Capabilities.ENERGY_OUTPUTTER_CAPABILITY || capability == Capabilities.TESLA_HOLDER_CAPABILITY - || capability == Capabilities.CONFIGURABLE_CAPABILITY || capability == CapabilityEnergy.ENERGY - || (capability == Capabilities.TESLA_CONSUMER_CAPABILITY && sideIsConsumer(facing)) - || (capability == Capabilities.TESLA_PRODUCER_CAPABILITY && sideIsOutput(facing)) - || super.hasCapability(capability, facing); + || capability == Capabilities.ENERGY_OUTPUTTER_CAPABILITY || capability == Capabilities.CONFIGURABLE_CAPABILITY + || capability == CapabilityEnergy.ENERGY || isTesla(capability, facing) || super.hasCapability(capability, facing); } @Override @@ -394,8 +391,7 @@ public T getCapability(@Nonnull Capability capability, EnumFacing facing) capability == Capabilities.ENERGY_OUTPUTTER_CAPABILITY || capability == Capabilities.CONFIGURABLE_CAPABILITY) { return (T) this; } - if (capability == Capabilities.TESLA_HOLDER_CAPABILITY || (capability == Capabilities.TESLA_CONSUMER_CAPABILITY && sideIsConsumer(facing)) - || (capability == Capabilities.TESLA_PRODUCER_CAPABILITY && sideIsOutput(facing))) { + if (isTesla(capability, facing)) { return (T) teslaManager.getWrapper(this, facing); } if (capability == CapabilityEnergy.ENERGY) { @@ -404,6 +400,11 @@ public T getCapability(@Nonnull Capability capability, EnumFacing facing) return super.getCapability(capability, facing); } + private boolean isTesla(@Nonnull Capability capability, EnumFacing side) { + return capability == Capabilities.TESLA_HOLDER_CAPABILITY || (capability == Capabilities.TESLA_CONSUMER_CAPABILITY && sideIsConsumer(side)) + || (capability == Capabilities.TESLA_PRODUCER_CAPABILITY && sideIsOutput(side)); + } + @Nonnull @Override public int[] getSlotsForFace(@Nonnull EnumFacing side) { diff --git a/src/main/java/mekanism/common/tile/prefab/TileEntityElectricBlock.java b/src/main/java/mekanism/common/tile/prefab/TileEntityElectricBlock.java index d226993a274..057282284a8 100644 --- a/src/main/java/mekanism/common/tile/prefab/TileEntityElectricBlock.java +++ b/src/main/java/mekanism/common/tile/prefab/TileEntityElectricBlock.java @@ -368,10 +368,10 @@ public T getCapability(@Nonnull Capability capability, EnumFacing side) { return null; } else if (isStrictEnergy(capability)) { return (T) this; - } else if (capability == CapabilityEnergy.ENERGY) { - return CapabilityEnergy.ENERGY.cast(getForgeEnergyWrapper(side)); } else if (isTesla(capability, side)) { return (T) getTeslaEnergyWrapper(side); + } else if (capability == CapabilityEnergy.ENERGY) { + return CapabilityEnergy.ENERGY.cast(getForgeEnergyWrapper(side)); } return super.getCapability(capability, side); } diff --git a/src/main/java/mekanism/common/tile/transmitter/TileEntityUniversalCable.java b/src/main/java/mekanism/common/tile/transmitter/TileEntityUniversalCable.java index 077a8f7d848..999f0fbf0b0 100644 --- a/src/main/java/mekanism/common/tile/transmitter/TileEntityUniversalCable.java +++ b/src/main/java/mekanism/common/tile/transmitter/TileEntityUniversalCable.java @@ -21,7 +21,9 @@ import mekanism.common.config.MekanismConfig; import mekanism.common.integration.MekanismHooks; import mekanism.common.integration.forgeenergy.ForgeEnergyCableIntegration; +import mekanism.common.integration.forgeenergy.ForgeEnergyIntegration; import mekanism.common.integration.tesla.TeslaCableIntegration; +import mekanism.common.integration.tesla.TeslaIntegration; import mekanism.common.tier.BaseTier; import mekanism.common.tier.CableTier; import mekanism.common.transmitters.grid.EnergyNetwork; @@ -73,7 +75,7 @@ public void update() { updateShare(); List sides = getConnections(ConnectionType.PULL); if (!sides.isEmpty()) { - TileEntity[] connectedOutputters = CableUtils.getConnectedOutputters(getPos(), getWorld()); + TileEntity[] connectedOutputters = CableUtils.getConnectedOutputters(this, getPos(), getWorld()); double canDraw = tier.getCableCapacity(); for (EnumFacing side : sides) { TileEntity outputter = connectedOutputters[side.ordinal()]; @@ -91,23 +93,21 @@ public void update() { } strictStorage.setEnergy(strictStorage.getEnergy() - toDraw); } else if (MekanismUtils.useTesla() && (teslaProducer = CapabilityUtils.getCapability(outputter, Capabilities.TESLA_PRODUCER_CAPABILITY, side.getOpposite())) != null) { - double toDraw = teslaProducer.takePower(MekanismUtils.clampToInt(canDraw * MekanismConfig.current().general.TO_TESLA.val()), true) - * MekanismConfig.current().general.FROM_TESLA.val(); + double toDraw = TeslaIntegration.fromTesla(teslaProducer.takePower(TeslaIntegration.toTesla(canDraw), true)); if (toDraw > 0) { toDraw -= takeEnergy(toDraw, true); } - teslaProducer.takePower(Math.round(toDraw * MekanismConfig.current().general.TO_TESLA.val()), false); + teslaProducer.takePower(TeslaIntegration.toTesla(toDraw), false); } else if (MekanismUtils.useForge() && (forgeStorage = CapabilityUtils.getCapability(outputter, CapabilityEnergy.ENERGY, side.getOpposite())) != null) { - double toDraw = forgeStorage.extractEnergy(MekanismUtils.clampToInt(canDraw * MekanismConfig.current().general.TO_FORGE.val()), true) - * MekanismConfig.current().general.FROM_FORGE.val(); + double toDraw = ForgeEnergyIntegration.fromForge(forgeStorage.extractEnergy(ForgeEnergyIntegration.toForge(canDraw), true)); if (toDraw > 0) { toDraw -= takeEnergy(toDraw, true); } - forgeStorage.extractEnergy(MekanismUtils.clampToInt(toDraw * MekanismConfig.current().general.TO_TESLA.val()), false); + forgeStorage.extractEnergy(ForgeEnergyIntegration.toForge(toDraw), false); } else if (MekanismUtils.useRF() && outputter instanceof IEnergyProvider) { IEnergyProvider rfProvider = (IEnergyProvider) outputter; - double toDraw = rfProvider.extractEnergy(side.getOpposite(), - MekanismUtils.clampToInt(canDraw * MekanismConfig.current().general.TO_RF.val()), true) * MekanismConfig.current().general.FROM_RF.val(); + double toDraw = rfProvider.extractEnergy(side.getOpposite(), MekanismUtils.clampToInt(canDraw * MekanismConfig.current().general.TO_RF.val()), true) + * MekanismConfig.current().general.FROM_RF.val(); if (toDraw > 0) { toDraw -= takeEnergy(toDraw, true); } @@ -332,11 +332,9 @@ public boolean hasCapability(@Nonnull Capability capability, EnumFacing facin public T getCapability(@Nonnull Capability capability, EnumFacing facing) { if (capability == Capabilities.ENERGY_STORAGE_CAPABILITY || capability == Capabilities.ENERGY_ACCEPTOR_CAPABILITY) { return (T) this; - } - if (capability == Capabilities.TESLA_CONSUMER_CAPABILITY) { + } else if (capability == Capabilities.TESLA_CONSUMER_CAPABILITY) { return (T) teslaManager.getWrapper(this, facing); - } - if (capability == CapabilityEnergy.ENERGY) { + } else 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 ce71882bcc7..cd1eb8ffeef 100644 --- a/src/main/java/mekanism/common/util/CableUtils.java +++ b/src/main/java/mekanism/common/util/CableUtils.java @@ -45,7 +45,7 @@ public static boolean isValidAcceptorOnSide(TileEntity cableEntity, TileEntity t if (tile == null || isCable(tile)) { return false; } - return isAcceptor(cableEntity, tile, side) || isOutputter(tile, side) || + return isAcceptor(cableEntity, tile, side) || isOutputter(cableEntity, tile, side) || (MekanismUtils.useRF() && tile instanceof IEnergyConnection && ((IEnergyConnection) tile).canConnectEnergy(side.getOpposite())) || (MekanismUtils.useForge() && CapabilityUtils.hasCapability(tile, CapabilityEnergy.ENERGY, side.getOpposite())); } @@ -58,21 +58,25 @@ public static boolean isValidAcceptorOnSide(TileEntity cableEntity, TileEntity t * @return TileEntity[] of connected cables */ public static TileEntity[] getConnectedOutputters(TileEntity tileEntity) { - return getConnectedOutputters(tileEntity.getPos(), tileEntity.getWorld()); + return getConnectedOutputters(tileEntity, tileEntity.getPos(), tileEntity.getWorld()); } public static TileEntity[] getConnectedOutputters(BlockPos pos, World world) { + return getConnectedOutputters(MekanismUtils.getTileEntity(world, pos), pos, world); + } + + public static TileEntity[] getConnectedOutputters(TileEntity source, BlockPos pos, World world) { TileEntity[] outputters = new TileEntity[]{null, null, null, null, null, null}; for (EnumFacing orientation : EnumFacing.VALUES) { final TileEntity outputter = MekanismUtils.getTileEntity(world, pos.offset(orientation)); - if (isOutputter(outputter, orientation)) { + if (isOutputter(source, outputter, orientation)) { outputters[orientation.ordinal()] = outputter; } } return outputters; } - public static boolean isOutputter(TileEntity tileEntity, EnumFacing side) { + public static boolean isOutputter(TileEntity source, TileEntity tileEntity, EnumFacing side) { if (tileEntity == null) { return false; } @@ -83,16 +87,13 @@ public static boolean isOutputter(TileEntity tileEntity, EnumFacing side) { if (outputter != null && outputter.canOutputEnergy(opposite)) { return true; } - if (MekanismUtils.useTesla() && CapabilityUtils.hasCapability(tileEntity, Capabilities.TESLA_PRODUCER_CAPABILITY, opposite)) { return true; } - IEnergyStorage forgeStorage; if (MekanismUtils.useForge() && (forgeStorage = CapabilityUtils.getCapability(tileEntity, CapabilityEnergy.ENERGY, opposite)) != null) { return forgeStorage.canExtract(); } - if (MekanismUtils.useRF() && tileEntity instanceof IEnergyProvider && ((IEnergyConnection) tileEntity).canConnectEnergy(opposite)) { return true; } @@ -100,24 +101,25 @@ public static boolean isOutputter(TileEntity tileEntity, EnumFacing side) { } - public static boolean isAcceptor(TileEntity orig, TileEntity tileEntity, EnumFacing side) { + public static boolean isAcceptor(TileEntity source, TileEntity tileEntity, EnumFacing side) { if (CapabilityUtils.hasCapability(tileEntity, Capabilities.GRID_TRANSMITTER_CAPABILITY, side.getOpposite())) { return false; } IStrictEnergyAcceptor strictEnergyAcceptor; - IEnergyStorage energyStorage; if ((strictEnergyAcceptor = CapabilityUtils.getCapability(tileEntity, Capabilities.ENERGY_ACCEPTOR_CAPABILITY, side.getOpposite())) != null) { return strictEnergyAcceptor.canReceiveEnergy(side.getOpposite()); - } else if (MekanismUtils.useTesla() && CapabilityUtils.hasCapability(tileEntity, Capabilities.TESLA_CONSUMER_CAPABILITY, side.getOpposite())) { + } + if (MekanismUtils.useTesla() && CapabilityUtils.hasCapability(tileEntity, Capabilities.TESLA_CONSUMER_CAPABILITY, side.getOpposite())) { return true; - } else if (MekanismUtils.useForge() && (energyStorage = CapabilityUtils.getCapability(tileEntity, CapabilityEnergy.ENERGY, side.getOpposite())) != null) { + } + IEnergyStorage energyStorage; + if (MekanismUtils.useForge() && (energyStorage = CapabilityUtils.getCapability(tileEntity, CapabilityEnergy.ENERGY, side.getOpposite())) != null) { return energyStorage.canReceive(); - } else if (MekanismUtils.useIC2() && IC2Integration.isAcceptor(orig, tileEntity, side)) { - return true; - } else if (MekanismUtils.useRF() && tileEntity instanceof IEnergyReceiver) { + } + if (MekanismUtils.useRF() && tileEntity instanceof IEnergyReceiver) { return ((IEnergyReceiver) tileEntity).canConnectEnergy(side.getOpposite()); } - return false; + return MekanismUtils.useIC2() && IC2Integration.isAcceptor(tileEntity, side); } public static void emit(IEnergyWrapper emitter) { diff --git a/src/main/java/mekanism/common/util/ChargeUtils.java b/src/main/java/mekanism/common/util/ChargeUtils.java index 89b66ea1b33..af4e3bd8f5a 100644 --- a/src/main/java/mekanism/common/util/ChargeUtils.java +++ b/src/main/java/mekanism/common/util/ChargeUtils.java @@ -8,6 +8,8 @@ import mekanism.api.energy.IStrictEnergyStorage; import mekanism.common.capabilities.Capabilities; import mekanism.common.config.MekanismConfig; +import mekanism.common.integration.forgeenergy.ForgeEnergyIntegration; +import mekanism.common.integration.tesla.TeslaIntegration; import mekanism.common.tile.prefab.TileEntityContainerBlock; import net.darkhax.tesla.api.ITeslaConsumer; import net.darkhax.tesla.api.ITeslaProducer; @@ -39,20 +41,20 @@ public static void discharge(int slotID, IStrictEnergyStorage storer) { if (!stack.isEmpty() && storer.getEnergy() < storer.getMaxEnergy()) { if (stack.getItem() instanceof IEnergizedItem) { storer.setEnergy(storer.getEnergy() + EnergizedItemManager.discharge(stack, storer.getMaxEnergy() - storer.getEnergy())); + } else if (MekanismUtils.useTesla() && stack.hasCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null)) { + ITeslaProducer producer = stack.getCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null); + long needed = TeslaIntegration.toTesla(storer.getMaxEnergy() - storer.getEnergy()); + storer.setEnergy(storer.getEnergy() + TeslaIntegration.fromTesla(producer.takePower(needed, false))); } else if (MekanismUtils.useForge() && stack.hasCapability(CapabilityEnergy.ENERGY, null)) { IEnergyStorage storage = stack.getCapability(CapabilityEnergy.ENERGY, null); if (storage.canExtract()) { - int needed = MekanismUtils.clampToInt((storer.getMaxEnergy() - storer.getEnergy()) * MekanismConfig.current().general.TO_FORGE.val()); - storer.setEnergy(storer.getEnergy() + storage.extractEnergy(needed, false) * MekanismConfig.current().general.FROM_FORGE.val()); + int needed = ForgeEnergyIntegration.toForge(storer.getMaxEnergy() - storer.getEnergy()); + storer.setEnergy(storer.getEnergy() + ForgeEnergyIntegration.fromForge(storage.extractEnergy(needed, false))); } } else if (MekanismUtils.useRF() && stack.getItem() instanceof IEnergyContainerItem) { IEnergyContainerItem item = (IEnergyContainerItem) stack.getItem(); int needed = MekanismUtils.clampToInt((storer.getMaxEnergy() - storer.getEnergy()) * MekanismConfig.current().general.TO_RF.val()); storer.setEnergy(storer.getEnergy() + (item.extractEnergy(stack, needed, false) * MekanismConfig.current().general.FROM_RF.val())); - } else if (MekanismUtils.useTesla() && stack.hasCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null)) { - ITeslaProducer producer = stack.getCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null); - long needed = Math.round((storer.getMaxEnergy() - storer.getEnergy()) * MekanismConfig.current().general.TO_TESLA.val()); - storer.setEnergy(storer.getEnergy() + producer.takePower(needed, false) * MekanismConfig.current().general.FROM_TESLA.val()); } else if (MekanismUtils.useIC2() && isIC2Dischargeable(stack)) { double gain = ElectricItem.manager.discharge(stack, (storer.getMaxEnergy() - storer.getEnergy()) * MekanismConfig.current().general.TO_IC2.val(), 4, true, true, false) * MekanismConfig.current().general.FROM_IC2.val(); @@ -85,20 +87,20 @@ public static void charge(ItemStack stack, IStrictEnergyStorage storer) { if (!stack.isEmpty() && storer.getEnergy() > 0) { if (stack.getItem() instanceof IEnergizedItem) { storer.setEnergy(storer.getEnergy() - EnergizedItemManager.charge(stack, storer.getEnergy())); + } else if (MekanismUtils.useTesla() && stack.hasCapability(Capabilities.TESLA_CONSUMER_CAPABILITY, null)) { + ITeslaConsumer consumer = stack.getCapability(Capabilities.TESLA_CONSUMER_CAPABILITY, null); + long stored = TeslaIntegration.toTesla(storer.getEnergy()); + storer.setEnergy(storer.getEnergy() - TeslaIntegration.fromTesla(consumer.givePower(stored, false))); } else if (MekanismUtils.useForge() && stack.hasCapability(CapabilityEnergy.ENERGY, null)) { IEnergyStorage storage = stack.getCapability(CapabilityEnergy.ENERGY, null); if (storage.canReceive()) { - int stored = MekanismUtils.clampToInt(storer.getEnergy() * MekanismConfig.current().general.TO_FORGE.val()); - storer.setEnergy(storer.getEnergy() - storage.receiveEnergy(stored, false) * MekanismConfig.current().general.FROM_FORGE.val()); + int stored = ForgeEnergyIntegration.toForge(storer.getEnergy()); + storer.setEnergy(storer.getEnergy() - ForgeEnergyIntegration.fromForge(storage.receiveEnergy(stored, false))); } } else if (MekanismUtils.useRF() && stack.getItem() instanceof IEnergyContainerItem) { IEnergyContainerItem item = (IEnergyContainerItem) stack.getItem(); int toTransfer = MekanismUtils.clampToInt(storer.getEnergy() * MekanismConfig.current().general.TO_RF.val()); storer.setEnergy(storer.getEnergy() - (item.receiveEnergy(stack, toTransfer, false) * MekanismConfig.current().general.FROM_RF.val())); - } else if (MekanismUtils.useTesla() && stack.hasCapability(Capabilities.TESLA_CONSUMER_CAPABILITY, null)) { - ITeslaConsumer consumer = stack.getCapability(Capabilities.TESLA_CONSUMER_CAPABILITY, null); - long stored = Math.round(storer.getEnergy() * MekanismConfig.current().general.TO_TESLA.val()); - storer.setEnergy(storer.getEnergy() - consumer.givePower(stored, false) * MekanismConfig.current().general.FROM_TESLA.val()); } else if (MekanismUtils.useIC2() && isIC2Chargeable(stack)) { double sent = ElectricItem.manager.charge(stack, storer.getEnergy() * MekanismConfig.current().general.TO_IC2.val(), 4, true, false) * MekanismConfig.current().general.FROM_IC2.val(); @@ -122,6 +124,13 @@ public static boolean canBeDischarged(ItemStack itemstack) { } } } + if (MekanismUtils.useTesla()) { + if (itemstack.hasCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null)) { + if (itemstack.getCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null).takePower(1, true) > 0) { + return true; + } + } + } if (MekanismUtils.useForge()) { if (itemstack.hasCapability(CapabilityEnergy.ENERGY, null)) { if (itemstack.getCapability(CapabilityEnergy.ENERGY, null).extractEnergy(1, true) > 0) { @@ -136,13 +145,6 @@ public static boolean canBeDischarged(ItemStack itemstack) { } } } - if (MekanismUtils.useTesla()) { - if (itemstack.hasCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null)) { - if (itemstack.getCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null).takePower(1, true) > 0) { - return true; - } - } - } if (MekanismUtils.useIC2()) { if (ElectricItem.manager.discharge(itemstack, 1, 0, true, true, true) > 0) { return true; @@ -167,6 +169,13 @@ public static boolean canBeCharged(ItemStack itemstack) { } } } + if (MekanismUtils.useTesla()) { + if (itemstack.hasCapability(Capabilities.TESLA_CONSUMER_CAPABILITY, null)) { + if (itemstack.getCapability(Capabilities.TESLA_CONSUMER_CAPABILITY, null).givePower(1, true) > 0) { + return true; + } + } + } if (MekanismUtils.useForge()) { if (itemstack.hasCapability(CapabilityEnergy.ENERGY, null)) { if (itemstack.getCapability(CapabilityEnergy.ENERGY, null).receiveEnergy(1, true) > 0) { @@ -181,13 +190,6 @@ public static boolean canBeCharged(ItemStack itemstack) { } } } - if (MekanismUtils.useTesla()) { - if (itemstack.hasCapability(Capabilities.TESLA_CONSUMER_CAPABILITY, null)) { - if (itemstack.getCapability(Capabilities.TESLA_CONSUMER_CAPABILITY, null).givePower(1, true) > 0) { - return true; - } - } - } if (MekanismUtils.useIC2()) { if (isIC2Chargeable(itemstack)) { return true; @@ -212,13 +214,8 @@ public static boolean canBeOutputted(ItemStack itemstack, boolean chargeSlot) { return energized.getEnergy(itemstack) == energized.getMaxEnergy(itemstack); } return energized.getEnergy(itemstack) == 0; - } else if (MekanismUtils.useRF() && itemstack.getItem() instanceof IEnergyContainerItem) { - IEnergyContainerItem energyContainer = (IEnergyContainerItem) itemstack.getItem(); - if (chargeSlot) { - return energyContainer.receiveEnergy(itemstack, 1, true) == 0; - } - return energyContainer.extractEnergy(itemstack, 1, true) == 0; - } else if (MekanismUtils.useTesla()) { + } + 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; @@ -226,13 +223,22 @@ public static boolean canBeOutputted(ItemStack itemstack, boolean chargeSlot) { ITeslaProducer producer = itemstack.getCapability(Capabilities.TESLA_PRODUCER_CAPABILITY, null); return producer.takePower(1, true) == 0; } - } else if (MekanismUtils.useForge() && itemstack.hasCapability(CapabilityEnergy.ENERGY, null)) { + } + 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; } return !storage.canExtract() || storage.extractEnergy(1, true) == 0; - } else if (MekanismUtils.useIC2() && (isIC2Chargeable(itemstack) || isIC2Dischargeable(itemstack))) { + } + if (MekanismUtils.useRF() && itemstack.getItem() instanceof IEnergyContainerItem) { + IEnergyContainerItem energyContainer = (IEnergyContainerItem) itemstack.getItem(); + if (chargeSlot) { + return energyContainer.receiveEnergy(itemstack, 1, true) == 0; + } + return energyContainer.extractEnergy(itemstack, 1, true) == 0; + } + if (MekanismUtils.useIC2() && (isIC2Chargeable(itemstack) || isIC2Dischargeable(itemstack))) { IElectricItemManager manager = ElectricItem.manager; if (manager != null) { if (chargeSlot) { diff --git a/src/main/java/mekanism/common/util/MekanismUtils.java b/src/main/java/mekanism/common/util/MekanismUtils.java index 83ad2e21656..e81b111d58a 100644 --- a/src/main/java/mekanism/common/util/MekanismUtils.java +++ b/src/main/java/mekanism/common/util/MekanismUtils.java @@ -30,6 +30,7 @@ import mekanism.common.block.states.BlockStateMachine.MachineType; import mekanism.common.block.states.BlockStateTransmitter.TransmitterType; import mekanism.common.config.MekanismConfig; +import mekanism.common.integration.tesla.TeslaIntegration; import mekanism.common.inventory.InventoryPersonalChest; import mekanism.common.inventory.container.ContainerPersonalChest; import mekanism.common.item.ItemBlockGasTank; @@ -738,7 +739,7 @@ public static String getEnergyDisplay(double energy) { case EU: return UnitDisplayUtils.getDisplayShort(energy * MekanismConfig.current().general.TO_IC2.val(), ElectricUnit.ELECTRICAL_UNITS); case T: - return UnitDisplayUtils.getDisplayShort(energy * MekanismConfig.current().general.TO_TESLA.val(), ElectricUnit.TESLA); + return UnitDisplayUtils.getDisplayShort(TeslaIntegration.toTesla(energy), ElectricUnit.TESLA); } return "error"; } 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 22e4274bda0..0a30856b453 100644 --- a/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineValve.java +++ b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineValve.java @@ -379,14 +379,11 @@ public T getCapability(@Nonnull Capability capability, EnumFacing side) { if ((!world.isRemote && structure != null) || (world.isRemote && clientHasStructure)) { if (capability == Capabilities.ENERGY_STORAGE_CAPABILITY || capability == Capabilities.ENERGY_OUTPUTTER_CAPABILITY) { return (T) this; - } - if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) { + } else if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) { return CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY.cast(new FluidHandlerWrapper(this, side)); - } - if (capability == Capabilities.TESLA_HOLDER_CAPABILITY || (capability == Capabilities.TESLA_PRODUCER_CAPABILITY && sideIsOutput(facing))) { + } else if (capability == Capabilities.TESLA_HOLDER_CAPABILITY || (capability == Capabilities.TESLA_PRODUCER_CAPABILITY && sideIsOutput(facing))) { return (T) teslaManager.getWrapper(this, facing); - } - if (capability == CapabilityEnergy.ENERGY) { + } else if (capability == CapabilityEnergy.ENERGY) { return CapabilityEnergy.ENERGY.cast(forgeEnergyManager.getWrapper(this, facing)); } } diff --git a/src/main/resources/mcmod.info b/src/main/resources/mcmod.info index f14d55a5a3c..12833150da6 100755 --- a/src/main/resources/mcmod.info +++ b/src/main/resources/mcmod.info @@ -19,8 +19,7 @@ "redstoneflux", "mcmultipart", "jei", - "buildcraft", - "buildcraftapi", + "buildcraftcore", "ic2", "computercraft", "galaticraft api",