package cofh.api.energy;
import net.minecraft.util.EnumFacing;
/**
* 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:<br>
* {@link SEND} for sending only<br>
* {@link RECEIVE} for receiving only<br>
* {@link BALANCE} for sending and receiving, and the default state
*/
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.<br>
* 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.
* <br>
* 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.<br>
* {@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} (<tt>true</tt>) 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}<br>
* This method <b>cannot</b> be a no-op for IEnergyTransport.
*/
@Override
int getEnergyStored(EnumFacing 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:<br>
* BALANCE, your mode should change to {@link InterFaceType#RECEIVE}.<br>
* RECEIVE, your mode should change to {@link InterFaceType#SEND}.<br>
* SEND, your mode should change to {@link InterFaceType#BALANCE}.<br>
* This is not required, but will be easier for users.
*
* @return The type of connection to establish on this side. <b>null is NOT a valid value</b>
*/
InterfaceType getTransportState(EnumFacing 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, EnumFacing from);
}