From f2bb532f659290c3e4b8742d9458ac058fba2606 Mon Sep 17 00:00:00 2001 From: Timo Ley Date: Wed, 7 Apr 2021 22:24:08 +0200 Subject: [PATCH] Added RF to Battery --- src/main/scala/cofh/api/CoFHAPIProps.java | 11 ++ .../scala/cofh/api/energy/EnergyStorage.java | 158 ++++++++++++++++++ .../cofh/api/energy/IEnergyConnection.java | 21 +++ .../cofh/api/energy/IEnergyContainerItem.java | 52 ++++++ .../scala/cofh/api/energy/IEnergyHandler.java | 57 +++++++ .../cofh/api/energy/IEnergyProvider.java | 38 +++++ .../cofh/api/energy/IEnergyReceiver.java | 38 +++++ .../scala/cofh/api/energy/IEnergyStorage.java | 46 +++++ .../cofh/api/energy/IEnergyTransport.java | 109 ++++++++++++ .../cofh/api/energy/ItemEnergyContainer.java | 110 ++++++++++++ .../cofh/api/energy/TileEnergyHandler.java | 65 +++++++ .../scala/cofh/api/energy/package-info.java | 10 ++ src/main/scala/cofh/api/package-info.java | 9 + .../circuit/source/battery/TileBattery.scala | 47 +++++- 14 files changed, 770 insertions(+), 1 deletion(-) create mode 100644 src/main/scala/cofh/api/CoFHAPIProps.java create mode 100644 src/main/scala/cofh/api/energy/EnergyStorage.java create mode 100644 src/main/scala/cofh/api/energy/IEnergyConnection.java create mode 100644 src/main/scala/cofh/api/energy/IEnergyContainerItem.java create mode 100644 src/main/scala/cofh/api/energy/IEnergyHandler.java create mode 100644 src/main/scala/cofh/api/energy/IEnergyProvider.java create mode 100644 src/main/scala/cofh/api/energy/IEnergyReceiver.java create mode 100644 src/main/scala/cofh/api/energy/IEnergyStorage.java create mode 100644 src/main/scala/cofh/api/energy/IEnergyTransport.java create mode 100644 src/main/scala/cofh/api/energy/ItemEnergyContainer.java create mode 100644 src/main/scala/cofh/api/energy/TileEnergyHandler.java create mode 100644 src/main/scala/cofh/api/energy/package-info.java create mode 100644 src/main/scala/cofh/api/package-info.java diff --git a/src/main/scala/cofh/api/CoFHAPIProps.java b/src/main/scala/cofh/api/CoFHAPIProps.java new file mode 100644 index 000000000..5d21f6369 --- /dev/null +++ b/src/main/scala/cofh/api/CoFHAPIProps.java @@ -0,0 +1,11 @@ +package cofh.api; + +public class CoFHAPIProps { + + private CoFHAPIProps() { + + } + + public static final String VERSION = "1.7.10R1.3.1"; + +} diff --git a/src/main/scala/cofh/api/energy/EnergyStorage.java b/src/main/scala/cofh/api/energy/EnergyStorage.java new file mode 100644 index 000000000..25e0126ab --- /dev/null +++ b/src/main/scala/cofh/api/energy/EnergyStorage.java @@ -0,0 +1,158 @@ +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 void setCapacity(int capacity) { + + this.capacity = capacity; + + if (energy > capacity) { + energy = capacity; + } + } + + public void setMaxTransfer(int maxTransfer) { + + setMaxReceive(maxTransfer); + setMaxExtract(maxTransfer); + } + + public void setMaxReceive(int maxReceive) { + + this.maxReceive = maxReceive; + } + + public void setMaxExtract(int maxExtract) { + + this.maxExtract = maxExtract; + } + + public int getMaxReceive() { + + return maxReceive; + } + + public int getMaxExtract() { + + return maxExtract; + } + + /** + * This function is included to allow for server -> 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/main/scala/cofh/api/energy/IEnergyConnection.java b/src/main/scala/cofh/api/energy/IEnergyConnection.java new file mode 100644 index 000000000..301271e5a --- /dev/null +++ b/src/main/scala/cofh/api/energy/IEnergyConnection.java @@ -0,0 +1,21 @@ +package cofh.api.energy; + +import net.minecraftforge.common.util.ForgeDirection; + +/** + * 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(ForgeDirection from); + +} diff --git a/src/main/scala/cofh/api/energy/IEnergyContainerItem.java b/src/main/scala/cofh/api/energy/IEnergyContainerItem.java new file mode 100644 index 000000000..3ef725765 --- /dev/null +++ b/src/main/scala/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/main/scala/cofh/api/energy/IEnergyHandler.java b/src/main/scala/cofh/api/energy/IEnergyHandler.java new file mode 100644 index 000000000..6a4600a4e --- /dev/null +++ b/src/main/scala/cofh/api/energy/IEnergyHandler.java @@ -0,0 +1,57 @@ +package cofh.api.energy; + +import net.minecraftforge.common.util.ForgeDirection; + +/** + * 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}. + * + * @author King Lemming + * + */ +public interface IEnergyHandler extends IEnergyProvider, IEnergyReceiver { + + // merely a convenience interface (remove these methods in 1.8; provided here for back-compat via compiler doing things) + + /** + * 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. + */ + @Override + int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate); + + /** + * 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. + */ + @Override + int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate); + + /** + * Returns the amount of energy currently stored. + */ + @Override + int getEnergyStored(ForgeDirection from); + + /** + * Returns the maximum amount of energy that can be stored. + */ + @Override + int getMaxEnergyStored(ForgeDirection from); + +} diff --git a/src/main/scala/cofh/api/energy/IEnergyProvider.java b/src/main/scala/cofh/api/energy/IEnergyProvider.java new file mode 100644 index 000000000..05287b35e --- /dev/null +++ b/src/main/scala/cofh/api/energy/IEnergyProvider.java @@ -0,0 +1,38 @@ +package cofh.api.energy; + +import net.minecraftforge.common.util.ForgeDirection; + +/** + * 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 IEnergyConnection { + + /** + * 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(ForgeDirection from, int maxExtract, boolean simulate); + + /** + * Returns the amount of energy currently stored. + */ + int getEnergyStored(ForgeDirection from); + + /** + * Returns the maximum amount of energy that can be stored. + */ + int getMaxEnergyStored(ForgeDirection from); + +} diff --git a/src/main/scala/cofh/api/energy/IEnergyReceiver.java b/src/main/scala/cofh/api/energy/IEnergyReceiver.java new file mode 100644 index 000000000..c726e09e0 --- /dev/null +++ b/src/main/scala/cofh/api/energy/IEnergyReceiver.java @@ -0,0 +1,38 @@ +package cofh.api.energy; + +import net.minecraftforge.common.util.ForgeDirection; + +/** + * 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 IEnergyConnection { + + /** + * 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(ForgeDirection from, int maxReceive, boolean simulate); + + /** + * Returns the amount of energy currently stored. + */ + int getEnergyStored(ForgeDirection from); + + /** + * Returns the maximum amount of energy that can be stored. + */ + int getMaxEnergyStored(ForgeDirection from); + +} diff --git a/src/main/scala/cofh/api/energy/IEnergyStorage.java b/src/main/scala/cofh/api/energy/IEnergyStorage.java new file mode 100644 index 000000000..414b26566 --- /dev/null +++ b/src/main/scala/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/main/scala/cofh/api/energy/IEnergyTransport.java b/src/main/scala/cofh/api/energy/IEnergyTransport.java new file mode 100644 index 000000000..ab45e04fe --- /dev/null +++ b/src/main/scala/cofh/api/energy/IEnergyTransport.java @@ -0,0 +1,109 @@ +package cofh.api.energy; + +import net.minecraftforge.common.util.ForgeDirection; + +/** + * Implement this interface on Tile Entities which transport energy. + *

+ * This is used to "negotiate" connection types between two separate IEnergyTransports, allowing users to set flow direction and allowing for networks Of + * IEnergyTransports to intelligently transfer energy to other networks. + */ +public interface IEnergyTransport extends IEnergyProvider, IEnergyReceiver { + + /** + * The type of interface for a given side of a {@link IEnergyTransport}. + *

+ * Values are:
+ * {@link SEND} for sending only
+ * {@link RECEIVE} for receiving only
+ * {@link BALANCE} for sending and receiving, and the default state + */ + public enum InterfaceType { + /** + * Indicates that this {@link IEnergyTransport} is only sending power on this side. + */ + SEND, + /** + * Indicates that this {@link IEnergyTransport} is only receiving power on this side. + */ + RECEIVE, + /** + * Indicates that this {@link IEnergyTransport} wants to balance power between itself and the + * senders/receivers on this side. This is the default state.
+ * To block any connection, use {@link IEnergyConnection#canConnectEnergy} + *

+ * IEnergyTransport based senders should check that the total power in the destination IEnergyTransport is less than the power in themselves before sending. + *
+ * Active IEnergyTransport receivers (i.e., those that call {@link IEnergyProvider#extractEnergy}) should check that they contain less power than the + * source IEnergyTransport. + */ + BALANCE; + + /** + * Returns the opposite state to this InterfaceType. + *

+ * {@link #BALANCE} is considered its own opposite.
+ * {@link #SEND} is the opposite of {@link #RECEIVE} and visa versa. + */ + public InterfaceType getOpposite() { + + return this == BALANCE ? BALANCE : this == SEND ? RECEIVE : SEND; + } + + /** + * Returns the next InterfaceType as described in {@link IEnergyTransport#getTransportState} + */ + public InterfaceType rotate() { + + return rotate(true); + } + + /** + * Returns the next InterfaceType as described in {@link IEnergyTransport#getTransportState} + * + * @param forward + * Whether to step in the order specified by {@link IEnergyTransport#getTransportState} (true) or to step in the opposite direction + */ + public InterfaceType rotate(boolean forward) { + + if (forward) { + return this == BALANCE ? RECEIVE : this == RECEIVE ? SEND : BALANCE; + } else { + return this == BALANCE ? SEND : this == SEND ? RECEIVE : BALANCE; + } + } + } + + /** + * {@inheritDoc}
+ * This method cannot be a no-op for IEnergyTransport. + */ + @Override + int getEnergyStored(ForgeDirection from); + + /** + * Indicates to other IEnergyTransports the state of the given side. See {@link #InterfaceType} for details. + *

+ * For clarity of state tracking, on a tile update from another IEnergyTransport, if its mode has changed from the opposite of your own mode on that side, you + * should change your mode to the opposite of its mode. + *

+ * When the user alters your mode and your state is:
+ * BALANCE, your mode should change to {@link InterFaceType#RECEIVE}.
+ * RECEIVE, your mode should change to {@link InterFaceType#SEND}.
+ * SEND, your mode should change to {@link InterFaceType#BALANCE}.
+ * This is not required, but will be easier for users. + * + * @return The type of connection to establish on this side. null is NOT a valid value + */ + InterfaceType getTransportState(ForgeDirection from); + + /** + * This method is provided primarily for the purposes of automation tools, and should not need to be called by another IEnergyTransport. + *

+ * Calls to this method may fail if this IEnergyTransport has been secured by a user. + * + * @return Whether or not state was successfully altered. + */ + boolean setTransportState(InterfaceType state, ForgeDirection from); + +} diff --git a/src/main/scala/cofh/api/energy/ItemEnergyContainer.java b/src/main/scala/cofh/api/energy/ItemEnergyContainer.java new file mode 100644 index 000000000..2d3659cb6 --- /dev/null +++ b/src/main/scala/cofh/api/energy/ItemEnergyContainer.java @@ -0,0 +1,110 @@ +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 void setMaxTransfer(int maxTransfer) { + + setMaxReceive(maxTransfer); + setMaxExtract(maxTransfer); + } + + public void setMaxReceive(int maxReceive) { + + this.maxReceive = maxReceive; + } + + public void setMaxExtract(int maxExtract) { + + this.maxExtract = maxExtract; + } + + /* IEnergyContainerItem */ + @Override + public int receiveEnergy(ItemStack container, int maxReceive, boolean simulate) { + + if (container.stackTagCompound == null) { + container.stackTagCompound = new NBTTagCompound(); + } + int energy = container.stackTagCompound.getInteger("Energy"); + int energyReceived = Math.min(capacity - energy, Math.min(this.maxReceive, maxReceive)); + + if (!simulate) { + energy += energyReceived; + container.stackTagCompound.setInteger("Energy", energy); + } + return energyReceived; + } + + @Override + public int extractEnergy(ItemStack container, int maxExtract, boolean simulate) { + + if (container.stackTagCompound == null || !container.stackTagCompound.hasKey("Energy")) { + return 0; + } + int energy = container.stackTagCompound.getInteger("Energy"); + int energyExtracted = Math.min(energy, Math.min(this.maxExtract, maxExtract)); + + if (!simulate) { + energy -= energyExtracted; + container.stackTagCompound.setInteger("Energy", energy); + } + return energyExtracted; + } + + @Override + public int getEnergyStored(ItemStack container) { + + if (container.stackTagCompound == null || !container.stackTagCompound.hasKey("Energy")) { + return 0; + } + return container.stackTagCompound.getInteger("Energy"); + } + + @Override + public int getMaxEnergyStored(ItemStack container) { + + return capacity; + } + +} diff --git a/src/main/scala/cofh/api/energy/TileEnergyHandler.java b/src/main/scala/cofh/api/energy/TileEnergyHandler.java new file mode 100644 index 000000000..7cc655e92 --- /dev/null +++ b/src/main/scala/cofh/api/energy/TileEnergyHandler.java @@ -0,0 +1,65 @@ +package cofh.api.energy; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; + +/** + * Reference implementation of {@link IEnergyHandler}. Use/extend this or implement your own. + * + * @author King Lemming + * + */ +public class TileEnergyHandler extends TileEntity implements IEnergyHandler { + + protected EnergyStorage storage = new EnergyStorage(32000); + + @Override + public void readFromNBT(NBTTagCompound nbt) { + + super.readFromNBT(nbt); + storage.readFromNBT(nbt); + } + + @Override + public void writeToNBT(NBTTagCompound nbt) { + + super.writeToNBT(nbt); + storage.writeToNBT(nbt); + } + + /* IEnergyConnection */ + @Override + public boolean canConnectEnergy(ForgeDirection from) { + + return true; + } + + /* IEnergyReceiver */ + @Override + public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { + + return storage.receiveEnergy(maxReceive, simulate); + } + + /* IEnergyProvider */ + @Override + public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) { + + return storage.extractEnergy(maxExtract, simulate); + } + + /* IEnergyReceiver and IEnergyProvider */ + @Override + public int getEnergyStored(ForgeDirection from) { + + return storage.getEnergyStored(); + } + + @Override + public int getMaxEnergyStored(ForgeDirection from) { + + return storage.getMaxEnergyStored(); + } + +} diff --git a/src/main/scala/cofh/api/energy/package-info.java b/src/main/scala/cofh/api/energy/package-info.java new file mode 100644 index 000000000..7379702b8 --- /dev/null +++ b/src/main/scala/cofh/api/energy/package-info.java @@ -0,0 +1,10 @@ +/** + * (C) 2014 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 cofh.api.CoFHAPIProps; +import cpw.mods.fml.common.API; + diff --git a/src/main/scala/cofh/api/package-info.java b/src/main/scala/cofh/api/package-info.java new file mode 100644 index 000000000..08ff5fcb6 --- /dev/null +++ b/src/main/scala/cofh/api/package-info.java @@ -0,0 +1,9 @@ +/** + * (C) 2014 Team CoFH / CoFH / Cult of the Full Hub + * http://www.teamcofh.com + */ +@API(apiVersion = CoFHAPIProps.VERSION, owner = "CoFHLib", provides = "CoFHAPI") +package cofh.api; + +import cpw.mods.fml.common.API; + diff --git a/src/main/scala/edx/electrical/circuit/source/battery/TileBattery.scala b/src/main/scala/edx/electrical/circuit/source/battery/TileBattery.scala index 9830044d2..4fd004a18 100644 --- a/src/main/scala/edx/electrical/circuit/source/battery/TileBattery.scala +++ b/src/main/scala/edx/electrical/circuit/source/battery/TileBattery.scala @@ -2,6 +2,7 @@ package edx.electrical.circuit.source.battery import java.util.ArrayList +import cofh.api.energy.{IEnergyHandler, IEnergyReceiver} import cpw.mods.fml.relauncher.{Side, SideOnly} import edx.core.Reference import edx.electrical.Models @@ -43,7 +44,7 @@ object TileBattery def getEnergyForTier(tier: Int) = Math.round(Math.pow(500000000, (tier / (maxTier + 0.7f)) + 1) / 500000000) * 500000000 } -class TileBattery extends ResonantTile(Material.iron) with TIO with TBlockNodeProvider with TPacketSender with TPacketReceiver with TEnergyProvider with ISimpleItemRenderer +class TileBattery extends ResonantTile(Material.iron) with TIO with TBlockNodeProvider with TPacketSender with TPacketReceiver with TEnergyProvider with ISimpleItemRenderer with IEnergyHandler { private val electricNode = new NodeElectricComponent(this) var energyRenderLevel = 0 @@ -84,6 +85,18 @@ class TileBattery extends ResonantTile(Material.iron) with TIO with TBlockNodePr energy += electricNode.power / 20 } + for (side <- ForgeDirection.VALID_DIRECTIONS) { + if (getOutputDirections().contains(side)) { + val tile = worldObj.getTileEntity(xCoord + side.offsetX, yCoord + side.offsetY, zCoord + side.offsetZ) + if (tile != null && tile.isInstanceOf[IEnergyReceiver]) { + val rec = tile.asInstanceOf[IEnergyReceiver] + val received = Math.min(rec.receiveEnergy(side.getOpposite, (energy.value / 50).asInstanceOf[Int], true), (energy.value / 50).asInstanceOf[Int]) + energy -= (received * 50) + rec.receiveEnergy(side.getOpposite, received, false) + } + } + } + if (energy.prev != energy.value) { @@ -274,4 +287,36 @@ class TileBattery extends ResonantTile(Material.iron) with TIO with TBlockNodePr super.writeToNBT(nbt) energy.save(nbt) } + + override def receiveEnergy(side: ForgeDirection, i: Int, b: Boolean): Int = { + val joule: Double = i * 50 + val maxReceive = Math.min(joule, energy.max - energy.value) + if (!b) { + energy.setValue(energy.value + maxReceive) + markUpdate() + } + return (maxReceive / 50).asInstanceOf[Int] + } + + override def extractEnergy(side: ForgeDirection, i: Int, b: Boolean): Int = { + val joule: Double = i * 50 + val maxExtract = Math.min(joule, energy.value) + if (!b) { + energy.setValue(energy.value - maxExtract) + markUpdate() + } + return (maxExtract / 50).asInstanceOf[Int] + } + + override def getEnergyStored(side: ForgeDirection): Int = { + (energy.value / 50).asInstanceOf[Int] + } + + override def getMaxEnergyStored(side: ForgeDirection): Int = { + (energy.max / 50).asInstanceOf[Int] + } + + override def canConnectEnergy(side: ForgeDirection): Boolean = { + getOutputDirections().contains(side) || getInputDirections().contains(side) + } }