Primeros pasos con CSL

CSL es el lenguaje de programación personalizado de All Out, creado para hacer que escribir juegos multijugador sea tan fácil como crear juegos para un solo jugador.

CSL es el lenguaje de scripting personalizado de All Out. Es de tipado estático y se parece más a Go/Odin — excepto el estado de la jugabilidad se sincroniza automáticamente del servidor a los clientes.

No necesitas escribir RPCs, SyncVars ni replicación personalizada. Concéntrate en la lógica de juego; la plataforma se encarga de la red por ti.

Tu primer script (main.csl)

Cuando creas un proyecto nuevo, All Out genera un main.csl en la scripts/ carpeta de tu proyecto.

import "core:ao"

// ============================================================================
// Ciclo de vida global
// ============================================================================

ao_before_scene_load :: proc() {
    // Registrar definiciones de objetos, monedas, etc.
    // Se ejecuta antes de que se cree la escena.
}

ao_start :: proc() {
    // Se llama una vez cuando la escena comienza.
}

ao_update :: proc(dt: float) {
    // Se llama en cada fotograma.
}

ao_late_update :: proc(dt: float) {
    // Se llama en cada fotograma después de ao_update.
}

// ============================================================================
// Ciclo de vida del jugador
// ============================================================================

Player :: class : Player_Base {
    ao_start :: method() {
    }

    ao_update :: method(dt: float) {
    }

    ao_late_update :: method(dt: float) {
    }

    ao_end :: method() {
    }
}

Por ejemplo, registra un mensaje cuando se una cada jugador:

Player :: class : Player_Base {
    ao_start :: method() {
        log_info("hola %", {this->get_username()});
    }
}

Si quieres una explicación más profunda de cuándo se ejecutan estas funciones, consulta Ciclo de vida del juego/fotograma.

Importaciones

Tu main.csl debe importar core:ao y cualquier carpeta que crees (como ui/, abilities/, etc.).

import "core:ao"
import "ui"

En la mayoría de los proyectos, importación en main.csl solo. No disperses importaciones por muchos archivos — con el tiempo acabarás con problemas confusos de orden/visibilidad.

Declaraciones (variables y constantes)

Las declaraciones vinculan un nombre a un valor.

Variables

// Forma general
<nombre>: <tipo> = <expresión>;

O bien <tipo> o <expresión> puede omitirse:

// Tipo explícito
my_value: int = 42;

// Inferencia de tipos
my_value := 42; // inferido como int

// Inicialización a cero (igual que my_value := 0;)
my_value: int;

Constantes

Las constantes usan :: y deben ser constantes en tiempo de compilación:

PI :: 3.14159265359;
MAX_PLAYERS :: 12;

Esto no es válido (porque a no es una constante en tiempo de compilación):

a := 123;
b :: a; // error de compilación

Tipos

Tipos primitivos

• Enteros con signo: s8, s16, s32, s64

• Enteros sin signo: u8, u16, u32, u64

• Booleanos: b8, b16, b32, b64

• Flotantes: f32, f64

• Alias:

  • int == s64

  • uint == u64

  • bool == b8

  • float == f32

• Vectores: v2, v3, v4

• string

• typeid

• cualquier

Los tipos Vector

v2 tiene .x, .y; v3 añade .z; v4 añade .w — todos campos float:

pos: v2 = {10, 20};        // x=10, y=20
color: v4 = {1, 0, 0, 1};  // rojo con alpha=1
offset := v3{1, 4, 9};     // inferencia de tipos

Structs y clases

Los structs son tipos por valor (se copian en la asignación). Las clases son tipos por referencia (las asignas con new).

Structs (tipos por valor)

Food_Definition :: struct {
    name: string;
    food_value: int;
}

food: Food_Definition;
food.name = "Apple";
food.food_value = 10;

Clases (tipos por referencia)

Foo :: class {
    value: int;
    position: v2;
}

foo := new(Foo);
foo.value = 123;
foo.position = {12, 34};

Herencia

Los structs/clases pueden heredar de otros structs/clases:

Animal :: class {
    name: string;
    age: int;
}

Dog :: class : Animal {
    breed: string;
}

dog := new(Dog);
dog.name = "Buddy";
dog.age = 5;
dog.breed = "Labrador";

Procedimientos y métodos

Procedimientos (proc)

add :: proc(a: int, b: int) -> int {
    return a + b;
}

result := add(2, 4); // 6

Los procedimientos son valores normales y pueden asignarse/almacenarse como cualquier otro valor:

op := proc(a: int, b: int) -> int { return a + b; };
op = proc(a: int, b: int) -> int { return a * b; };

Métodos (method)

Usa method() dentro de un struct/class. Los métodos tienen un parámetro de referencia implícito this .

Dog :: class {
    name: string;

    bark :: method() {
        log_info("% dice guau!", {name});
    }
}

dog := new(Dog);
dog.name = "Buddy";
dog->bark();

Acceso a campos vs llamadas a métodos

Usa . para campos, -> para métodos:

hp := player.health;        // acceso a campo
player->respawn();          // llamada a método
entity->set_local_scale({2, 2});

Cualquier procedimiento puede llamarse como un “método” si su primer parámetro coincide con el tipo receptor. Este es un patrón común en CSL.

Matrices

CSL tiene unos cuantos tipos “tipo arreglo” que usarás constantemente:

• Arrays fijos: [4]int

• Slices / arrays gestionados: []T (a menudo usado como “vista de solo lectura” de un arreglo)

• Arrays dinámicos: [..]T (lista redimensionable)

• Arreglos no gestionados: [^]T (usado en firmas de API встроadas como format_string, log_info, etc. — pasa valores como {a, b, c})

Los arreglos dinámicos exponen .data, .count, y .capacity, y usan sintaxis de llamada a método para las operaciones:

numbers: [..]int;
numbers->append(10);
numbers->append(20);

log_info("cantidad: %", {numbers.count});
log_info("primero: %", {numbers[0]});

Para una guía completa (incluidos patrones de eliminación), consulta Arrays y colecciones.

Flujo de control

If / else

if hp <= 0 {
    die();
} else if hp < 25 {
    Notifier.notify(player, "¡Salud baja!");
} else {
    // todo bien
}

Switch

Item_Tier :: enum {
    COMMON;
    UNCOMMON;
    RARE;
    EPIC;
    LEGENDARY;
}

get_tier_color :: proc(tier: Item_Tier) -> v4 {
    switch tier {
        case .COMMON:    return {0.7, 0.7, 0.7, 1.0};
        case .UNCOMMON:  return {0.3, 0.8, 0.3, 1.0};
        case .RARE:      return {0.3, 0.5, 1.0, 1.0};
        case .EPIC:      return {0.7, 0.3, 0.9, 1.0};
        case .LEGENDARY: return {1.0, 0.8, 0.2, 1.0};
    }
    return {1, 1, 1, 1};
}

While / for / foreach

while condition {
    // ...
}

// Rango inclusivo: 0..9 incluye 9
for i: 0..9 {
    log_info("i=%", {i});
}

// Iterar elementos de un arreglo/slice
for item: my_items {
    // ...
}

// Con variable de índice
for item, i: my_items {
    log_info("elemento % en el índice %", {item, i});
}

// Iterar iteradores personalizados (común para entidades/componentes)
foreach enemy: component_iterator(Enemy) {
    enemy->update_ai();
}

Conversión de tipos

Usa expr.(T) para convertir:

a := 123.4;
b := a.(int);   // 123
c := b.(float); // 123.0

Pasar por referencia: ref (preferido)

Cuando necesitas modificar un parámetro, prefiere ref sobre los punteros sin procesar.

update_position :: proc(pos: ref v2, velocity: v2, dt: float) {
    pos.x += velocity.x * dt;
    pos.y += velocity.y * dt;
}

my_pos := v2{0, 0};
update_position(ref my_pos, {10, 5}, 0.16);

Callbacks: punteros a funciones + userdata (sin cierres)

CSL no tiene cierres. Los proc(...) { ... } en línea no pueden capturar variables circundantes.

Para transportar contexto, combina los callbacks con un userdata: Object campo:

Player :: class : Player_Base {
    on_death_userdata: Object;
    on_death: proc(player: Player, userdata: Object);

    die :: method() {
        if on_death != null {
            on_death(this, on_death_userdata);
        }
    }
}

Death_Tracker :: class : Component {
    count: int;

    ao_start :: method() {
        player := entity->get_component(Player);
        player.on_death_userdata = this;
        player.on_death = proc(player: Player, userdata: Object) {
            tracker := userdata.(Death_Tracker);
            tracker.count += 1;
        };
    }
}

Información de tipos (tipos como valores)

typeid los valores pueden pasarse a procedimientos polimórficos:

default_of :: proc($T: typeid) -> T {
    t: T;
    return t;
}

a := default_of(int);      // 0
b := default_of(string);   // ""
c := default_of([4]int);   // {0, 0, 0, 0}

Mejores prácticas (CSL en All Out)

• Evita el estado global de jugabilidad. Se conectan varios jugadores — guarda el estado por jugador en Player en su lugar.

• Separa la lógica cosmética de la lógica de jugabilidad. Usa is_local() para UI/partículas solo locales, y is_local_or_server() para entradas de jugabilidad que deben ejecutarse en el servidor + cliente local.

• Valores predeterminados para móvil. No dependas de la entrada de teclado/ratón a menos que tu juego esté explícitamente enfocado en PC.

• Si no estás seguro sobre la sintaxis o las APIs, consulta la api_reference/ carpeta generada en tu proyecto (contiene la última core.csl superficie).