From 6e348dbc5d2e4e39a9e1b4200701d1cc5a5392bf Mon Sep 17 00:00:00 2001 From: mezz Date: Thu, 30 Jun 2016 16:54:57 -0700 Subject: [PATCH] Add support for Tesla power --- build.gradle | 4 + gradle.properties | 2 +- .../multiblock/TileAlvearyClimatiser.java | 16 +++ .../java/forestry/core/tiles/TileEngine.java | 17 +++ .../java/forestry/core/tiles/TilePowered.java | 17 +++ .../java/forestry/core/utils/BlockUtil.java | 18 ++- .../java/forestry/energy/EnergyManager.java | 95 +++++++++++-- .../java/forestry/energy/EnergyStorage.java | 129 ++++++++++++++++++ .../farming/tiles/TileFarmGearbox.java | 16 +++ .../tiles/TileGreenhouseGearbox.java | 25 ++++ 10 files changed, 323 insertions(+), 16 deletions(-) create mode 100644 src/main/java/forestry/energy/EnergyStorage.java diff --git a/build.gradle b/build.gradle index 6b8f441f0..8d7c11c14 100755 --- a/build.gradle +++ b/build.gradle @@ -55,6 +55,9 @@ sourceSets { } repositories { + maven { + url 'http://maven.epoxide.xyz' + } maven { url "http://dvs1.progwml6.com/files/maven" } @@ -65,6 +68,7 @@ repositories { } dependencies { + deobfCompile "net.darkhax.tesla:Tesla:${tesla_version}" deobfCompile "mezz.jei:jei_${mcversion}:${jei_version}:api" runtime "mezz.jei:jei_${mcversion}:${jei_version}" deobfCompile "net.industrial-craft:industrialcraft-2:${ic2_version}:api" diff --git a/gradle.properties b/gradle.properties index dd1e27516..824c11e57 100644 --- a/gradle.properties +++ b/gradle.properties @@ -8,4 +8,4 @@ ic2_version=2.5.5-ex19 version_major=5 version_minor=1 -version_patch=7 +version_patch=8 diff --git a/src/main/java/forestry/apiculture/multiblock/TileAlvearyClimatiser.java b/src/main/java/forestry/apiculture/multiblock/TileAlvearyClimatiser.java index b7d04860b..3e4e6768c 100644 --- a/src/main/java/forestry/apiculture/multiblock/TileAlvearyClimatiser.java +++ b/src/main/java/forestry/apiculture/multiblock/TileAlvearyClimatiser.java @@ -11,6 +11,7 @@ package forestry.apiculture.multiblock; import javax.annotation.Nonnull; +import javax.annotation.Nullable; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumFacing; @@ -23,6 +24,7 @@ import forestry.core.tiles.IActivatable; import forestry.energy.EnergyManager; import cofh.api.energy.IEnergyReceiver; +import net.minecraftforge.common.capabilities.Capability; public abstract class TileAlvearyClimatiser extends TileAlveary implements IEnergyReceiver, IActivatable, IAlvearyComponent.Climatiser { @@ -143,4 +145,18 @@ public abstract class TileAlvearyClimatiser extends TileAlveary implements IEner return energyManager.canConnectEnergy(from); } + @Override + public boolean hasCapability(@Nonnull Capability capability, @Nullable EnumFacing facing) { + return energyManager.hasCapability(capability) || super.hasCapability(capability, facing); + } + + @Nonnull + @Override + public T getCapability(@Nonnull Capability capability, @Nullable EnumFacing facing) { + T energyCapability = energyManager.getCapability(capability); + if (energyCapability != null) { + return energyCapability; + } + return super.getCapability(capability, facing); + } } diff --git a/src/main/java/forestry/core/tiles/TileEngine.java b/src/main/java/forestry/core/tiles/TileEngine.java index 6f20b49c6..fb9260c71 100644 --- a/src/main/java/forestry/core/tiles/TileEngine.java +++ b/src/main/java/forestry/core/tiles/TileEngine.java @@ -11,6 +11,7 @@ package forestry.core.tiles; import javax.annotation.Nonnull; +import javax.annotation.Nullable; import java.io.IOException; import net.minecraft.block.state.IBlockState; @@ -33,6 +34,7 @@ import forestry.core.utils.BlockUtil; import forestry.energy.EnergyManager; import cofh.api.energy.IEnergyConnection; +import net.minecraftforge.common.capabilities.Capability; public abstract class TileEngine extends TileBase implements IEnergyConnection, IActivatable { private static final int CANT_SEND_ENERGY_TIME = 20; @@ -294,4 +296,19 @@ public abstract class TileEngine extends TileBase implements IEnergyConnection, public EnergyManager getEnergyManager() { return energyManager; } + + @Override + public boolean hasCapability(@Nonnull Capability capability, @Nullable EnumFacing facing) { + return energyManager.hasCapability(capability) || super.hasCapability(capability, facing); + } + + @Nonnull + @Override + public T getCapability(@Nonnull Capability capability, @Nullable EnumFacing facing) { + T energyCapability = energyManager.getCapability(capability); + if (energyCapability != null) { + return energyCapability; + } + return super.getCapability(capability, facing); + } } diff --git a/src/main/java/forestry/core/tiles/TilePowered.java b/src/main/java/forestry/core/tiles/TilePowered.java index 6047ae45e..ffc71da2b 100644 --- a/src/main/java/forestry/core/tiles/TilePowered.java +++ b/src/main/java/forestry/core/tiles/TilePowered.java @@ -11,6 +11,7 @@ package forestry.core.tiles; import javax.annotation.Nonnull; +import javax.annotation.Nullable; import java.io.IOException; import net.minecraft.nbt.NBTTagCompound; @@ -27,6 +28,7 @@ import forestry.core.render.TankRenderInfo; import forestry.energy.EnergyManager; import cofh.api.energy.IEnergyReceiver; +import net.minecraftforge.common.capabilities.Capability; //@Optional.Interface(iface = "buildcraft.api.tiles.IHasWork", modid = "BuildCraftAPI|tiles") public abstract class TilePowered extends TileBase implements IRenderableTile, IEnergyReceiver, IPowerHandler, ISpeedUpgradable, IStreamableGui { @@ -218,4 +220,19 @@ public abstract class TilePowered extends TileBase implements IRenderableTile, I public boolean canConnectEnergy(EnumFacing from) { return energyManager.canConnectEnergy(from); } + + @Override + public boolean hasCapability(@Nonnull Capability capability, @Nullable EnumFacing facing) { + return energyManager.hasCapability(capability) || super.hasCapability(capability, facing); + } + + @Nonnull + @Override + public T getCapability(@Nonnull Capability capability, @Nullable EnumFacing facing) { + T energyCapability = energyManager.getCapability(capability); + if (energyCapability != null) { + return energyCapability; + } + return super.getCapability(capability, facing); + } } diff --git a/src/main/java/forestry/core/utils/BlockUtil.java b/src/main/java/forestry/core/utils/BlockUtil.java index 856b6864a..b45858b51 100644 --- a/src/main/java/forestry/core/utils/BlockUtil.java +++ b/src/main/java/forestry/core/utils/BlockUtil.java @@ -19,6 +19,7 @@ import cofh.api.energy.IEnergyReceiver; import forestry.core.network.packets.PacketFXSignal; import forestry.core.proxy.Proxies; import forestry.core.tiles.TileEngine; +import forestry.energy.EnergyManager; import net.minecraft.block.Block; import net.minecraft.block.BlockHorizontal; import net.minecraft.block.BlockOldLog; @@ -51,12 +52,19 @@ public abstract class BlockUtil { } public static boolean isEnergyReceiverOrEngine(EnumFacing side, TileEntity tile) { - if (!(tile instanceof IEnergyReceiver) && !(tile instanceof TileEngine)) { - return false; - } + if (tile != null) { + if (EnergyManager.TESLA_CONSUMER != null) { + if (tile.hasCapability(EnergyManager.TESLA_CONSUMER, side)) { + return true; + } + } - IEnergyConnection receptor = (IEnergyConnection) tile; - return receptor.canConnectEnergy(side); + if (tile instanceof IEnergyReceiver || (tile instanceof TileEngine)) { + IEnergyConnection receptor = (IEnergyConnection) tile; + return receptor.canConnectEnergy(side); + } + } + return false; } public static boolean tryPlantCocoaPod(World world, BlockPos pos) { diff --git a/src/main/java/forestry/energy/EnergyManager.java b/src/main/java/forestry/energy/EnergyManager.java index 6fffb562c..550180e33 100644 --- a/src/main/java/forestry/energy/EnergyManager.java +++ b/src/main/java/forestry/energy/EnergyManager.java @@ -2,6 +2,9 @@ package forestry.energy; import java.io.IOException; +import net.darkhax.tesla.api.ITeslaConsumer; +import net.darkhax.tesla.api.ITeslaHolder; +import net.darkhax.tesla.api.ITeslaProducer; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.EnumFacing; @@ -13,11 +16,25 @@ import forestry.core.network.IStreamable; import forestry.core.tiles.TileEngine; import forestry.core.utils.BlockUtil; -import cofh.api.energy.EnergyStorage; import cofh.api.energy.IEnergyProvider; import cofh.api.energy.IEnergyReceiver; +import net.minecraftforge.common.capabilities.Capability; +import net.minecraftforge.common.capabilities.CapabilityInject; +import net.minecraftforge.fml.common.Optional; + +@Optional.InterfaceList({ + @Optional.Interface(iface = "net.darkhax.tesla.api.ITeslaConsumer", modid = "Tesla"), + @Optional.Interface(iface = "net.darkhax.tesla.api.ITeslaProducer", modid = "Tesla"), + @Optional.Interface(iface = "net.darkhax.tesla.api.ITeslaHolder", modid = "Tesla") +}) +public class EnergyManager implements IEnergyReceiver, ITeslaConsumer, ITeslaProducer, ITeslaHolder, IEnergyProvider, IStreamable { + @CapabilityInject(ITeslaConsumer.class) + public static Capability TESLA_CONSUMER = null; + @CapabilityInject(ITeslaProducer.class) + public static Capability TESLA_PRODUCER = null; + @CapabilityInject(ITeslaHolder.class) + public static Capability TESLA_HOLDER = null; -public class EnergyManager implements IEnergyReceiver, IEnergyProvider, IStreamable { private enum EnergyTransferMode { EXTRACT, RECEIVE, BOTH } @@ -63,7 +80,6 @@ public class EnergyManager implements IEnergyReceiver, IEnergyProvider, IStreama /* NBT */ public EnergyManager readFromNBT(NBTTagCompound nbt) { - NBTTagCompound energyManagerNBT = nbt.getCompoundTag("EnergyManager"); NBTTagCompound energyStorageNBT = energyManagerNBT.getCompoundTag("EnergyStorage"); energyStorage.readFromNBT(energyStorageNBT); @@ -72,7 +88,6 @@ public class EnergyManager implements IEnergyReceiver, IEnergyProvider, IStreama } public NBTTagCompound writeToNBT(NBTTagCompound nbt) { - NBTTagCompound energyStorageNBT = new NBTTagCompound(); energyStorage.writeToNBT(energyStorageNBT); @@ -188,16 +203,18 @@ public class EnergyManager implements IEnergyReceiver, IEnergyProvider, IStreama */ public int sendEnergy(EnumFacing orientation, TileEntity tile, int amount, boolean simulate) { int sent = 0; - if (BlockUtil.isEnergyReceiverOrEngine(orientation.getOpposite(), tile)) { + if (tile != null) { int extractable = energyStorage.extractEnergy(amount, true); if (extractable > 0) { - - if (tile instanceof IEnergyReceiver) { + EnumFacing side = orientation.getOpposite(); + if (TESLA_CONSUMER != null && tile.hasCapability(TESLA_CONSUMER, side)) { + sent = sendEnergyTesla(tile, side, extractable, simulate); + } else if (tile instanceof IEnergyReceiver) { IEnergyReceiver receptor = (IEnergyReceiver) tile; - sent = receptor.receiveEnergy(orientation.getOpposite(), extractable, simulate); - } else if (tile instanceof TileEngine) { + sent = receptor.receiveEnergy(side, extractable, simulate); + } else if (tile instanceof TileEngine) { // engine chaining TileEngine receptor = (TileEngine) tile; - sent = receptor.getEnergyManager().receiveEnergy(orientation.getOpposite(), extractable, simulate); + sent = receptor.getEnergyManager().receiveEnergy(side, extractable, simulate); } energyStorage.extractEnergy(sent, simulate); @@ -219,4 +236,62 @@ public class EnergyManager implements IEnergyReceiver, IEnergyProvider, IStreama public void generateEnergy(int amount) { energyStorage.modifyEnergyStored(amount); } + + public boolean hasCapability(Capability capability) { + if (capability == TESLA_PRODUCER && canExtract()) { + return true; + } else if (capability == TESLA_CONSUMER && canReceive()) { + return true; + } else if (capability == TESLA_HOLDER) { + return true; + } + return false; + } + + public T getCapability(Capability capability) { + if (capability == TESLA_PRODUCER && canExtract()) { + return TESLA_PRODUCER.cast(this); + } else if (capability == TESLA_CONSUMER && canReceive()) { + return TESLA_CONSUMER.cast(this); + } else if (capability == TESLA_HOLDER) { + return TESLA_HOLDER.cast(this); + } + return null; + } + + @Optional.Method(modid = "Tesla") + public static int sendEnergyTesla(TileEntity tile, EnumFacing side, int amount, boolean simulate) { + ITeslaConsumer consumer = tile.getCapability(TESLA_CONSUMER, side); + return (int) consumer.givePower(amount, simulate); + } + + @Optional.Method(modid = "Tesla") + @Override + public long givePower(long power, boolean simulated) { + if (!canReceive()) { + return 0; + } + return energyStorage.receiveEnergy(power, simulated); + } + + @Optional.Method(modid = "Tesla") + @Override + public long takePower(long power, boolean simulated) { + if (!canExtract()) { + return 0; + } + return energyStorage.extractEnergy(power, simulated); + } + + @Optional.Method(modid = "Tesla") + @Override + public long getStoredPower() { + return energyStorage.getEnergyStored(); + } + + @Optional.Method(modid = "Tesla") + @Override + public long getCapacity() { + return energyStorage.getMaxEnergyStored(); + } } diff --git a/src/main/java/forestry/energy/EnergyStorage.java b/src/main/java/forestry/energy/EnergyStorage.java new file mode 100644 index 000000000..06ef9571d --- /dev/null +++ b/src/main/java/forestry/energy/EnergyStorage.java @@ -0,0 +1,129 @@ +package forestry.energy; + +import net.minecraft.nbt.NBTTagCompound; + +public class EnergyStorage { + + protected int energy; + protected int capacity; + protected int maxReceive; + protected int maxExtract; + + public EnergyStorage(int capacity, int maxReceive, int maxExtract) { + this.capacity = capacity; + this.maxReceive = maxReceive; + this.maxExtract = maxExtract; + } + + public EnergyStorage readFromNBT(NBTTagCompound nbt) { + this.energy = nbt.getInteger("Energy"); + + if (energy > capacity) { + energy = capacity; + } + return this; + } + + public NBTTagCompound writeToNBT(NBTTagCompound nbt) { + if (energy < 0) { + energy = 0; + } + nbt.setInteger("Energy", energy); + return nbt; + } + + public EnergyStorage setCapacity(int capacity) { + this.capacity = capacity; + + if (energy > capacity) { + energy = capacity; + } + return this; + } + + public EnergyStorage setMaxTransfer(int maxTransfer) { + + setMaxReceive(maxTransfer); + setMaxExtract(maxTransfer); + return this; + } + + public EnergyStorage setMaxReceive(int maxReceive) { + + this.maxReceive = maxReceive; + return this; + } + + public EnergyStorage setMaxExtract(int maxExtract) { + this.maxExtract = maxExtract; + return this; + } + + public int getMaxReceive() { + return maxReceive; + } + + public int getMaxExtract() { + return maxExtract; + } + + /** + * This function is included to allow for server to client sync. Do not call this externally to the containing Tile Entity, as not all IEnergyHandlers + * are guaranteed to have it. + * + * @param energy + */ + public void setEnergyStored(int energy) { + if (energy > capacity) { + this.energy = capacity; + } else if (energy < 0) { + this.energy = 0; + } else { + this.energy = energy; + } + } + + /** + * This function is included to allow the containing tile to directly and efficiently modify the energy contained in the EnergyStorage. Do not rely on this + * externally, as not all IEnergyHandlers are guaranteed to have it. + * + * @param energy + */ + public void modifyEnergyStored(int energy) { + this.energy += energy; + + if (this.energy > capacity) { + this.energy = capacity; + } else if (this.energy < 0) { + this.energy = 0; + } + } + + /* IEnergyStorage */ + public int receiveEnergy(long maxReceive, boolean simulate) { + int energyReceived = (int) Math.min(capacity - energy, Math.min(this.maxReceive, maxReceive)); + + if (!simulate) { + energy += energyReceived; + } + return energyReceived; + } + + public int extractEnergy(long maxExtract, boolean simulate) { + int energyExtracted = (int) Math.min(energy, Math.min(this.maxExtract, maxExtract)); + + if (!simulate) { + energy -= energyExtracted; + } + + return energyExtracted; + } + + public int getEnergyStored() { + return energy; + } + + public int getMaxEnergyStored() { + return capacity; + } +} diff --git a/src/main/java/forestry/farming/tiles/TileFarmGearbox.java b/src/main/java/forestry/farming/tiles/TileFarmGearbox.java index 7f5abb282..a93172f5c 100644 --- a/src/main/java/forestry/farming/tiles/TileFarmGearbox.java +++ b/src/main/java/forestry/farming/tiles/TileFarmGearbox.java @@ -11,6 +11,7 @@ package forestry.farming.tiles; import javax.annotation.Nonnull; +import javax.annotation.Nullable; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumFacing; @@ -21,6 +22,7 @@ import forestry.energy.EnergyManager; import cofh.api.energy.IEnergyHandler; import cofh.api.energy.IEnergyReceiver; +import net.minecraftforge.common.capabilities.Capability; public class TileFarmGearbox extends TileFarm implements IEnergyReceiver, IEnergyHandler, IFarmComponent.Active { @@ -117,4 +119,18 @@ public class TileFarmGearbox extends TileFarm implements IEnergyReceiver, IEnerg return energyManager.canConnectEnergy(from); } + @Override + public boolean hasCapability(@Nonnull Capability capability, @Nullable EnumFacing facing) { + return energyManager.hasCapability(capability) || super.hasCapability(capability, facing); + } + + @Nonnull + @Override + public T getCapability(@Nonnull Capability capability, @Nullable EnumFacing facing) { + T energyCapability = energyManager.getCapability(capability); + if (energyCapability != null) { + return energyCapability; + } + return super.getCapability(capability, facing); + } } diff --git a/src/main/java/forestry/greenhouse/tiles/TileGreenhouseGearbox.java b/src/main/java/forestry/greenhouse/tiles/TileGreenhouseGearbox.java index f81f60b9a..779e4a760 100644 --- a/src/main/java/forestry/greenhouse/tiles/TileGreenhouseGearbox.java +++ b/src/main/java/forestry/greenhouse/tiles/TileGreenhouseGearbox.java @@ -10,12 +10,16 @@ ******************************************************************************/ package forestry.greenhouse.tiles; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; + import net.minecraft.util.EnumFacing; import forestry.energy.EnergyManager; import cofh.api.energy.IEnergyHandler; import cofh.api.energy.IEnergyReceiver; +import net.minecraftforge.common.capabilities.Capability; public class TileGreenhouseGearbox extends TileGreenhouse implements IEnergyReceiver, IEnergyHandler { @@ -59,4 +63,25 @@ public class TileGreenhouseGearbox extends TileGreenhouse implements IEnergyRece return getMultiblockLogic().getController().getEnergyManager(); } + @Override + public boolean hasCapability(@Nonnull Capability capability, @Nullable EnumFacing facing) { + EnergyManager energyManager = getEnergyManager(); + if (energyManager != null && energyManager.hasCapability(capability)) { + return true; + } + return super.hasCapability(capability, facing); + } + + @Nonnull + @Override + public T getCapability(@Nonnull Capability capability, @Nullable EnumFacing facing) { + EnergyManager energyManager = getEnergyManager(); + if (energyManager != null) { + T energyCapability = energyManager.getCapability(capability); + if (energyCapability != null) { + return energyCapability; + } + } + return super.getCapability(capability, facing); + } }