NeoTale

NeoTale

NeoTale is a lightweight, annotation-driven event system for Hytale plugins inspired by NeoForge’s event bus system. It removes manual registration and boilerplate by automatically discovering and wiring your event handlers at runtime.

Features

Annotation-based event subscription

No manual registration required

Automatic class scanning

Static method dispatch

Minimal, clean API

NeoForge-style workflow

How It Works

On startup, NeoTale scans your plugin and automatically detects:

Classes annotated with @EventBusSubscriber

public static methods inside those classes annotated with @SubscribeEvent

Any method matching this pattern is automatically registered to the event bus and invoked when the corresponding event fires.

Event Example

@EventBusSubscriber public final class ServerEvents {

@SubscribeEvent public static void onBoot(BootEvent event) { System.out.println("Server booted!"); }

@SubscribeEvent public static void onBreak(BreakBlockEvent event) { System.out.println("Block broken!"); } }

That’s it. NeoTale handles discovery and binding automatically.

Detection Rules

NeoTale will only register methods that meet all of the following:

Declared in a class annotated with @EventBusSubscriber

Marked public static

Annotated with @SubscribeEvent

Accept exactly one parameter (the event type)

System Registration

NeoTale can also auto-register ECS systems using the same annotation-first approach. Declare public static methods annotated with @SubscribeSystem inside an @EventBusSubscriber class. NeoTale will invoke these methods during plugin setup and register the returned system into the correct registry.

System Example

@EventBusSubscriber public final class Systems {

@SubscribeSystem(store = SystemStore.ENTITY) public static ISystem<EntityStore> myEntitySystem() { return new EntityEventSystem<>(BreakBlockEvent.class) { @Override public void handle(int i, @Nonnull ArchetypeChunk<EntityStore> chunk, @Nonnull Store<EntityStore> store, @Nonnull CommandBuffer<EntityStore> buffer, @Nonnull BreakBlockEvent event) { }

@Override public Query<EntityStore> getQuery() { return Query.any(); } }; }

@SubscribeSystem(store = SystemStore.CHUNK) public static ISystem<ChunkStore> myChunkSystem() { return new RefSystem<ChunkStore>() { @Override public Query<ChunkStore> getQuery() { return Query.any(); }

@Override public void onEntityAdded(Ref<ChunkStore> ref, AddReason reason, Store<ChunkStore> store, CommandBuffer<ChunkStore> buffer) { }

@Override public void onEntityRemove(Ref<ChunkStore> ref, RemoveReason reason, Store<ChunkStore> store, CommandBuffer<ChunkStore> buffer) { } }; } }

Gradle Setup

Add the NeoTale Maven repository:

Gradle (Groovy)

repositories { maven { url 'https://dl.cloudsmith.io/public/lio/neotale/maven/&#x27; } }

dependencies { implementation "net.liopyu:neotale:$neoTaleVersion" }

Gradle (Kotlin DSL)

repositories { maven("https://dl.cloudsmith.io/public/lio/neotale/maven/") }

dependencies { implementation("net.liopyu:neotale:$neoTaleVersion") }

Why NeoTale?

Hytale&rsquo;s native systems are powerful, but event wiring can be repetitive and confusing. NeoTale streamlines development by providing a simple, familiar approach for developers coming from NeoForge event bus subscription.

Usage & Distribution

NeoTale is free to use in any project, including public servers, modpacks, and redistributed builds. You are allowed to bundle and redistribute NeoTale as-is wherever you need it.

The ARR label only applies to direct ownership of the project&rsquo;s source/assets; it does not restrict normal use or redistribution of the built mod.