Roughly Enough Items (REI) Documentation

For Fabric projects, REI recommends declaring a modCompileOnly dependency on the API and a modRuntimeOnly dependency on the full package. If you need to interact with built-in plugins, also include the default plugin as a compile dependency.

dependencies {
    modCompileOnly "me.shedaniel:RoughlyEnoughItems-api-fabric:VERSION"
    modRuntimeOnly "me.shedaniel:RoughlyEnoughItems-fabric:VERSION"
}

// Optional: To interact with built-in plugins
dependencies {
    modCompileOnly "me.shedaniel:RoughlyEnoughItems-default-plugin-fabric:VERSION"
}

For Forge projects using Architectury Loom, declare a modCompileOnly dependency on the API and a modRuntimeOnly dependency on the full package. If you need to interact with built-in plugins, include the default plugin as a compile dependency.

dependencies {
    modCompileOnly "me.shedaniel:RoughlyEnoughItems-api-forge:VERSION"
    modRuntimeOnly "me.shedaniel:RoughlyEnoughItems-forge:VERSION"
}

// Optional: To interact with built-in plugins
dependencies {
    modCompileOnly "me.shedaniel:RoughlyEnoughItems-default-plugin-forge:VERSION"
}

To use Roughly Enough Items (REI) in your project, you must first add the Shedaniel Maven repository to your repositories block in Gradle. Note that if you already have the Architectury Maven configured, you do not need to add this one as they are the same repository.

repositories {
    maven { url "https://maven.shedaniel.me" }
}

For Forge projects using ForgeGradle, it is recommended to depend directly on the full REI package using implementation and fg.deobf.

dependencies {
    implementation fg.deobf("me.shedaniel:RoughlyEnoughItems-forge:VERSION")
}

When using Architectury, declare the common API in your common subproject. Then, declare the platform-specific full package in your individual platform subprojects (Fabric or Forge). To interact with built-in plugins, declare the default plugin in the common subproject.

// Common
dependencies {
    modCompileOnly "me.shedaniel:RoughlyEnoughItems-api:VERSION"
}

// Optional: To interact with built-in plugins in Common
dependencies {
    modCompileOnly "me.shedaniel:RoughlyEnoughItems-default-plugin:VERSION"
}

// Fabric
dependencies {
    modRuntimeOnly "me.shedaniel:RoughlyEnoughItems-fabric:VERSION"
}

// Forge
dependencies {
    modRuntimeOnly "me.shedaniel:RoughlyEnoughItems-forge:VERSION"
}

The RecipeFinder maintains an internal map of item types to their available quantities via the amounts field (a Reference2IntOpenHashMap).

Key methods for managing quantities:

• put(T item, int amount): Adds the specified amount of an item to the finder.
• take(T item, int amount): Removes the specified amount from the finder. Throws an IllegalStateException if the amount to be taken exceeds the available amount.
• contains(T item): Returns true if the item exists in the finder with an amount greater than 0.
• clear(): Resets all item amounts to zero.

Note: amounts is a public field of type Reference2IntOpenHashMap<T>.

RecipeFinder<MyItem, MyIngredient> finder = new RecipeFinder<>();
finder.put(myStack, 64);
if (finder.contains(myStack)) {
    finder.take(myStack, 1);
}

To use RecipeFinder, you must provide a list of ingredients. Each ingredient must implement the Ingredient<T> interface, where T is the item type.

public interface Ingredient<T> {
    List<T> elements();
}

elements() should return a list of items that satisfy that specific ingredient requirement.

public class MyIngredient implements RecipeFinder.Ingredient<MyItem> {
    private final List<MyItem> items;

    public MyIngredient(List<MyItem> items) {
        this.items = items;
    }

    @Override
    public List<MyItem> elements() {
        return items;
    }
}