blob: 600ffe5fd369a1d2f358b98567d64b7416396c32 [file] [log] [blame] [raw]
package li.cil.oc.api.driver
import li.cil.oc.api.Driver
import li.cil.oc.api.network.Node
import net.minecraft.item.ItemStack
import net.minecraft.nbt.NBTTagCompound
/**
* Interface for item component drivers.
* <p/>
* This driver type is used for components that are items, i.e. that can be
* inserted into computers. An example for this are internal drives, memory and
* power supply units.
* <p/>
* When trying to add an item to a computer the list of registered drivers is
* queried using the drivers' `worksWith` functions. The first driver that
* replies positively and whose check against the slot type is successful, i.e.
* for which the `slot` matches the slot it should be inserted into, will be
* used as the component's driver and the component will be added. If no driver
* is found the item will be rejected and cannot be installed.
* <p/>
* Note that it is possible to write one driver that supports as many different
* items as you wish. I'd recommend writing one per device (type), though, to
* keep things modular.
*/
trait Item extends Driver {
/**
* Used to determine the item types this driver handles.
* <p/>
* This is used to determine which driver to use for an item when installed in
* a computer. Note that the return value should not change over time; if it
* does, though, an already installed component will not be ejected, since
* this value is only checked when adding components.
*
* @param item the item to check.
* @return true if the item is supported; false otherwise.
*/
def worksWith(item: ItemStack): Boolean
/**
* The slot type of the specified item this driver supports.
* <p/>
* This is used to determine into which slot of a computer the components this
* driver supports may go. This will only be called if a previous call to
* `worksWith` with the same item type returned true.
*
* @return the component type of the specified item.
*/
def slot(item: ItemStack): Slot.Value
/**
* Gets a reference to the network node interfacing the specified item.
* <p/>
* This is used to connect the component to the component network when it is
* added to a computer, for example. Components that are not part of the
* component network probably don't make much sense (can't think of any uses
* at this time), but you may still opt to not implement this.
* <p/>
* This is expected to return a *new instance* each time it is called.
*
* @param item the item instance for which to get the node.
* @return the network node for that item.
*/
def node(item: ItemStack): Option[Node] = None
/**
* Get the tag compound based on the item stack to use for persisting the
* node associated with the specified item stack.
* <p/>
* This is only used if `node` is not `None`. This must always be a child
* tag of the items own tag compound, it will not be saved otherwise. Use
* this in the unlikely case that the default name collides with something.
*
* @param item the item to get the child tag to use for the `node`.
* @return the tag to use for saving and loading.
*/
def nbt(item: ItemStack) = {
val nbt = item.getTagCompound
if (!nbt.hasKey("oc.node")) {
nbt.setCompoundTag("oc.node", new NBTTagCompound())
}
nbt.getCompoundTag("oc.node")
}
}