From 9c8f914f422b97dec83036e92e17959c1946eaed Mon Sep 17 00:00:00 2001 From: Sebastian Hartte Date: Sun, 6 Nov 2016 22:22:34 +0100 Subject: [PATCH] Added CoFH Energy API. --- build.gradle | 10 +- src/thirdparty/LICENSE CoFH API.txt | 165 ++++++++++++++++++ .../java/cofh/api/CoFHAPIProps.java | 11 ++ .../java/cofh/api/energy/EnergyStorage.java | 162 +++++++++++++++++ .../cofh/api/energy/IEnergyConnection.java | 22 +++ .../cofh/api/energy/IEnergyContainerItem.java | 52 ++++++ .../java/cofh/api/energy/IEnergyHandler.java | 27 +++ .../java/cofh/api/energy/IEnergyProvider.java | 29 +++ .../java/cofh/api/energy/IEnergyReceiver.java | 29 +++ .../java/cofh/api/energy/IEnergyStorage.java | 46 +++++ .../cofh/api/energy/ItemEnergyContainer.java | 113 ++++++++++++ .../cofh/api/energy/TileEnergyHandler.java | 68 ++++++++ .../java/cofh/api/energy/package-info.java | 10 ++ .../java/cofh/api/package-info.java | 9 + 14 files changed, 752 insertions(+), 1 deletion(-) create mode 100644 src/thirdparty/LICENSE CoFH API.txt create mode 100644 src/thirdparty/java/cofh/api/CoFHAPIProps.java create mode 100644 src/thirdparty/java/cofh/api/energy/EnergyStorage.java create mode 100644 src/thirdparty/java/cofh/api/energy/IEnergyConnection.java create mode 100644 src/thirdparty/java/cofh/api/energy/IEnergyContainerItem.java create mode 100644 src/thirdparty/java/cofh/api/energy/IEnergyHandler.java create mode 100644 src/thirdparty/java/cofh/api/energy/IEnergyProvider.java create mode 100644 src/thirdparty/java/cofh/api/energy/IEnergyReceiver.java create mode 100644 src/thirdparty/java/cofh/api/energy/IEnergyStorage.java create mode 100644 src/thirdparty/java/cofh/api/energy/ItemEnergyContainer.java create mode 100644 src/thirdparty/java/cofh/api/energy/TileEnergyHandler.java create mode 100644 src/thirdparty/java/cofh/api/energy/package-info.java create mode 100644 src/thirdparty/java/cofh/api/package-info.java diff --git a/build.gradle b/build.gradle index 54f06e5c..337201ed 100644 --- a/build.gradle +++ b/build.gradle @@ -87,12 +87,20 @@ sourceSets { api - thirdparty + // This source set will contain third party API code that we need to compile, but which is not shipped with the jar + thirdparty { + // Third Party APIs often need access to Minecraft classes (i.e. EnumFacing), so set this up here + compileClasspath += configurations.forgeGradleMc + configurations.forgeGradleMcDeps + } main } +dependencies { + compile sourceSets.thirdparty.output +} + processResources { // this will ensure that this task is redone when the versions change. diff --git a/src/thirdparty/LICENSE CoFH API.txt b/src/thirdparty/LICENSE CoFH API.txt new file mode 100644 index 00000000..65c5ca88 --- /dev/null +++ b/src/thirdparty/LICENSE CoFH API.txt @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. diff --git a/src/thirdparty/java/cofh/api/CoFHAPIProps.java b/src/thirdparty/java/cofh/api/CoFHAPIProps.java new file mode 100644 index 00000000..eb2e05ad --- /dev/null +++ b/src/thirdparty/java/cofh/api/CoFHAPIProps.java @@ -0,0 +1,11 @@ +package cofh.api; + +public class CoFHAPIProps { + + private CoFHAPIProps() { + + } + + public static final String VERSION = "1.8.9R1.2.0B1"; + +} diff --git a/src/thirdparty/java/cofh/api/energy/EnergyStorage.java b/src/thirdparty/java/cofh/api/energy/EnergyStorage.java new file mode 100644 index 00000000..dd7dd3e0 --- /dev/null +++ b/src/thirdparty/java/cofh/api/energy/EnergyStorage.java @@ -0,0 +1,162 @@ +package cofh.api.energy; + +import net.minecraft.nbt.NBTTagCompound; + +/** + * Reference implementation of {@link IEnergyStorage}. Use/extend this or implement your own. + * + * @author King Lemming + * + */ +public class EnergyStorage implements IEnergyStorage { + + protected int energy; + protected int capacity; + protected int maxReceive; + protected int maxExtract; + + public EnergyStorage(int capacity) { + + this(capacity, capacity, capacity); + } + + public EnergyStorage(int capacity, int maxTransfer) { + + this(capacity, maxTransfer, maxTransfer); + } + + 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) { + + this.energy = energy; + + if (this.energy > capacity) { + this.energy = capacity; + } else if (this.energy < 0) { + this.energy = 0; + } + } + + /** + * 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 */ + @Override + public int receiveEnergy(int maxReceive, boolean simulate) { + + int energyReceived = Math.min(capacity - energy, Math.min(this.maxReceive, maxReceive)); + + if (!simulate) { + energy += energyReceived; + } + return energyReceived; + } + + @Override + public int extractEnergy(int maxExtract, boolean simulate) { + + int energyExtracted = Math.min(energy, Math.min(this.maxExtract, maxExtract)); + + if (!simulate) { + energy -= energyExtracted; + } + return energyExtracted; + } + + @Override + public int getEnergyStored() { + + return energy; + } + + @Override + public int getMaxEnergyStored() { + + return capacity; + } + +} diff --git a/src/thirdparty/java/cofh/api/energy/IEnergyConnection.java b/src/thirdparty/java/cofh/api/energy/IEnergyConnection.java new file mode 100644 index 00000000..29ef0a1c --- /dev/null +++ b/src/thirdparty/java/cofh/api/energy/IEnergyConnection.java @@ -0,0 +1,22 @@ +package cofh.api.energy; + +import net.minecraft.util.EnumFacing; + + +/** + * Implement this interface on TileEntities which should connect to energy transportation blocks. This is intended for blocks which generate energy but do not + * accept it; otherwise just use IEnergyHandler. + *

+ * Note that {@link IEnergyHandler} is an extension of this. + * + * @author King Lemming + * + */ +public interface IEnergyConnection { + + /** + * Returns TRUE if the TileEntity can connect on a given side. + */ + boolean canConnectEnergy(EnumFacing from); + +} diff --git a/src/thirdparty/java/cofh/api/energy/IEnergyContainerItem.java b/src/thirdparty/java/cofh/api/energy/IEnergyContainerItem.java new file mode 100644 index 00000000..3ef72576 --- /dev/null +++ b/src/thirdparty/java/cofh/api/energy/IEnergyContainerItem.java @@ -0,0 +1,52 @@ +package cofh.api.energy; + +import net.minecraft.item.ItemStack; + +/** + * Implement this interface on Item classes that support external manipulation of their internal energy storages. + *

+ * A reference implementation is provided {@link ItemEnergyContainer}. + * + * @author King Lemming + * + */ +public interface IEnergyContainerItem { + + /** + * Adds energy to a container item. Returns the quantity of energy that was accepted. This should always return 0 if the item cannot be externally charged. + * + * @param container + * ItemStack to be charged. + * @param maxReceive + * Maximum amount of energy to be sent into the item. + * @param simulate + * If TRUE, the charge will only be simulated. + * @return Amount of energy that was (or would have been, if simulated) received by the item. + */ + int receiveEnergy(ItemStack container, int maxReceive, boolean simulate); + + /** + * Removes energy from a container item. Returns the quantity of energy that was removed. This should always return 0 if the item cannot be externally + * discharged. + * + * @param container + * ItemStack to be discharged. + * @param maxExtract + * Maximum amount of energy to be extracted from the item. + * @param simulate + * If TRUE, the discharge will only be simulated. + * @return Amount of energy that was (or would have been, if simulated) extracted from the item. + */ + int extractEnergy(ItemStack container, int maxExtract, boolean simulate); + + /** + * Get the amount of energy currently stored in the container item. + */ + int getEnergyStored(ItemStack container); + + /** + * Get the max amount of energy that can be stored in the container item. + */ + int getMaxEnergyStored(ItemStack container); + +} diff --git a/src/thirdparty/java/cofh/api/energy/IEnergyHandler.java b/src/thirdparty/java/cofh/api/energy/IEnergyHandler.java new file mode 100644 index 00000000..16b236e7 --- /dev/null +++ b/src/thirdparty/java/cofh/api/energy/IEnergyHandler.java @@ -0,0 +1,27 @@ +package cofh.api.energy; + +import net.minecraft.util.EnumFacing; + +/** + * Implement this interface on Tile Entities which should handle energy, generally storing it in one or more internal {@link IEnergyStorage} objects. + *

+ * A reference implementation is provided {@link TileEnergyHandler}. + *

+ * Note that {@link IEnergyReceiver} and {@link IEnergyProvider} are extensions of this. + * + * @author King Lemming + * + */ +public interface IEnergyHandler extends IEnergyConnection { + + /** + * Returns the amount of energy currently stored. + */ + int getEnergyStored(EnumFacing from); + + /** + * Returns the maximum amount of energy that can be stored. + */ + int getMaxEnergyStored(EnumFacing from); + +} diff --git a/src/thirdparty/java/cofh/api/energy/IEnergyProvider.java b/src/thirdparty/java/cofh/api/energy/IEnergyProvider.java new file mode 100644 index 00000000..ef0e09d0 --- /dev/null +++ b/src/thirdparty/java/cofh/api/energy/IEnergyProvider.java @@ -0,0 +1,29 @@ +package cofh.api.energy; + +import net.minecraft.util.EnumFacing; + + +/** + * Implement this interface on Tile Entities which should provide energy, generally storing it in one or more internal {@link IEnergyStorage} objects. + *

+ * A reference implementation is provided {@link TileEnergyHandler}. + * + * @author King Lemming + * + */ +public interface IEnergyProvider extends IEnergyHandler { + + /** + * Remove energy from an IEnergyProvider, internal distribution is left entirely to the IEnergyProvider. + * + * @param from + * Orientation the energy is extracted from. + * @param maxExtract + * Maximum amount of energy to extract. + * @param simulate + * If TRUE, the extraction will only be simulated. + * @return Amount of energy that was (or would have been, if simulated) extracted. + */ + int extractEnergy(EnumFacing from, int maxExtract, boolean simulate); + +} diff --git a/src/thirdparty/java/cofh/api/energy/IEnergyReceiver.java b/src/thirdparty/java/cofh/api/energy/IEnergyReceiver.java new file mode 100644 index 00000000..989e9baa --- /dev/null +++ b/src/thirdparty/java/cofh/api/energy/IEnergyReceiver.java @@ -0,0 +1,29 @@ +package cofh.api.energy; + +import net.minecraft.util.EnumFacing; + + +/** + * Implement this interface on Tile Entities which should receive energy, generally storing it in one or more internal {@link IEnergyStorage} objects. + *

+ * A reference implementation is provided {@link TileEnergyHandler}. + * + * @author King Lemming + * + */ +public interface IEnergyReceiver extends IEnergyHandler { + + /** + * Add energy to an IEnergyReceiver, internal distribution is left entirely to the IEnergyReceiver. + * + * @param from + * Orientation the energy is received from. + * @param maxReceive + * Maximum amount of energy to receive. + * @param simulate + * If TRUE, the charge will only be simulated. + * @return Amount of energy that was (or would have been, if simulated) received. + */ + int receiveEnergy(EnumFacing from, int maxReceive, boolean simulate); + +} diff --git a/src/thirdparty/java/cofh/api/energy/IEnergyStorage.java b/src/thirdparty/java/cofh/api/energy/IEnergyStorage.java new file mode 100644 index 00000000..414b2656 --- /dev/null +++ b/src/thirdparty/java/cofh/api/energy/IEnergyStorage.java @@ -0,0 +1,46 @@ +package cofh.api.energy; + +/** + * An energy storage is the unit of interaction with Energy inventories.
+ * This is not to be implemented on TileEntities. This is for internal use only. + *

+ * A reference implementation can be found at {@link EnergyStorage}. + * + * @author King Lemming + * + */ +public interface IEnergyStorage { + + /** + * Adds energy to the storage. Returns quantity of energy that was accepted. + * + * @param maxReceive + * Maximum amount of energy to be inserted. + * @param simulate + * If TRUE, the insertion will only be simulated. + * @return Amount of energy that was (or would have been, if simulated) accepted by the storage. + */ + int receiveEnergy(int maxReceive, boolean simulate); + + /** + * Removes energy from the storage. Returns quantity of energy that was removed. + * + * @param maxExtract + * Maximum amount of energy to be extracted. + * @param simulate + * If TRUE, the extraction will only be simulated. + * @return Amount of energy that was (or would have been, if simulated) extracted from the storage. + */ + int extractEnergy(int maxExtract, boolean simulate); + + /** + * Returns the amount of energy currently stored. + */ + int getEnergyStored(); + + /** + * Returns the maximum amount of energy that can be stored. + */ + int getMaxEnergyStored(); + +} diff --git a/src/thirdparty/java/cofh/api/energy/ItemEnergyContainer.java b/src/thirdparty/java/cofh/api/energy/ItemEnergyContainer.java new file mode 100644 index 00000000..0fb36dab --- /dev/null +++ b/src/thirdparty/java/cofh/api/energy/ItemEnergyContainer.java @@ -0,0 +1,113 @@ +package cofh.api.energy; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; + +/** + * Reference implementation of {@link IEnergyContainerItem}. Use/extend this or implement your own. + * + * @author King Lemming + * + */ +public class ItemEnergyContainer extends Item implements IEnergyContainerItem { + + protected int capacity; + protected int maxReceive; + protected int maxExtract; + + public ItemEnergyContainer() { + + } + + public ItemEnergyContainer(int capacity) { + + this(capacity, capacity, capacity); + } + + public ItemEnergyContainer(int capacity, int maxTransfer) { + + this(capacity, maxTransfer, maxTransfer); + } + + public ItemEnergyContainer(int capacity, int maxReceive, int maxExtract) { + + this.capacity = capacity; + this.maxReceive = maxReceive; + this.maxExtract = maxExtract; + } + + public ItemEnergyContainer setCapacity(int capacity) { + + this.capacity = capacity; + return this; + } + + public ItemEnergyContainer setMaxTransfer(int maxTransfer) { + + setMaxReceive(maxTransfer); + setMaxExtract(maxTransfer); + return this; + } + + public ItemEnergyContainer setMaxReceive(int maxReceive) { + + this.maxReceive = maxReceive; + return this; + } + + public ItemEnergyContainer setMaxExtract(int maxExtract) { + + this.maxExtract = maxExtract; + return this; + } + + /* IEnergyContainerItem */ + @Override + public int receiveEnergy(ItemStack container, int maxReceive, boolean simulate) { + + if (!container.hasTagCompound()) { + container.setTagCompound(new NBTTagCompound()); + } + int energy = container.getTagCompound().getInteger("Energy"); + int energyReceived = Math.min(capacity - energy, Math.min(this.maxReceive, maxReceive)); + + if (!simulate) { + energy += energyReceived; + container.getTagCompound().setInteger("Energy", energy); + } + return energyReceived; + } + + @Override + public int extractEnergy(ItemStack container, int maxExtract, boolean simulate) { + + if (container.getTagCompound() == null || !container.getTagCompound().hasKey("Energy")) { + return 0; + } + int energy = container.getTagCompound().getInteger("Energy"); + int energyExtracted = Math.min(energy, Math.min(this.maxExtract, maxExtract)); + + if (!simulate) { + energy -= energyExtracted; + container.getTagCompound().setInteger("Energy", energy); + } + return energyExtracted; + } + + @Override + public int getEnergyStored(ItemStack container) { + + if (container.getTagCompound() == null || !container.getTagCompound().hasKey("Energy")) { + return 0; + } + return container.getTagCompound().getInteger("Energy"); + } + + @Override + public int getMaxEnergyStored(ItemStack container) { + + return capacity; + } + +} diff --git a/src/thirdparty/java/cofh/api/energy/TileEnergyHandler.java b/src/thirdparty/java/cofh/api/energy/TileEnergyHandler.java new file mode 100644 index 00000000..3cceab21 --- /dev/null +++ b/src/thirdparty/java/cofh/api/energy/TileEnergyHandler.java @@ -0,0 +1,68 @@ +package cofh.api.energy; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumFacing; + +/** + * Reference implementation of {@link IEnergyReceiver} and {@link IEnergyProvider}. Use/extend this or implement your own. + * + * This class is really meant to summarize how each interface is properly used. + * + * @author King Lemming + * + */ +public class TileEnergyHandler extends TileEntity implements IEnergyReceiver, IEnergyProvider { + + protected EnergyStorage storage = new EnergyStorage(32000); + + @Override + public void readFromNBT(NBTTagCompound nbt) { + + super.readFromNBT(nbt); + storage.readFromNBT(nbt); + } + + @Override + public NBTTagCompound writeToNBT(NBTTagCompound nbt) { + + super.writeToNBT(nbt); + storage.writeToNBT(nbt); + return nbt; + } + + /* IEnergyConnection */ + @Override + public boolean canConnectEnergy(EnumFacing from) { + + return true; + } + + /* IEnergyReceiver */ + @Override + public int receiveEnergy(EnumFacing from, int maxReceive, boolean simulate) { + + return storage.receiveEnergy(maxReceive, simulate); + } + + /* IEnergyProvider */ + @Override + public int extractEnergy(EnumFacing from, int maxExtract, boolean simulate) { + + return storage.extractEnergy(maxExtract, simulate); + } + + /* IEnergyHandler */ + @Override + public int getEnergyStored(EnumFacing from) { + + return storage.getEnergyStored(); + } + + @Override + public int getMaxEnergyStored(EnumFacing from) { + + return storage.getMaxEnergyStored(); + } + +} diff --git a/src/thirdparty/java/cofh/api/energy/package-info.java b/src/thirdparty/java/cofh/api/energy/package-info.java new file mode 100644 index 00000000..da856673 --- /dev/null +++ b/src/thirdparty/java/cofh/api/energy/package-info.java @@ -0,0 +1,10 @@ +/** + * (C) 2014-2016 Team CoFH / CoFH / Cult of the Full Hub + * http://www.teamcofh.com + */ +@API(apiVersion = CoFHAPIProps.VERSION, owner = "CoFHAPI", provides = "CoFHAPI|energy") +package cofh.api.energy; + +import net.minecraftforge.fml.common.API; +import cofh.api.CoFHAPIProps; + diff --git a/src/thirdparty/java/cofh/api/package-info.java b/src/thirdparty/java/cofh/api/package-info.java new file mode 100644 index 00000000..e2847daa --- /dev/null +++ b/src/thirdparty/java/cofh/api/package-info.java @@ -0,0 +1,9 @@ +/** + * (C) 2014-2016 Team CoFH / CoFH / Cult of the Full Hub + * http://www.teamcofh.com + */ +@API(apiVersion = CoFHAPIProps.VERSION, owner = "CoFHLib", provides = "CoFHAPI") +package cofh.api; + +import net.minecraftforge.fml.common.API; +