NeoTale

NeoTale es un sistema de eventos ligero y basado en anotaciones para plugins de Hytale, inspirado en el sistema de bus de eventos de NeoForge. Elimina el registro manual y el código repetitivo al descubrir y conectar automáticamente tus manejadores de eventos en tiempo de ejecución.

Características

• Suscripción a eventos basada en anotaciones
• No se requiere registro manual
• Escaneo automático de clases
• Despacho de métodos estáticos
• API mínima y limpia
• Flujo de trabajo al estilo de NeoForge

Cómo Funciona

Al iniciar, NeoTale escanea tu plugin y detecta automáticamente:

• Clases anotadas con @EventBusSubscriber
• Métodos public static dentro de esas clases anotadas con @SubscribeEvent

Cualquier método que coincida con este patrón se registra automáticamente en el bus de eventos y se invoca cuando se dispara el evento correspondiente.

Ejemplo de Evento

@EventBusSubscriber
public final class ServerEvents {

    @SubscribeEvent
    public static void onBoot(BootEvent event) {
        System.out.println("¡Servidor iniciado!");
    }

    @SubscribeEvent
    public static void onBreak(BreakBlockEvent event) {
        System.out.println("¡Bloque roto!");
    }
}

Eso es todo. NeoTale maneja el descubrimiento y la vinculación automáticamente.

Reglas de Detección

NeoTale solo registrará métodos que cumplan con todas las siguientes:

• Declarados en una clase anotada con @EventBusSubscriber
• Marcados como public static
• Anotados con @SubscribeEvent
• Aceptan exactamente un parámetro (el tipo de evento)

Registro de Sistemas

NeoTale también puede registrar automáticamente sistemas ECS utilizando el mismo enfoque basado en anotaciones. Declara métodos public static anotados con @SubscribeSystem dentro de una clase @EventBusSubscriber. NeoTale invocará estos métodos durante la configuración del plugin y registrará el sistema devuelto en el registro correcto.

Ejemplo de Sistema

@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) {
            }
        };
    }
}

Configuración de Gradle

Agrega el repositorio Maven de NeoTale:

Gradle (Groovy)

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

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")
}

¿Por qué NeoTale?

Los sistemas nativos de Hytale son poderosos, pero la conexión de eventos puede ser repetitiva y confusa. NeoTale simplifica el desarrollo al proporcionar un enfoque simple y familiar para los desarrolladores que vienen de la suscripción al bus de eventos de NeoForge.

Uso y Distribución

NeoTale es gratuito para usar en cualquier proyecto, incluidos servidores públicos, modpacks y compilaciones redistribuidas. Se te permite empaquetar y redistribuir NeoTale tal como está donde lo necesites.

La etiqueta ARR solo se aplica a la propiedad directa del código fuente/activos del proyecto; no restriñe el uso normal o la redistribución del mod construido.