Referencia Avanzada del Lenguaje

CSL te ofrece algunas herramientas “tipo arreglo” que cubren la mayoría de las necesidades de juego: arreglos fijos, slices y arreglos dinámicos. Esta página es la guía práctica para usarlos sin errores graves.

Glosario rápido

• Arreglo fijo: [N]T — el tamaño se conoce en tiempo de compilación.

• Slice / arreglo gestionado: []T — una vista sobre datos de arreglo (a menudo usado para parámetros).

• Arreglo dinámico: [..]T — lista redimensionable con conteo y capacidad.

fixed: [4]int = {1, 2, 3, 4};
view: []int = fixed; // vista slice

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

Los métodos de arreglos dinámicos usan -> (p. ej. list->append(x)). Los campos usan . (p. ej. list.count).

Arreglos dinámicos ([..]T)

Los arreglos dinámicos son el tipo de “lista por defecto” para el código de juego.

Crear y anexar

players_seen: [..]string;
players_seen->append(player->get_user_id());

Reservar capacidad (rendimiento)

Si sabes que agregarás muchos elementos, reserva primero para evitar realocaciones repetidas.

results: [..]Enemy;
results->reserve(128);

Eliminar elementos

Generalmente eliges entre eliminación rápida (el orden no importa) y eliminación ordenada (preserva el orden).

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

values->unordered_remove_by_value(20); // intercambia con el último, rápido
values->ordered_remove_by_value(10);   // desplaza, conserva el orden

También puedes eliminar por índice:

values->unordered_remove_by_index(0);
values->ordered_remove_by_index(0);

Limpiar

values->clear(); // O(1): simplemente pone el conteo a 0

Pasar arreglos a procedimientos

Muchas APIs aceptan []T (una slice/vista). Los arreglos dinámicos pueden pasarse donde []T se espera.

sum :: proc(arr: []int) -> int {
    total := 0;
    for v: arr {
        total += v;
    }
    return total;
}

nums: [..]int;
nums->append(1);
nums->append(2);
nums->append(3);

total := sum(nums); // implícito [..]int -> []int

Patrones de iteración

Iterar elementos

for v: nums {
    log_info("v=%", {v});
}

Iterar índices (rangos inclusivos)

0..n-1 es común para bucles “estilo ranura”:

for i: 0..inventory.capacity-1 {
    item := inventory->get_item(i);
    if item == null continue;
    // ...
}

Los rangos son inclusivos. Si quieres un bucle típico “0 a count-1”, escribe 0..count-1.

Closures, callbacks y userdata (importante)

CSL no tienen closures. Las proc() { ... } definiciones en línea no pueden capturar variables circundantes.

Cuando necesites callbacks (manejadores de UI, hooks de muerte, etc.), empareja el callback con un userdata: Object campo.

Button_Handler :: class {
    clicks: int;
}

UI_Button :: class {
    on_click_userdata: Object;
    on_click: proc(userdata: Object);
}

setup :: proc(btn: UI_Button, handler: Button_Handler) {
    btn.on_click_userdata = handler;
    btn.on_click = proc(userdata: Object) {
        h := userdata.(Button_Handler);
        h.clicks += 1;
    };
}

Referencia de la API

Cada proyecto incluye una api_reference/ carpeta que contiene la superficie de la API central más reciente. Si estás intentando encontrar “¿qué métodos existen en este tipo?”, esa carpeta es la fuente de la verdad.