Difference between revisions of "User:TheSilkMiner/Capabilities"

From Forge Community Wiki
User:TheSilkMiner/Capabilities
(Start rewrite of Capability page)
(Set up structure for the page)
Line 18: Line 18:
 
== Terminology ==
 
== Terminology ==
 
The high flexibility of the system comes with a cost, though, which is terminology. The following section wants to be a dictionary of sorts, defining all the terms that you may come across when dealing with capabilities.
 
The high flexibility of the system comes with a cost, though, which is terminology. The following section wants to be a dictionary of sorts, defining all the terms that you may come across when dealing with capabilities.
 +
 +
In the rest of this article, we will refer to these terms frequently, so make sure you are familiar with them.
  
 
* '''Capability''': the ability to perform something; in-code this is represented by the <code>Capability</code> class.
 
* '''Capability''': the ability to perform something; in-code this is represented by the <code>Capability</code> class.
* '''Capability Provider''':  
+
* '''Capability Provider''': something that is able to support capabilities and provides a mean of accessing them; capability providers come in multiple kinds.
 +
** ''Volatile Provider'': a provider that doesn't persist data to disk; once the provider ceases to exist for any number of reasons, all capability data gets deleted.
 +
** ''Persistent Provider'': a provider that requires all capabilities to serialize data to disk, in order to persist data even across game restarts.
 +
** ''Agnostic Provider'': a provider that isn't neither volatile nor persistent, rather delegates the decision either to the capability directly or to sub-implementations.
 +
* '''Capability Interface''': the interface that defines the contract of the capability, so what operations the capability exposes.
 +
* '''Capability Implementation''': one of the possibly many implementations of the capability interface, that actually carries out the work; one of the various implementations may also be considered the '''default capability implementation'''.
 +
* '''Capability Storage''': the manager that handles loading and storing persistent capabilities data from and to disk, guaranteeing preservation of information; in-code this is represented by an implementation of the <code>Capability.IStorage</code> interface.
 +
 
 +
== Forge-provided Capabilities and Providers ==
 +
In order to ensure mods can work together seamlessly, Forge provides a set of default capabilities and capability providers.
 +
 
 +
The default capability providers in a Forge environment are: <code>TileEntity</code>, <code>Entity</code>, <code>ItemStack</code>, <code>World</code>, and <code>Chunk</code>. These are all agnostic providers, since they don't mandate any sort of capability persistency requirements. Rather, it is the job of whoever subclasses these providers to deal with either volatile or non-volatile capabilities.
 +
 
 +
The default capabilities that forge provides are <code>IItemHandler</code>, <code>IFluidHandler</code>, and <code>IEnergyStorage</code>. Each one of these capabilities will be discussed in the corresponding section.
 +
 
 +
=== <code>IItemHandler</code> ===
 +
 
 +
=== <code>IFluidHandler</code> ===
 +
 
 +
=== <code>IEnergyStorage</code> ===
 +
 
 +
== Operating with Capabilities ==
 +
 
 +
=== Exposing ===
 +
 
 +
=== Attaching ===
 +
 
 +
== Creating Custom Capabilities ==
 +
 
 +
== Code Examples ==
 +
 
  
  

Revision as of 13:15, 8 January 2021

Capabilities are a Forge system that allows cross-mod interactions by allowing capability providers to dynamically respect contracts and provide specialized behavior without requiring the implementation of many interfaces or hard dependencies on mods.

History

In an ideal world, all that would be needed for a mod to provide the equivalent of a capability would be implementing an interface. This is in fact how cross-mod interaction used to work prior to the introduction of capabilities.

The real world, though, is often much more complicated: users wanted to be free to combine mods the way they wanted and saw fit, and developers wanted to be able to declare soft dependencies on other mods, thus reducing the need of having a huge mod pack just for testing.

The first approach used by Forge was conditional stripping of interfaces and methods, but this proved to be problematic. While the idea works well in theory, in practice the ASM editing of classes relied on complex mechanics and could lead to hard to spot bugs.

For this reason, the entire system was redesigned and the concept of capabilities was born.

The Concept

A capability allows any capability provider to conditionally expose a certain ability to do something, e.g. accepting power or handling items. A capability provider, moreover, can decide to expose a capability only on certain sides, allowing for easy interactions with hoppers, cables, etc.

Capabilities may also be added and removed dynamically both from the "owner" of the capability provider and other mods, allowing even easier cross-mod interaction. For example, a mod that isn't compatible with Forge Energy could be converted into one by dynamically attaching the Forge Energy capability and handling the conversion to a third-party energy system without having to alter the original mod.

Terminology

The high flexibility of the system comes with a cost, though, which is terminology. The following section wants to be a dictionary of sorts, defining all the terms that you may come across when dealing with capabilities.

In the rest of this article, we will refer to these terms frequently, so make sure you are familiar with them.

  • Capability: the ability to perform something; in-code this is represented by the Capability class.
  • Capability Provider: something that is able to support capabilities and provides a mean of accessing them; capability providers come in multiple kinds.
    • Volatile Provider: a provider that doesn't persist data to disk; once the provider ceases to exist for any number of reasons, all capability data gets deleted.
    • Persistent Provider: a provider that requires all capabilities to serialize data to disk, in order to persist data even across game restarts.
    • Agnostic Provider: a provider that isn't neither volatile nor persistent, rather delegates the decision either to the capability directly or to sub-implementations.
  • Capability Interface: the interface that defines the contract of the capability, so what operations the capability exposes.
  • Capability Implementation: one of the possibly many implementations of the capability interface, that actually carries out the work; one of the various implementations may also be considered the default capability implementation.
  • Capability Storage: the manager that handles loading and storing persistent capabilities data from and to disk, guaranteeing preservation of information; in-code this is represented by an implementation of the Capability.IStorage interface.

Forge-provided Capabilities and Providers

In order to ensure mods can work together seamlessly, Forge provides a set of default capabilities and capability providers.

The default capability providers in a Forge environment are: TileEntity, Entity, ItemStack, World, and Chunk. These are all agnostic providers, since they don't mandate any sort of capability persistency requirements. Rather, it is the job of whoever subclasses these providers to deal with either volatile or non-volatile capabilities.

The default capabilities that forge provides are IItemHandler, IFluidHandler, and IEnergyStorage. Each one of these capabilities will be discussed in the corresponding section.

IItemHandler

IFluidHandler

IEnergyStorage

Operating with Capabilities

Exposing

Attaching

Creating Custom Capabilities

Code Examples

OLD SHIT FOLLOWS

Capabilities allow exposing features in a dynamic and flexible way, without having to resort to directly implementing many interfaces.

In general terms, each capability provides a feature in the form of an interface, alongside with a default implementation which can be requested, and a storage handler for at least this default implementation. The storage handler can support other implementations, but this is up to the capability implementor, so look it up in their documentation before trying to use the default storage with non-default implementations.

Forge adds capability support to TileEntities, Entities, ItemStacks, Worlds and Chunks, which can be exposed either by attaching them through an event or by overriding the capability methods in your own implementations of the objects. This will be explained in more detail in the following sections.

Forge-provided Capabilities

Forge provides three capabilities: IItemHandler, IFluidHandler and IEnergyStorage.

IItemHandler exposes an interface for handling inventory slots. It can be applied to TileEntities (chests, machines, etc.), Entities (extra player slots, mob/creature inventories/bags), or ItemStacks (portable backpacks and such). It replaces the old IInventory and ISidedInventory with an automation-friendly system.

IFluidHandler exposes an interface for handling fluid inventories. It can also be applied to TileEntities Entities, or ItemStacks. It replaces the old IFluidHandler with a more consistent and automation-friendly system.

IEnergyStorage exposes an interface for handling energy containers. It can be applied to TileEntities, Entities or ItemStacks. It is based on the RedstoneFlux API by TeamCoFH.

Using an Existing Capability

As mentioned earlier, TileEntities, Entities, and ItemStacks implement the capability provider feature, through the ICapabilityProvider interface. This interface adds the method getCapability, which can be used to query the capabilities present in the objects.

In order to obtain a capability, you will need to refer it by its unique instance. In the case of the IItemHandler, this capability is primarily stored in CapabilityItemHandler#ITEM_HANDLER_CAPABILITY, but it is possible to get other instance references by using the @CapabilityInject annotation.

@CapabilityInject(IItemHandler.class)
static Capability<IItemHandler> ITEM_HANDLER_CAPABILITY = null;

This annotation can be applied to fields and methods. When applied to a field, it will assign the instance of the capability (the same one gets assigned to all fields) upon registration of the capability, and left to the existing value (null), if the capability was never registered. Because local static field accesses are fast, it is a good idea to keep your own local copy of the reference for objects that work with capabilities. This annotation can also be used on a method, in order to get notified when a capability is registered, so that certain features can be enabled conditionally.

Both the getCapability methods have a second parameter, of type Direction, which can be used in the to request the specific instance for that one face. If passed null, it can be assumed that the request comes either from within the block, or from some place where the side has no meaning, such as a different dimension. In this case a general capability instance that does not care about sides will be requested instead. The return type of getCapability will correspond to the type declared in the capability passed to the method. For the item handler capability, this is indeed IItemHandler.

Exposing a Capability

In order to expose a capability, you will first need an instance of the underlying capability type. Note that you should assign a separate instance to each object that keeps the capability, since the capability will most probably be tied to the containing object.

There’s two ways to obtain such an instance, through the Capability itself, or by explicitly instantiating an implementation of it. The first method is designed to use a default implementation via Capability#getDefaultInstance, if those default values are useful for you. In the case of the item handler capability, the default implementation will expose a single slot inventory, which is most probably not what you want.

The second method can be used to provide custom implementations. In the case of IItemHandler, the default implementation uses the ItemStackHandler class, which has an optional argument in the constructor, to specify a number of slots. However, relying on the existence of these default implementations should be avoided, as the purpose of the capability system is to prevent loading errors in contexts where the capability is not present, so instantiation should be protected behind a check testing if the capability has been registered (see the remarks about @CapabilityInject in the previous section).

Once you have your own instance of the capability interface, you will want to notify users of the capability system that you expose this capability and provide a holder of the instance. This is done by overriding the getCapability method, and comparing the instance with the capability you are exposing. If your machine has different slots based on which side is being queried, you can test this with the side parameter. For Entities and ItemStacks, this parameter can be ignored, but it is still possible to have side as a context, such as different armor slots on a player (top side => head slot?), or about the surrounding blocks in the inventory (west => slot on the left?). Don’t forget to fall back to super, otherwise the attached capabilities will stop working. Make sure to invalidate the holder of the instance at the end of the provider's lifecycle.

// Somewhere in your TileEntity subclass
LazyOptional<IItemHandler> inventoryHandlerLazyOptional;

// After initializing inventoryHandler
inventoryHandlerLazyOptional = LazyOptional.of(() -> inventoryHandler);

public <T> LazyOptional<T> getCapability(Capability<T> cap, Direction side) {
  if (cap == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
    return inventoryHandlerLazyOptional.cast();
  }
  return super.getCapability(cap, side);
}

@Override
protected void invalidateCaps() {
  super.invalidateCaps();
  inventoryHandlerLazyOptional.invalidate();
}

Items are a special case since their capability providers are stored on an ItemStack. Instead, a provider should be attached through Item#initCapabilities when applicable. This should hold your capabilities for the lifecycle of the stack.

It is strongly suggested that direct checks in code are used to test for capabilities instead of attempting to rely on maps or other data structures, since capability tests can be done by many objects every tick, and they need to be as fast as possible in order to avoid slowing down the game.