Unity

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

---

Si vienes de Unity, te sentirás como en casa con entidades + componentes, una jerarquía, un inspector, y prefabs reutilizables. El mayor cambio de mentalidad es que los juegos de All Out son multijugador primero: el estado del juego se sincroniza por ti, y escribes la mayor parte de la lógica como si fuera autoritativa del servidor por defecto.

Resumen: Qué es diferente frente a Unity

• El multijugador es lo predeterminado: el estado del juego se replica automáticamente del servidor a los clientes. Generalmente no escribes RPC, SyncVars ni lógica de aparición de Netcode.

• Sé intencional sobre dónde se ejecuta el código:

  • Usa entradas de juego/UI que afecten el estado en servidor + cliente local (ver is_local_or_server() patrones en las pautas de autoría de CSL).

  • Usa lógica puramente cosmética solo local.

• Evita el estado singleton global: varios jugadores se conectan a la misma sesión. Prefiere almacenar el estado en el jugador o en componentes del mundo.

• Primero móvil: evita asumir solo teclado a menos que tu juego apunte explícitamente a PC.

Mapa de conceptos (Unity → All Out)

Unity	All Out
Escena	Escena (mundo)
GameObject	Entidad
Transform	Transformación de entidad (posición/rotación/escala)
Componente / MonoBehaviour	Componente (clase CSL que deriva de Componente)
Prefab	Recurso prefab (creado en el editor)
Ventana Jerarquía	Jerarquía
Ventana Inspector	Inspector
Instantiate(prefab)	instantiate(prefab_asset)
Start() / Update()	ao_start / ao_update(dt) ciclo de vida

Diseño del proyecto: dónde viven los “scripts” y los “assets”

• Scripts: El código de tu juego vive en archivos .csl . Los proyectos nuevos comienzan con un main.csl que importa el motor y define puntos de entrada del ciclo de vida. Ver Primeros pasos con CSL.

• Activos: Los recursos del juego viven bajo el directorio /res de tu proyecto y se referencian por ruta sin el prefijo /res (ejemplo: "ui/button.png"). Ver Assets y Resources.

Imports (diferencia importante)

En Unity, cada script de C# se compila y puede usar sus propias directivas using . En All Out, mantén los imports centralizados:

• Importa "core:ao" en main.csl

• Si agregas una carpeta (como ui/), importa la carpeta una vez en main.csl

• Evita agregar imports en otros archivos

Ejemplo:

// main.csl
import "core:ao"
import "ui" // opcional: pone todos los archivos bajo /scripts/ui en alcance

Ciclo de vida: MonoBehaviour → CSL

En Unity normalmente adjuntas un MonoBehaviour a un GameObject e implementas:

• Start() / Awake()

• Update() / LateUpdate()

• OnDestroy()

En CSL, normalmente usarás:

• Procs globales en main.csl (para configuración a nivel de juego)

• Métodos del ciclo de vida del componente en tus componentes

Componente de ejemplo:

// orbiter.csl
Orbiter :: class : Component {
    center: v2;
    radius: float;
    speed: float;
    angle: float;

    ao_start :: method() {
        center = entity.local_position;
        radius = 2.0;
        speed = 1.0;
        angle = 0.0;
    }

    ao_update :: method(dt: float) {
        angle += speed * dt;
        offset := v2{cos(angle) * radius, sin(angle) * radius};
        entity->set_local_position(center + offset);
    }
}

Para más contexto sobre el modelo de ciclo de vida, ver Ciclo de vida del juego/fotograma.

Prefabs: Prefabs de Unity → Prefabs de All Out

Los prefabs de All Out se crean en el editor y pueden reutilizarse o generarse en tiempo de ejecución.

• Crear: ver Prefabs

• Generar en tiempo de ejecución:

spawn_enemy :: proc() {
    prefab := get_asset(Prefab_Asset, "Enemies/BasicEnemy.prefab");
    e := instantiate(prefab);
    e->set_local_position({10, 5});
}

El sistema de prefabs está evolucionando. Consulta la sección de limitaciones en la documentación de Prefabs.

“Campos serializados” (variables expuestas en el Inspector)

Unity usa [SerializeField] y campos públicos para exponer valores en el Inspector. En CSL, usa @ao_serialize para exponer un campo al editor.

DamageOnTouch :: class : Component {
    @ao_serialize
    damage: int = 10;
}

Luego agrega tu componente a una entidad en el Inspector y ajusta los valores por entidad.

Generación y consultas: Instantiate/Find → APIs de Scene

Patrones de Unity:

• new GameObject() / Instantiate()

• FindObjectOfType<T>(), GetComponentsInChildren<T>()

Patrones de All Out:

// Crear y destruir entidades
e := Scene.create_entity();
e->set_local_position({0, 0});
e->destroy();

// Iterar entidades (cuando de verdad necesitas "todo")
foreach e2: entity_iterator() {
}

// Iterar componentes de un tipo específico
foreach player: component_iterator(My_Player) {
}

Colisión y triggers: “sin callbacks” por defecto

Si estás acostumbrado a OnTriggerEnter / OnCollisionEnter, ten en cuenta que CSL no se basa en callbacks de colisión para scripting de gameplay. Un patrón común es consultar componentes cercanos y comprobar distancias.

nearby: [..]Pickup;
Scene.get_all_components_in_range(entity.local_position, 2.0, ref nearby);

for p: nearby {
    // comprobar distancia / aplicar efecto / etc.
}

Mentalidad multijugador: entradas, UI y “dónde se ejecuta el código”

En Unity a menudo puedes asumir “mi cliente posee mi personaje”. En All Out, piensa con autoridad del servidor:

• Entrada/UI que afecta el gameplay: ejecútala donde pueda afectar el estado autoritativo (comúnmente servidor + cliente local)

• Elementos cosméticos: solo local

Consulta las pautas de autoría de CSL para ver ejemplos que usan is_local_or_server() frente a is_local().

Errores comunes al pasar de Unity a All Out

• Gestores singleton: prefiere estado por jugador o por entidad en lugar de GameManager singletons de estilo .

• Hábitos de imports: importa el motor y las carpetas desde main.csl (no disperses imports en muchos archivos).

• Asumir un solo jugador: piensa siempre “¿qué pasa con 10 jugadores conectados?”

• Entrada de escritorio codificada de forma fija: evita requerir teclado/ratón a menos que sea intencional.

A dónde ir después

• Primeros pasos con CSL

• Jerarquía

• Inspector

• Prefabs