Comenzando con CSL

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

CSL es el lenguaje de scripts personalizado de All Out. Es tipado estáticamente y se siente más similar a Go/Odin — excepto el estado del juego se sincroniza automáticamente desde el servidor hacia los clientes.

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

Tu primer script (main.csl)

Cuando creas un nuevo proyecto, All Out genera un main.csl en el 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 la escena sea creada.
}

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

ao_update :: proc(dt: float) {
    // Llamado cada frame.
}

ao_late_update :: proc(dt: float) {
    // Llamado cada frame 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 cada jugador se une:

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

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

Importaciones

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

import "core:ao"
import "ui"

En la mayoría de los proyectos, importar en main.csl solo. No esparzas importaciones por muchos archivos — eventualmente terminarás con problemas confusos de orden/visibilidad.

Declaraciones (variables y constantes)

Las declaraciones enlazan un nombre a un valor.

Variables

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

Se puede omitir <tipo> o <expresión> :

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

// Inferencia de tipo
my_value := 42; // inferido a 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 es inválido (porque un no es 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

• Aliases:

  • int == s64

  • uint == u64

  • bool == b8

  • float == f32

• Vectores: v2, v3, v4

• string

• typeid

• any

Tipos vectoriales

v2, v3, y v4 tienen .x, .y, .z, .w 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 tipo

Estructuras y clases

Las structs son tipos por valor (se copian al asignar). 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

Structs/clases pueden heredar de otras 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 una struct/clase. Los métodos tienen un this implícito como parámetro de referencia.

Dog :: class {
    name: string;

    bark :: method() {
        log_info("% says bark!", {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 “método” si su primer parámetro coincide con el tipo receptor. Este es un patrón común en CSL.

Arrays

CSL tiene algunos tipos “similares a arrays” que usarás constantemente:

• Arrays fijos: [4]int

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

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

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

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

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

Para una guía completa (incluidos los 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 array/slice
for item: my_items {
    // ...
}

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

Casting

Usa expr.(T) para castear:

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 punteros crudos.

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 función + userdata (sin closures)

CSL no tiene closures. Inline proc(...) { ... } no puede capturar variables circundantes.

Para transportar contexto, empareja callbacks con un userdata: Object campo:

Player :: class : Component {
    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 valores pueden pasarse a proc 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}

Buenas prácticas (CSL en All Out)

• Evita el estado global de juego. Se conectan múltiples jugadores — almacena el estado por jugador en Jugador en su lugar.

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

• Predeterminados con prioridad móvil. No dependas de la entrada de teclado/ratón a menos que tu juego sea explícitamente enfocado a PC.

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