Unreal

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

---

Esta guía es para desarrolladores de Unreal Engine (Blueprints / C++) que están pasando 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 (generados, replicados, poseídos)

• Componentes adjuntos a Actores

• Blueprint graphs / C++ impulsando el gameplay

• RPC + replicación lo defines explícitamente

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

• Entidades en una escena (con componentes)

• Componentes (componentes proporcionados por el motor + tus propios componentes CSL)

• Habilidades para las acciones del jugador (UI primero para móvil + tiempo de reutilización + apuntado)

• Gameplay compartido y predicho donde la sincronización de estado es automática (sin infraestructura RPC personalizada para la mayoría del gameplay)

• Transformaciones 2D using v2 posición y escala más un ángulo de rotación

Mapeo rápido: Unreal → All Out / CSL

Unreal	All Out / CSL	Notas
UWorld / Level	Escena	Las entidades existen en la escena; también puedes crearlas/destruirlas en tiempo de ejecución.
AActor	Entidad	Las entidades tienen transformaciones 2D y componentes.
Ubicación del actor	Entity.local_position / world_position	Decide cómo Unreal X/Y/Z se mapea al plano 2D X/Y del juego.
Rotación del actor	Entity.local_rotation	All Out usa un solo ángulo de rotación en grados.
Escala del actor	Entity.local_scale	All Out usa v2; no existe escala Z de gameplay.
UActorComponent	Component	Defines el gameplay escribiendo componentes CSL y adjuntándolos a 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 habilidades).
Blueprint graphs	Código CSL	Basado en texto, compilado como parte de tu proyecto.
Pawn/Character	Player_Base subclases	La lógica de tu jugador normalmente vive en un Player componente/clase.
Mapeos de entrada	Habilidades + asignaciones de teclas	Prioridad móvil: prefiere botones de habilidades en lugar de entrada cruda.
Replicación (Replicado vars)	Sincronización automática de estado	Escribe una única ruta de gameplay predicha en lugar de versiones separadas de cliente/servidor.
RPCs (Servidor, Cliente, NetMulticast)	Normalmente no se necesita	Usa las facilidades del motor (por ejemplo, notificaciones) en lugar de una proliferación de RPC personalizados.
Generación de actores	Scene.create_entity() / Scene.instantiate(Prefab_Asset)	Los prefabs son assets y pueden instanciarse.
UAsset referencias	get_asset(...)	Los assets viven en /res y se referencian por ruta.

Tu primer archivo CSL (imports)

CSL usa un único patrón de importación “raíz”: importa en main.csly no disperses imports en cada archivo.

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

Entidades y componentes (vs Actores y Componentes)

Creación de 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);

Añadir y acceder a componentes

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

// Destruir la entidad (y sus componentes)
entity.destroy();

Escribir 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);
    }
}

Los procs globales del ciclo de vida se ejecutan en cada simulación de escena participante; no son solo para el servidor. Los clientes que se unan tarde pueden recibir un componente cuyo ciclo de vida de inicio ya se ejecutó, así que reconstruye la presentación a partir del estado sincronizado en ao_on_state_sync cuando sea necesario. Consulta Ciclo de vida del juego/fotograma.

Iteración de entidades/componentes

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

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

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

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

• Una interfaz compatible con móviles de botones

• Tiempos de reutilización

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

Dibuja los botones de habilidad desde Player.ao_late_update interior de ese jugador 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: Habilidades para la API completa y los patrones.

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

Qué es diferente de la replicación de Unreal

• El gameplay normal se ejecuta en el cliente que predice y en el servidor autoritativo.

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

• Aun así debes diseñar pensando en varios jugadores : evita el estado global; guarda el estado por jugador en la instancia del jugador.

• No protejas el gameplay normal con Game.is_server() o desactivarás la predicción.

IU del jugador vs anulaciones visuales locales

Usa estos patrones:

• is_local_or_server() para los controles + IU de gameplay

• is_local() solo para anulaciones visuales específicas del jugador

Player :: class : Player_Base {
    ao_late_update :: method(dt: float) {
        if this.is_local_or_server() {
            // controles + IU de gameplay
        }
        if this.is_local() {
            // anulaciones visuales que solo este jugador debería ver
        }
    }
}

Ver Fundamentos de redes.

Assets, prefabs y rutas

El /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 y pueden instanciarse mediante Escena:

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

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

Un collider habilitado con is_trigger establecido puede llamar a on_trigger_start, on_trigger_stay, y on_trigger_end. Cada callback recibe el collider del trigger y el otro collider. Un Movement_Agent no es necesario.

CSL no expone un callback general de impacto sólido equivalente a OnHit. Usa un trigger para el comportamiento de solapamiento del gameplay. Para detección amplia, consulta componentes cercanos:

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 prioridad móvil, así que evita construir una UX solo para teclado. Usa las utilidades de UI del motor y los botones de habilidades.

Para UI personalizada, empieza con Fundamentos de la UI o Inicio rápido de UIDoc.

Flujo de partida, inventario, interactuables

Si buscas equivalentes a sistemas de gameplay comunes de Unreal:

• Interactuables: Interactuables

• Inventory: Inventory

• Emparejamiento / juegos de hub: Emparejamiento / juegos de hub

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

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

“Trampas” de Unreal a CSL

• No construyas una capa personalizada de RPC/replicación: empieza con la ruta de gameplay compartida y predicha y deja que el motor sincronice el estado.

• No protejas el gameplay con Game.is_server(): el gameplay normal también debe ejecutarse en el cliente que predice.

• Evita singletons globales para el estado del gameplay: se conectan varios jugadores; guarda el estado en el jugador o en la instancia del componente relevante.

• Los imports están centralizados: importa carpetas una sola vez desde main.csl, no por archivo.

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

• Mapea diseños 3D a 2D: usa capas de renderizado en lugar de una transformación Z.

Próximos pasos

• Lee Habilidades

• Lee Navmesh y colisión

• Echa un vistazo Interactuables y Inventory