li.cil.oc.api.network

Interface Environment

All Known Subinterfaces:

Machine, ManagedEnvironment

All Known Implementing Classes:

ManagedEnvironment, TileEntityEnvironment

public interface Environment

The environment of a node.

For blocks/tile entities this will usually be the tile entity. For items this will usually be an object created when a component is added to a compatible inventory (e.g. put into a computer).

Tile entities should implement this interface if they want to be connected to the component network of their neighboring blocks. If you cannot do that, as mentioned above, you will have to provide a driver that creates a managed environment for the block you wish to connect instead.

To get some more control over which sides of your block may connect to a network, see SidedEnvironment.

When a tile entity implements this interface a good way of connecting and disconnecting is the following pattern:

     void updateEntity() {
         super.updateEntity()
         if (node != null && node.network == null) {
             api.Network.joinOrCreateNetwork(this);
         }
     }

     void onChunkUnload() {
         super.onChunkUnload()
         if (node != null) node.remove()
     }

     void invalidate() {
         super.invalidate()
         if (node != null) node.remove()
     }
 

Item environments are always managed, so you will always have to provide a driver for items that should interact with the component network.

To interact with environments from user code you will have to do two things:

1. Make the environment's node() a Component and ensure its Component.visibility() is set to a value where it can be seen by computers in the network.
2. Annotate methods in the environment as Callbacks.

Method Summary

Methods

Modifier and Type	Method and Description
Node	node() The node this environment wraps.
void	onConnect(Node node) This is called when a node is added to a network.
void	onDisconnect(Node node) This is called when a node is removed from the network.
void	onMessage(Message message) This is the generic message handler.

Method Detail

node

Node node()

The node this environment wraps.

The node is the environments gateway to the component network, and thus its preferred way to interact with other components in the same network.

Returns:

the node this environment wraps.

onConnect

void onConnect(Node node)

This is called when a node is added to a network.

This is also called for the node itself, if it was added to the network.

At this point the node's network is never null and you can use it to query it for other nodes. Use this to perform initialization logic, such as building lists of nodes of a certain type in the network.

For example, if node C is added to a network with nodes A and B, these calls are made:

• A.onConnect(A)
• A.onConnect(B)
• A.onConnect(C)
• B.onConnect(A)
• C.onConnect(A)

onDisconnect

void onDisconnect(Node node)

This is called when a node is removed from the network.

This is also called for the node itself, when it has been removed from its network. Note that this is called on the node that is being removed only once with the node itself as the parameter.

At this point the node's network is no longer available (null). Use this to perform clean-up logic such as removing references to the removed node.

For example, if node C is removed from a network with nodes A, B and C, these calls are made:

• A.onDisconnect(A)
• B.onDisconnect(A)
• C.onDisconnect(A)

onMessage

void onMessage(Message message)

This is the generic message handler.

It is called whenever this environments Node receives a message that was sent via one of the send methods in the Network or the Node itself.

Parameters:

message - the message to handle.