EverlastingUtils (Minecraft)

Note: If you're seeing this as a dependency or requirement for another mod, you can simply install it and ignore this documentation.

EverlastingUtils is a utility library for Fabric mod development. It provides implementations for common features that mod developers frequently need to implement:

• Configuration management with runtime reloading
• Command registration with permission handling
• Inventory GUI framework
• Utility functions and extensions

For mod developers looking to use this library, continue reading below.

Features

Config Management

• JSONC configuration with comments support
• Automatic config migration and backup
• File watching and hot reloading
• Type-safe config handling with Kotlin data classes

data class MyConfig(
    override val version: String = "1.0.0",
    override val configId: String = "mymod"
    // Your config properties here
) : ConfigData

val configManager = ConfigManager(
    currentVersion = "1.0.0",
    defaultConfig = MyConfig(),
    configClass = MyConfig::class
)

Enhanced Command System

• Fluent command builder API
• Built-in permission handling
• Subcommand support
• Alias support

commandManager.command("mycommand", permission = "mymod.command") {
    executes { context ->
        // Command logic
        1
    }
    
    subcommand("subcommand") {
        executes { context ->
            // Subcommand logic
            1
        }
    }
}

GUI Framework

• Simple inventory GUI creation
• Custom button support
• Interactive slot handling
• Dynamic content updates

CustomGui.openGui(
    player = player,
    title = "My GUI",
    layout = listOf(/* GUI items */),
    onInteract = { context ->
        // Handle interactions
    }
)

Dependencies

• Kotlin
• Fabric API
• Fabric Language Kotlin

Installation

Add to your build.gradle.kts:

dependencies {
    modImplementation "curse.maven:e-utils-1275646:6588136"
}

Usage Examples

Config Management

// Create a config
data class MyConfig(
    override val version: String = "1.0.0",
    override val configId: String = "mymod",
    var debugMode: Boolean = false
) : ConfigData

// Initialize manager
val configManager = ConfigManager(
    currentVersion = "1.0.0",
    defaultConfig = MyConfig(),
    configClass = MyConfig::class,
    metadata = ConfigMetadata(
        headerComments = listOf("My mod configuration")
    )
)

// Access config
val currentConfig = configManager.getCurrentConfig()

Command Registration

val commandManager = CommandManager("mymod")

commandManager.command("hello", permission = "mymod.hello") {
    executes { context ->
        val source = context.source
        CommandManager.sendSuccess(source, "Hello, World!")
        1
    }
}

GUI Creation

CustomGui.openGui(
    player = player,
    title = "My GUI",
    layout = listOf(
        CustomGui.createNormalButton(
            ItemStack(Items.DIAMOND),
            "Click Me!",
            listOf("Button Description")
        )
    ),
    onInteract = { context ->
        // Handle button clicks
    }
)

Contributing

Contributions are welcome! Feel free to submit issues and pull requests.

Source Code & Development

The complete source code for EverlastingUtils is available on GitHub: EverlastingUtils Repository

Adding to Your Project

Add this to your build.gradle.kts:

dependencies {
    modCompileOnly(files("libs/everlastingutils-1.0.0.jar"))
}

Make sure to place the EverlastingUtils JAR file in your project's libs directory.

EverlastingUtils

EverlastingUtils is a powerful, server-side utility and API library for the Fabric modding toolchain. It provides a robust framework for common, yet complex, features that mod developers frequently need, allowing them to focus more on their mod's unique content.

For Players: If a mod you downloaded requires "EverlastingUtils," you just need to install this library in your mods folder. You can ignore all the technical information below.

Legacy Versions: If you are using older versions of mods that require this library, please download EverlastingUtils version 1.0.2.

Dependencies

• Fabric API
• Fabric Language Kotlin

Attention Developers

The information from this point forward is intended for mod developers looking to use EverlastingUtils as a dependency in their own projects.

Core Features

EverlastingUtils is designed to accelerate development by providing ready-to-use, high-quality systems for:

• Configuration: A type-safe, multi-file configuration system with JSONC support, live reloading, and automatic version migration.
• Task Scheduling: A server-aware scheduler that properly handles synchronous (main thread) and asynchronous tasks, preventing common concurrency issues.
• Commands: A fluent, Brigadier-based command builder with integrated permission handling.
• GUIs: A simple yet powerful framework for creating interactive inventory-based GUIs, including standard and anvil types.
• Utilities: A collection of helpers for things like MiniMessage color parsing and toggleable, per-mod debug logging.

System Spotlights

Configuration System (ConfigManager)

The ConfigManager is a sophisticated system designed to handle all aspects of configuration management with minimal boilerplate.

Key Functionalities:

• Type-Safe & Modern: Uses Kotlin data classes for type-safe config access and JSONC for human-readable files with comments.
• Live Reloading: Automatically reloads configuration files from disk when they are changed, allowing server owners to adjust settings without a restart.
• Multi-File Support: Manages a main config.jsonc and any number of "secondary" configs in sub-directories, perfect for organizing complex data like Pokémon or loot pools.
• Automatic Migration: When you release a new version of your mod, the ConfigManager compares the version number in the user's config file with your mod's current version. If they don't match, it automatically merges their existing settings into a new, updated config structure, preserving their changes.
• Metadata & Comments: Programmatically add header comments, footer comments, and per-field descriptions to your config files, making them self-documenting.

Example Usage:

// 1. Define your configuration structure
data class MyConfig(
    override val version: String = "1.0.0",
    override val configId: String = "mymod", // Used for the config folder name
    var debugMode: Boolean = false,
    var welcomeMessage: String = "<green>Welcome to my server!"
) : ConfigData

// 2. Initialize the manager in your mod's entry point
val configManager = ConfigManager(
    currentVersion = "1.0.0", // Your mod's current version
    defaultConfig = MyConfig(),
    configClass = MyConfig::class,
    metadata = ConfigMetadata(
        headerComments = listOf("Main configuration for MyMod."),
        sectionComments = mapOf("debugMode" to "Enables detailed console logging.")
    )
)

// 3. Access your config anywhere
val isDebug = configManager.getCurrentConfig().debugMode

Task Scheduler (SchedulerManager)

The SchedulerManager provides a safe and efficient way to schedule delayed or repeating tasks, built specifically for the Minecraft server environment.

Key Functionalities:

• Server-Aware: The scheduler is tied to the server lifecycle. It automatically shuts down when the server stops and recreates its thread pool on restart, preventing thread leaks and errors.
• Sync vs. Async: Easily specify whether a task should run synchronously on the main server thread (necessary for almost all Minecraft API calls) or asynchronously on a worker thread (for heavy, non-API work like database queries).
• Efficient Threading: Uses a shared, managed thread pool to prevent individual mods from creating excessive threads and bogging down the server.
• Tracked Tasks: All scheduled tasks are tracked by a unique ID, allowing you to cancel them later if needed.

Example Usage:

// In your server-side initializer (e.g., inside ServerLifecycleEvents.SERVER_STARTED)
val server = ... // Get the MinecraftServer instance

// Schedule a task to run every 5 minutes on the main server thread
SchedulerManager.scheduleAtFixedRate(
    id = "mymod-broadcast-task", // Unique ID for this task
    server = server,
    initialDelay = 0,
    period = 5,
    unit = TimeUnit.MINUTES,
    runAsync = false, // IMPORTANT: false runs on the main server thread
    task = {
        // This code is safe to run because runAsync is false
        server.playerManager.broadcast(Text.literal("It has been 5 minutes!"), false)
    }
)

Other Features

Command System (CommandManager)

A fluent builder for creating Brigadier commands with less boilerplate. It handles permission checks automatically, supporting both vanilla OP levels and the Fabric Permissions API.

val commandManager = CommandManager(modId = "mymod")

commandManager.command("hello", permission = "mymod.hello") {
    executes { context ->
        context.source.sendFeedback({ Text.literal("Hello, world!") }, false)
        1 // Success
    }
    subcommand("admin") {
        executes { context -> /* ... */ }
    }
}
// Don't forget to register it!
commandManager.register()

GUI Framework (CustomGui & AnvilGuiManager)

Quickly create interactive GUIs for your players with callback-based logic, dynamic updates, and full MiniMessage support for titles and lore.

// Example of a simple chest GUI
CustomGui.openGuiFormatted(
    player = player,
    title = "<gradient:gold:yellow>My Awesome GUI",
    layout = listOf(
        CustomGui.createFormattedButton(
            ItemStack(Items.DIAMOND), 
            "<blue>Click Me!", 
            listOf("<gray>This is a button."), 
            player
        )
    ),
    onInteract = { context ->
        if (context.slotIndex == 0) {
            player.sendMessage(Text.literal("You clicked the button!"))
            CustomGui.closeGui(player)
        }
    },
    onClose = { /* ... */ }
)

For Developers: Getting Started

To use EverlastingUtils in your project, add it to your dependencies.

build.gradle.kts

repositories {
    // Add the repository where EverlastingUtils is hosted
    maven { url = "https://api.modrinth.com/maven" }
}

dependencies {
    // Add the library as a dependency
    modImplementation("maven.modrinth:e-utils:1.1.2") // Replace with the latest version
}

fabric.mod.json

Make sure to declare the dependency in your fabric.mod.json file.

"depends": {
    "everlastingutils": ">=1.1.2" // Replace with the version you are using
}