Unreal

Si has creado juegos con Unreal, hay algunas diferencias clave que necesitarás conocer para comenzar en All Out.

---

Esta guía es para desarrolladores de Unreal Engine (Blueprints / C++) que hacen la transición a All Out y CSL (el lenguaje de scripting personalizado de All Out).

El gran cambio (modelo mental)

En Unreal a menudo piensas en términos de:

• Actores en un Mundo (instanciados, replicados, poseídos)

• Componentes adjuntos a Actores

• gráficos de Blueprint / C++ que impulsan la jugabilidad

• RPC + Replicación que tú autorizas explícitamente

En All Out normalmente pensarás en términos de:

• Entidades en una Escena (con Componentes)

• Componentes (componentes provistos por el motor + los tuyos en CSL)

• Abilities para acciones del jugador (interfaz móvil primero + tiempo de reutilización + apuntado)

• Jugabilidad con autoridad del servidor donde la sincronización de estado es automática (sin cableado RPC personalizado para la mayoría de la jugabilidad)

Mapeo rápido: Unreal → All Out / CSL

Unreal	All Out / CSL	Notas
UWorld / Nivel	Escena	Las entidades existen en la escena; también puedes crearlas/destruirlas en tiempo de ejecución.
AActor	Entidad	Las entidades tienen transformaciones y componentes.
UActorComponent	Component	Escribes la jugabilidad creando componentes CSL y adjuntándolos a las entidades.
BeginPlay	ao_start	Punto de entrada del ciclo de vida del componente.
Tick(float DeltaTime)	ao_update(dt) / ao_late_update(dt)	Usa actualización tardía para patrones de UI/entrada usados por el motor (por ejemplo, botones de habilidad).
gráficos de Blueprint	código CSL	Basado en texto, compilado como parte de tu proyecto.
Pawn/Character	Player_Base subclases	Tu lógica de jugador suele residir en un Player componente/clase.
Asignaciones de entrada	Habilidades + asignaciones de teclas	Móvil primero: prefiere botones de habilidad sobre entrada cruda.
Replicación (Replicado vars)	Sincronización automática de estado	Evita construir tus propios patrones de replicación/RPC a menos que realmente los necesites.
RPCs (Servidor, Cliente, NetMulticast)	Usualmente no necesarios	Usa las facilidades del motor (p. ej., notificaciones) en lugar de una proliferación de RPCs personalizados.
Generación de actores	Scene.create_entity() / instantiate(Prefab_Asset)	Los prefabs son assets y pueden ser instanciados.
UAsset referencias	get_asset(...)	Los assets viven bajo /res y son referenciados por ruta.

Tu primer archivo CSL (imports)

CSL usa un único patrón de importación “raíz”: importa en main.csl, y no esparzas imports por cada archivo.

// main.csl
import "core:ao"
import "ui"   // si creas una carpeta /ui y quieres que esté en el alcance

Entidades y componentes (vs Actores y Componentes)

Creando una entidad en tiempo de ejecución

entity := Scene.create_entity();
entity->set_local_position({10, 20});
entity->set_local_scale({2.0, 2.0});
entity->set_local_rotation(0);

Agregar y acceder a componentes

my := entity->add_component(My_Component);
sprite := entity->get_component(Sprite_Renderer);

// Destruir entidad (y sus componentes)
entity->destroy();

Escribiendo un componente personalizado (ciclo de vida)

Spinner :: class : Component {
    speed: float;

    ao_start :: method() {
        speed = 1.0;
    }

    ao_update :: method(dt: float) {
        entity->set_local_rotation(entity.local_rotation + speed * dt);
    }
}

Iterando entidades/componentes

foreach e: entity_iterator() {
    // ...
}

foreach p: component_iterator(Player) {
    // ...
}

Acciones del jugador: usa Habilidades (en lugar de entrada cruda)

Los proyectos de Unreal a menudo comienzan con enlaces de entrada (Enhanced Input) y luego construyen UI/UX encima. En All Out, Abilities son la forma predeterminada de implementar acciones del jugador con:

• Un consistente amigable para móvil UI de botones

• Tiempos de reutilización

• Apuntado opcional (arrastrar para apuntar en móvil, apuntado con ratón en PC)

Dibuja botones de habilidad desde Player.ao_late_update dentro de is_local_or_server():

Player :: class : Player_Base {
    ao_late_update :: method(dt: float) {
        if this->is_local_or_server() {
            draw_ability_button(this, Shoot_Ability, 0);
            draw_ability_button(this, Dodge_Roll, 1);
        }
    }
}

Ver: Abilities para la API completa y los patrones.

Red: “la replicación” no es tu trabajo (la mayor parte del tiempo)

Qué es diferente respecto a la replicación de Unreal

• El estado de la jugabilidad se sincroniza automáticamente del servidor → clientes.

• Generalmente no escribes RPCs para flujos de jugabilidad estándar.

• Aún debes diseñar con múltiples jugadores en mente: evita el estado global; almacena el estado por jugador en la instancia del jugador.

Lógica solo cliente vs servidor/compartida

Usa estos patrones:

• is_local_or_server() para entradas + UI de jugabilidad (se ejecuta en servidor + cliente local)

• is_local() para UI/efectos puramente cosméticos (se ejecuta solo en el cliente local)

Player :: class : Player_Base {
    ao_late_update :: method(dt: float) {
        if is_local_or_server() {
            // entradas + UI de jugabilidad
        }
        if is_local() {
            // UI/efectos solo cosméticos
        }
    }
}

Assets, prefabs y rutas

La /res carpeta

Los assets están en /res. Al referenciar assets, omite /res de la ruta.

button := get_asset(Texture_Asset, "ui/button.png");
click := get_asset(SFX_Asset, "sfx/click.wav");
font := get_asset(Font_Asset, "$AO/fonts/Barlow-Black.ttf"); // assets del motor

Prefabs

Los prefabs son assets (carpetas que terminan en .prefab) y pueden ser instanciados:

prefab := get_asset(Prefab_Asset, "Enemies/Slime.prefab");
enemy_entity := instantiate(prefab);

Eventos de colisión y solapamiento (truco común en Unreal)

Si estás acostumbrado a los callbacks de solapamiento/impacto de Unreal (OnComponentBeginOverlap, OnHit), nota que la jugabilidad en CSL a menudo usa consultas en lugar de callbacks de eventos.

Patrón común: consulta componentes cercanos y verifica la distancia:

nearby: [..]Pickup;
Scene.get_all_components_in_range(player_pos, 2.0, ref nearby);
for p: nearby {
    // ...
}

Ver: Navmesh y colisión.

Diferencias de UI (UMG vs UI de CSL)

Los juegos de All Out son móvil primero, así que evita construir UX solo para teclado. Usa las utilidades de UI del motor y los botones de habilidad.

Si necesitas UI personalizada, consulta la documentación de UI y sigue los patrones estándar (no inventes un árbol de widgets tipo UMG a menos que la documentación lo indique).

Flujo de partida, inventario, interactuables

Si buscas equivalentes a sistemas de jugabilidad comunes de Unreal:

• Interactuables: Interactuables

• Inventario: Inventario

• Partidas/emparejamiento / juegos hub: Partidas/emparejamiento / juegos hub

• Agentes de movimiento / NPCs: Agentes de movimiento / NPCs

• Animaciones Spine (si usaste Paper2D / flipbooks): Spine

“gotchas” de Unreal a CSL

• No construyas una capa personalizada de RPC/replicación: comienza desde la lógica con autoridad del servidor y deja que el motor sincronice el estado.

• Evita singletons globales para el estado de jugabilidad: se conectan múltiples jugadores; almacena el estado en el jugador o en la instancia de componente relevante.

• Las importaciones están centralizadas: importa carpetas una vez desde main.csl, no por archivo.

• Prefiere Habilidades para acciones: resuelve la UX móvil + tiempos de reutilización + apuntado de forma consistente.

• Cosméticos vs jugabilidad: mantiene los efectos solo cosméticos locales; mantiene el estado de jugabilidad con autoridad del servidor.

Próximos pasos

• Leer Abilities

• Leer Navmesh y colisión

• Examinar Interactuables y Inventario