AbstractModule (TIS-3D MC1.13-Rift-1.5.0.21 API)

java.lang.Object
- li.cil.tis3d.api.prefab.module.AbstractModule

All Implemented Interfaces:

Module

Direct Known Subclasses:

AbstractModuleRotatable, ModuleAudio, ModuleInfrared, ModuleRandom, ModuleSerialPort
```
public abstract class AbstractModule
extends java.lang.Object
implements Module
```
Base implementation of a module, taking care of the boilerplate code.

Constructor Summary

Constructors
Modifier Constructor and Description

protected AbstractModule(Casing casing, Face face)

Constructors
Modifier	Constructor and Description
`protected`	`AbstractModule(Casing casing, Face face)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`cancelRead()` Cancel reading on all ports.
`protected void`	`cancelWrite()` Cancel writing on all ports.
`Casing`	`getCasing()` The `Casing` the `Module` is installed in.
`Face`	`getFace()` The `Face` the `Module` is installed on in its `Casing`.
`protected net.minecraft.util.math.Vec3d`	`getObserverLookAt(net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher rendererDispatcher)` Utility method for determining the hit coordinate on the module's face the player is looking at.
`protected net.minecraft.util.math.Vec3d`	`hitToUV(net.minecraft.util.math.Vec3d hitPos)` Project a hit position on the surface of a casing to a UV coordinate on the face of this module.
`protected boolean`	`isObserverLookingAt(net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher rendererDispatcher)` Utility method for determining whether the player is currently looking at this module.
`protected boolean`	`isVisible()` Convenience check for determining whether a module is actually visible.
`boolean`	`onActivate(net.minecraft.entity.player.EntityPlayer player, net.minecraft.util.EnumHand hand, float hitX, float hitY, float hitZ)` Called when a player right-clicks the module while installed in a casing.
`void`	`onBeforeWriteComplete(Port port)` Called from a pipe this module is writing to when the data is being read.
`void`	`onData(io.netty.buffer.ByteBuf data)` Called with data sent from the remote instance of the module.
`void`	`onData(net.minecraft.nbt.NBTTagCompound nbt)` Called with NBT data sent from the remote instance of the module.
`void`	`onDisabled()` Called when the multi-block of casings the module is installed in is disabled, or when the module was removed from an enabled casing.
`void`	`onDisposed()` Called when the `Casing` housing the module is being disposed, e.g.
`void`	`onEnabled()` Called when the multi-block of casings the module is installed in is enabled, or when the module was installed into an enabled casing.
`void`	`onInstalled(net.minecraft.item.ItemStack stack)` Called when the module is being installed into a `Casing`.
`void`	`onUninstalled(net.minecraft.item.ItemStack stack)` Called after the module was uninstalled from a `Casing`.
`void`	`onWriteComplete(Port port)` Called from a pipe this module is writing to when the data was read.
`void`	`readFromNBT(net.minecraft.nbt.NBTTagCompound nbt)` Restore the state of the module from the specified NBT compound.
`void`	`render(net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher rendererDispatcher, float partialTicks)` Called to allow the module to render dynamic content on the casing it is installed in.
`void`	`step()` Advance the state of the module.
`void`	`writeToNBT(net.minecraft.nbt.NBTTagCompound nbt)` Save the state of the module to the specified NBT compound.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - AbstractModule
```
protected AbstractModule(Casing casing,
                         Face face)
```
- Method Detail
  - cancelWrite
```
protected void cancelWrite()
```
    Cancel writing on all ports.
  - cancelRead
```
protected void cancelRead()
```
    Cancel reading on all ports.
  - isObserverLookingAt
```
protected boolean isObserverLookingAt(net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher rendererDispatcher)
```
    Utility method for determining whether the player is currently looking at this module.
    
    Returns:
    
    true if the player is looking at the module, false otherwise.
  - getObserverLookAt
```
@Nullable
protected net.minecraft.util.math.Vec3d getObserverLookAt(net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher rendererDispatcher)
```
    Utility method for determining the hit coordinate on the module's face the player is looking at. This will return null if the player is not currently looking at the module.
    Note that this will return the unadjusted X, Y and Z components. To transform this coordinate to a UV coordinate mapped to the module's face, pass this into hitToUV(net.minecraft.util.math.Vec3d). Note that this method is overridden in AbstractModuleRotatable to also take into account the module's rotation.
    
    Returns:
    
    the UV coordinate the player is looking at as the X and Y components.
  - hitToUV
```
protected net.minecraft.util.math.Vec3d hitToUV(net.minecraft.util.math.Vec3d hitPos)
```
    Project a hit position on the surface of a casing to a UV coordinate on the face of this module.
    Note that this is also overridden in AbstractModuleRotatable to take into account the module's rotation.
    
    Parameters:
    
    hitPos - the hit position to project.
    
    Returns:
    
    the projected UV coordinate, with the Z component being 0.
    
    See Also:
    
    getObserverLookAt(TileEntityRendererDispatcher), Module.onActivate(EntityPlayer, EnumHand, float, float, float)
  - isVisible
```
protected boolean isVisible()
```
    Convenience check for determining whether a module is actually visible.
    This can allow for some optimizations, such as sending state updates much more or infrequently (or not at all) while invisible. If rendering a module's overlay is exceptionally complex,
    
    Returns:
    
    whether the module is currently visible.
  - getCasing
```
public Casing getCasing()
```
    Description copied from interface: Module
    
    The Casing the Module is installed in.
    
    Specified by:
    
    getCasing in interface Module
    
    Returns:
    
    the casing the module is installed in.
  - getFace
```
public Face getFace()
```
    Description copied from interface: Module
    
    The Face the Module is installed on in its Casing.
    
    Specified by:
    
    getFace in interface Module
    
    Returns:
    
    the face the module is installed on.
  - step
```
public void step()
```
    Description copied from interface: Module
    
    Advance the state of the module.
    This is called by the controller of the system the module is part of each tick the system is running.
    
    Specified by:
    
    step in interface Module
  - onInstalled
```
public void onInstalled(net.minecraft.item.ItemStack stack)
```
    Description copied from interface: Module
    
    Called when the module is being installed into a Casing.
    This is mainly for convenience and having things in one place, you could just as well restore state in your ModuleProvider's ModuleProvider.createModule(ItemStack, Casing, Face) method.
    This is called before the first Module.onEnabled(), and also before it is actually set in the containing Casing. Particularly this means Casing.getModule(Face) for the module's Face will return null in this callback.
    Note that this is only called on the server.
    
    Specified by:
    
    onInstalled in interface Module
    
    Parameters:
    
    stack - the item stack the module was created from.
  - onUninstalled
```
public void onUninstalled(net.minecraft.item.ItemStack stack)
```
    Description copied from interface: Module
    
    Called after the module was uninstalled from a Casing.
    This allows storing any data that should be persisted onto the module's item representation. For most modules this will not apply, since they are generally stateless / reset state when the computer shuts down.
    This is called after the last Module.onDisabled() and is equivalent to a dispose method (i.e. the module will not be used again after this).
    Note that this is only called on the server.
    
    Specified by:
    
    onUninstalled in interface Module
    
    Parameters:
    
    stack - the stack representing the module.
  - onEnabled
```
public void onEnabled()
```
    Description copied from interface: Module
    
    Called when the multi-block of casings the module is installed in is enabled, or when the module was installed into an enabled casing.
    Note that this is only called on the server.
    
    Specified by:
    
    onEnabled in interface Module
  - onDisabled
```
public void onDisabled()
```
    Description copied from interface: Module
    
    Called when the multi-block of casings the module is installed in is disabled, or when the module was removed from an enabled casing.
    Modules should use this to reset their state, so that cycling power of a controller resets the whole multi-block system.
    Note that this is only called on the server.
    
    Specified by:
    
    onDisabled in interface Module
  - onDisposed
```
public void onDisposed()
```
    Description copied from interface: Module
    
    Called when the Casing housing the module is being disposed, e.g. due to a chunk being unloaded.
    This is intended for freeing up resources (e.g. allocated texture or audio memory). Unlike Module.onDisabled() this is only called once on a module, at the very end of its life. Avoid world interaction in this callback to avoid loading the chunk again.
    This is called on the server and the client.
    
    Specified by:
    
    onDisposed in interface Module
  - onBeforeWriteComplete
```
public void onBeforeWriteComplete(Port port)
```
    Description copied from interface: Module
    
    Called from a pipe this module is writing to when the data is being read.
    The key difference to Module.onWriteComplete(Port) is that this is called directly during the read operation, so this may be called before or after the module's Module.step() for the current cycle. As such, no operations which might influence number of required cycles for the current transfer operation should be performed in this method. It may be used to cancel other write operations to write a value only once, for example, or to update some other internal state before a read operation completes (used by the stack module for example, to ensure the correct value is being popped).
    
    Specified by:
    
    onBeforeWriteComplete in interface Module
    
    Parameters:
    
    port - the port on which the write operation will be completed.
  - onWriteComplete
```
public void onWriteComplete(Port port)
```
    Description copied from interface: Module
    
    Called from a pipe this module is writing to when the data was read.
    This allows completing the operation in the same tick in which the read operation was completed. This is particularly useful when writing to multiple ports at a time but the written value may only be read once; in this case the remaining writes can be canceled in this callback.
    
    Specified by:
    
    onWriteComplete in interface Module
    
    Parameters:
    
    port - the port on which the write operation was completed.
  - onActivate
```
public boolean onActivate(net.minecraft.entity.player.EntityPlayer player,
                          net.minecraft.util.EnumHand hand,
                          float hitX,
                          float hitY,
                          float hitZ)
```
    Description copied from interface: Module
    
    Called when a player right-clicks the module while installed in a casing.
    The face is implicitly given by the face the module is installed in, as is the world via the casing's world.
    Note that there should be some way in which a click can be ignored, e.g. by a player sneaking, otherwise the module cannot be removed from the casing by hand.
    
    Specified by:
    
    onActivate in interface Module
    
    Parameters:
    
    player - the player that clicked the module.
    
    hand - the hand the player used to activate the module.
    
    hitX - the relative x position that was clicked.
    
    hitY - the relative y position that was clicked.
    
    hitZ - the relative z position that was clicked.
    
    Returns:
    
    true if the click was handled, false otherwise.
  - onData
```
public void onData(net.minecraft.nbt.NBTTagCompound nbt)
```
    Description copied from interface: Module
    
    Called with NBT data sent from the remote instance of the module.
    This can be called on both the server and the client, depending on which side sent the message (i.e. the client can send messages to the server this way and vice versa).
    
    Specified by:
    
    onData in interface Module
    
    Parameters:
    
    nbt - the received data.
    
    See Also:
    
    Casing.sendData(Face, NBTTagCompound, byte), Casing.sendData(Face, NBTTagCompound)
  - onData
```
public void onData(io.netty.buffer.ByteBuf data)
```
    Description copied from interface: Module
    
    Called with data sent from the remote instance of the module.
    This can be called on both the server and the client, depending on which side sent the message (i.e. the client can send messages to the server this way and vice versa).
    
    Specified by:
    
    onData in interface Module
    
    Parameters:
    
    data - the received data.
    
    See Also:
    
    Casing.sendData(Face, ByteBuf, byte), Casing.sendData(Face, ByteBuf)
  - render
```
public void render(net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher rendererDispatcher,
                   float partialTicks)
```
    Description copied from interface: Module
    
    Called to allow the module to render dynamic content on the casing it is installed in.
    The render state will be adjusted to take into account the face the module is installed in, i.e. rendering from (0, 0, 0) to (1, 1, 0) will render the full quad of face of the casing the module is installed in.
    Note that the enabled is the same as Casing.isEnabled(), it is merely passed along for backwards compatibility from before the time that getter existed.
    
    Specified by:
    
    render in interface Module
    
    Parameters:
    
    rendererDispatcher - the render context of the tile entity the module sits in.
    
    partialTicks - the partial time elapsed in this tick.
  - readFromNBT
```
public void readFromNBT(net.minecraft.nbt.NBTTagCompound nbt)
```
    Description copied from interface: Module
    
    Restore the state of the module from the specified NBT compound.
    
    Specified by:
    
    readFromNBT in interface Module
    
    Parameters:
    
    nbt - the tag to load the state from.
  - writeToNBT
```
public void writeToNBT(net.minecraft.nbt.NBTTagCompound nbt)
```
    Description copied from interface: Module
    
    Save the state of the module to the specified NBT compound.
    
    Specified by:
    
    writeToNBT in interface Module
    
    Parameters:
    
    nbt - the tag to save the state to.

Class AbstractModule

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

AbstractModule

Method Detail

cancelWrite

cancelRead

isObserverLookingAt

getObserverLookAt

hitToUV

isVisible

getCasing

getFace

step

onInstalled

onUninstalled

onEnabled

onDisabled

onDisposed

onBeforeWriteComplete

onWriteComplete

onActivate

onData

onData

render

readFromNBT

writeToNBT