Lodestone

An automatic content loader for Fabric mods.

Usage

In order to use Lodestone directly, please ensure that you add it as a dependency for your mod. This mod does not add any content by itself.

Lodestone provides basic interfaces and APIs for easily registering modded content during initialization. The most important type provided is the `Loaded` interface, which the mod is built around. For a basic example, see the Cheese mod.

To create an automatically registered type, simply implement the target environment's associated interface.

```java /** An item that is loaded at runtime. */ public class LoadedItem extends Item implements CommonLoaded {

// Required for all instances of `Loaded`. Allows Lodestone to group registered values by mod identifier. @Override public Identifier getLoaderId() { return Identifier.of(YourMod.MOD_ID, "your_item"); }

// A function that registers the value at runtime. @Override public void loadCommon() { Registry.register(Registries.ITEM, this.getLoaderId(), this); }

} ```

Each mod environment has its own dedicated interface:

- `CommonLoaded` loads the value on the "common" environment, meaning both the client *and* the server. - `ClientLoaded` *only* loads the value on the client instance. - `ServerLoaded` *only* loads the value on the server instance. - `DataGenerating` *only* loads the value during Fabric's data generation task.

These are intended to be used within each mod initializer to load it properly.

```java public class YourMod implements ModInitializer {

public static final String MOD_ID = "your_mod"; public static final LoadedItem YOUR_ITEM = new LoadedItem(new Settings());

@Override public void onInitialize() { // Registers this item for later loading. Lodestone.register(CommonLoaded.class, YOUR_ITEM);

// Which is then done here. Lodestone.load(CommonLoaded.class, MOD_ID); }

} ```

Lodestone also provides an abstract class and two annotations for automatic registration of values.

```java public final class ItemLoader extends AutoLoader {

@LoadingPriority(-1) // Controls the loading order. In this case, this loads last. public static final LoadedItem ITEM_1 = new LoadedItem("item_1", new Settings()); public static final LoadedItem ITEM_2 = new LoadedItem("item_2", new Settings()); public static final LoadedItem ITEM_3 = new LoadedItem("item_3", new Settings()); public static final LoadedItem ITEM_4 = new LoadedItem("item_4", new Settings()); public static final LoadedItem ITEM_5 = new LoadedItem("item_5", new Settings());

@IgnoreLoading({ }) // Prevents this value from being loaded. public static final LoadedItem NULL = null;

@Override public Identifier getLoaderId() { return Identifier.of(YourMod.MOD_ID, "items"); }

} ```

This is then registered in a very similar way.

```java public class YourMod implements ModInitializer {

public static final String MOD_ID = "your_mod"; public static final ItemLoader ITEMS = new ItemLoader();

@Override public void onInitialize() { // Registers all items for later loading. ITEMS.register();

// Which is then done here. Lodestone.load(CommonLoaded.class, MOD_ID); }

} ```

Depending on Lodestone

Lodestone's sole purpose is to be used as a library for other mods. If you would like to depend on Lodestone for your Fabric mod, add the following to your Gradle manifest:

```properties

gradle.properties

lodestone_version = 1.8.0 ```

```groovy // build.gradle

repositories { maven { url 'https://jitpack.io' } }

dependencies { modImplementation "com.github.Jaxydog:Lodestone:${project.lodestone_version}"

// Or, to alternatively depend on the most recent commit: modImplementation 'com.github.Jaxydog:Lodestone:main-SNAPSHOT' } ```

Lodestone *should* work with many older versions of Minecraft, but only the latest game version is guaranteed to have proper support. I am currently not interested in backporting to versions prior to roughly 1.18, but if you encounter any issues feel free to let me know anyway.