Saltar a contenido

Arquitectura de Hytale

Entender la arquitectura interna de Hytale es fundamental para desarrollar plugins efectivos. Esta página describe la estructura general del servidor y sus componentes principales.

Estructura General

graph TB
    A[Main Entry Point] --> B[EarlyPluginLoader]
    B --> C[TransformingClassLoader]
    C --> D[LateMain]
    D --> E[HytaleServer]
    E --> F[Module System]
    F --> G[Entity Module]
    F --> H[Interaction Module]
    F --> I[Meta Module]
    E --> J[World Management]
    E --> K[Network Layer]

Componentes Principales

1. Early Plugin System

El sistema de plugins tempranos es el primer componente que se inicializa.

Ubicación: com.hypixel.hytale.plugin.early

Componentes: - EarlyPluginLoader: Carga plugins desde earlyplugins/ - ClassTransformer: Interfaz para transformar bytecode - TransformingClassLoader: ClassLoader que aplica transformaciones

Flujo: 

// 1. Cargar plugins
EarlyPluginLoader.loadEarlyPlugins(args);

// 2. Registrar transformadores
ServiceLoader.load(ClassTransformer.class, pluginClassLoader);

// 3. Aplicar transformaciones al cargar clases
TransformingClassLoader.loadClass(className);

2. Server Core

Ubicación: com.hypixel.hytale.server.core

HytaleServer

Clase principal del servidor que coordina todos los sistemas.

Responsabilidades: - Inicialización de módulos - Gestión del ciclo de vida - Configuración global - Sistema de eventos

Código de entrada (LateMain.java:16): 

public static void lateMain(String[] args) {
    Options.parse(args);
    HytaleLogger.init();
    new HytaleServer();
}

Options System

Sistema de configuración basado en argumentos de línea de comandos.

Ubicación: com.hypixel.hytale.server.core.Options

Ejemplos de opciones: 

--accept-early-plugins      # Acepta early plugins sin confirmación
--singleplayer              # Modo un jugador
--log-levels logger:LEVEL   # Configura niveles de log

3. Meta System

Sistema flexible para almacenar metadatos asociados a objetos del juego.

Ubicación: com.hypixel.hytale.server.core.meta

Componentes Clave

MetaKey: 

public class MetaKey<T> {
    private final int id;

    public int getId() { return id; }
}

IMetaStore: 

public interface IMetaStore<K> {
    <T> T getMetaObject(MetaKey<T> key);
    <T> T putMetaObject(MetaKey<T> key, T obj);
    <T> T removeMetaObject(MetaKey<T> key);
    boolean hasMetaObject(MetaKey<?> key);
}

MetaRegistry: 

public class MetaRegistry<K> {
    public <T> MetaKey<T> registerMetaObject(
        Function<K, T> defaultValueSupplier
    );
}

Uso: 

// Registrar una key
MetaKey<String> CUSTOM_NAME =
    registry.registerMetaObject(entity -> "Default");

// Guardar/recuperar
entity.putMetaObject(CUSTOM_NAME, "Mi Nombre");
String name = entity.getMetaObject(CUSTOM_NAME);

4. Interaction System

Sistema complejo para definir y ejecutar interacciones en el juego.

Ubicación: com.hypixel.hytale.server.core.modules.interaction

Jerarquía de Interacciones

classDiagram
    Operation <|-- Interaction
    Interaction <|-- SimpleInstantInteraction
    Interaction <|-- ChangeBlockInteraction
    Interaction <|-- PlaceBlockInteraction
    Interaction <|-- DestroyBlockInteraction
    Interaction <|-- UseEntityInteraction

    class Interaction {
        +String id
        +float runTime
        +InteractionEffects effects
        +tick()
        +simulateTick()
    }

Tipos de Interacciones

Client Interactions: Interacciones que requieren sincronización con el cliente - PlaceBlockInteraction - DestroyBlockInteraction - UseEntityInteraction - WieldingInteraction

None Interactions: Interacciones de lógica pura - ApplyEffectInteraction - SendMessageInteraction - RemoveEntityInteraction - ConditionInteraction

Control Flow Interactions: Control de flujo - SerialInteraction: Ejecuta interacciones en serie - ParallelInteraction: Ejecuta interacciones en paralelo - ConditionInteraction: Ejecución condicional - RepeatInteraction: Repetir interacción

InteractionContext

Contexto que se pasa durante la ejecución de interacciones:

public class InteractionContext {
    private Ref<EntityStore> entity;
    private InteractionChain chain;
    private IMetaStore instanceStore;
    private ItemStack heldItem;

    // Métodos para acceder/modificar el estado
}

5. Module System

Los módulos encapsulan funcionalidad específica del juego.

EntityModule

Gestión de entidades en el mundo.

Componentes: - TransformComponent: Posición, rotación, escala - NetworkId: ID de red de la entidad - PlayerRef: Referencia a jugador

InteractionModule

Gestión del sistema de interacciones.

Responsabilidades: - Registro de interacciones - Ejecución de cadenas de interacción - Sincronización cliente-servidor

Flujo de Ejecución

Inicialización del Servidor

sequenceDiagram
    participant Main
    participant EPL as EarlyPluginLoader
    participant TCL as TransformingClassLoader
    participant LM as LateMain
    participant HS as HytaleServer

    Main->>EPL: loadEarlyPlugins(args)
    EPL->>EPL: Cargar JARs de earlyplugins/
    EPL->>EPL: Crear ServiceLoader
    EPL->>TCL: Registrar transformadores
    Main->>LM: lateMain(args)
    LM->>LM: Parsear Options
    LM->>LM: Inicializar Logger
    LM->>HS: new HytaleServer()
    HS->>HS: Inicializar módulos
    HS->>HS: Cargar mundo
    HS->>HS: Iniciar network listener

Ejecución de Interacción

sequenceDiagram
    participant Player
    participant IM as InteractionManager
    participant IC as InteractionChain
    participant I as Interaction

    Player->>IM: Activar interacción
    IM->>IC: Crear cadena
    IC->>I: tick(time, context)
    I->>I: Ejecutar lógica
    I->>IC: Actualizar estado
    IC->>IM: Retornar resultado
    IM->>Player: Aplicar efectos

Patrones de Diseño

Service Loader Pattern

Usado para cargar plugins de manera dinámica.

ServiceLoader<ClassTransformer> loader =
    ServiceLoader.load(ClassTransformer.class, classLoader);

for (ClassTransformer transformer : loader) {
    transformers.add(transformer);
}

Registry Pattern

Usado para metadatos y assets.

public class MetaRegistry<K> {
    private final List<Function<K, ?>> suppliers = new ArrayList<>();

    public <T> MetaKey<T> registerMetaObject(
        Function<K, T> supplier
    ) {
        int id = suppliers.size();
        suppliers.add(supplier);
        return new MetaKey<>(id);
    }
}

Command Pattern

Las interacciones siguen el patrón Command.

public abstract class Interaction implements Operation {
    protected abstract void tick0(
        boolean firstRun,
        float time,
        InteractionType type,
        InteractionContext context
    );
}

Consideraciones de Rendimiento

Transformación de Clases

  • Se ejecuta una sola vez durante la carga de clases
  • Impacta el tiempo de inicio del servidor
  • Transiciones complejas pueden ser costosas

Meta System

  • Almacenamiento en memoria
  • Acceso O(1) mediante índice
  • Serialización para persistencia

Interaction System

  • Ejecución tick-based (cada frame)
  • Optimizado para múltiples interacciones simultáneas
  • Sistema de pooling para reducir allocaciones

Próximos Pasos

Preguntas? Consulta el Glosario