Language Basics

For the purposes of these docs, we refer to CSL and the runtime/platform around it interchangeably

This page is the “data modeling” side of CSL: primitives, structs/classes, and the patterns you’ll use to represent game state cleanly.

If you’re brand new, start with Getting Started with CSL. This page assumes you already know how to declare variables and write proc/method.

Primitive types

Numbers and bools

• Signed integers: s8, s16, s32, s64 (alias: int == s64)

• Unsigned integers: u8, u16, u32, u64 (alias: uint == u64)

• Floats: f32 (alias: float), f64

• Booleans: b8 (alias: bool), b16, b32, b64

health: int = 100;
speed: float = 6.5;
is_dead: bool = false;

Strings

string is used constantly for IDs, names, and formatting.

item_id := "sword";
log_info("picked up %", {item_id});

Vectors

v2, v3, v4 are built-in math/data types:

pos: v2 = {10, 20};
color: v4 = {1, 0, 0, 1};

Enums

Enums are great for readable “mode/state” fields:

Game_Phase :: enum {
    LOBBY;
    RUNNING;
    POST_GAME;
}

phase := Game_Phase.LOBBY;

if phase == .RUNNING {
    // ...
}

Enum values are commonly referenced with the shorthand .VALUE when the compiler can infer the enum type.

Structs (value types)

Use structs for “plain data” you want to copy around cheaply (config, small state blobs, descriptors).

Damage_Desc :: struct {
    amount: int;
    knockback: v2;
}

hit := Damage_Desc{amount=10, knockback={2, 1}};

When to use a struct

• A descriptor/config object (*_Desc)

• Small, self-contained state you want to copy by value

• Data you want to embed inside another type

When not to use a struct

• Large mutable state shared across multiple systems (use a class)

• “Identity” objects (players, items, long-lived objects) (use a class)

Classes (reference types)

Classes are reference types. Create instances with new(...).

Enemy :: class {
    health: int;
    target: v2;
}

e := new(Enemy);
e.health = 50;
e.target = {0, 0};

Inheritance

You can inherit from other structs/classes:

Weapon_Definition :: class {
    id: string;
    name: string;
}

Gun_Definition :: class : Weapon_Definition {
    fire_rate: float;
}

Use inheritance when there’s a real “is-a” relationship. For most gameplay data, composition (fields) is simpler and easier to maintain.

Arrays, slices, and dynamic arrays

You’ll see three common shapes:

• Fixed arrays: [N]T (compile-time size)

• Slices / managed arrays: []T (a view of an array)

• Dynamic arrays: [..]T (resizable list)

Example:

spawn_points: [4]v2 = {{0,0}, {5,0}, {0,5}, {5,5}};

alive_enemy_ids: [..]int;
alive_enemy_ids->append(123);
alive_enemy_ids->append(456);

For a full guide, see Arrays and Collections.

Passing by reference (ref)

If a procedure needs to modify a value, use ref:

apply_damage :: proc(health: ref int, amount: int) {
    health -= amount;
}

hp := 100;
apply_damage(ref hp, 10);

This is especially useful for “layout-style” APIs that progressively cut/shrink a rect:

draw_panel :: proc(rect: ref Rect) {
    header := rect->cut_top(50);
    draw_header(header);
    // rect is now the remaining area for content
}

Casting

Use expr.(T):

f := 12.7;
i := f.(int);    // 12
f2 := i.(float); // 12.0

Type polymorphism (generic-style procs)

CSL supports polymorphic procedures using $ to deduce types at the callsite:

min :: proc(a: $T, b: T) -> T {
    if a < b return a;
    return b;
}

a := min(10, 20);       // T == int
b := min(1.25, 3.5);    // T == float

Types as values (typeid)

typeid is a value that represents a type at runtime and/or for polymorphic calls:

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

zero := default_of(int);
empty := default_of(string);

Practical modeling guidelines

• Per-player state lives on Player. If it should differ between players, it shouldn’t be global.

• Prefer small structs for descriptors and store runtime state in classes/components.

• Keep server-authoritative data authoritative. If it affects gameplay, don’t compute it only on the client.

For player-specific patterns, see Adding Player Logic. For the ECS side of the world, see Entities and Components.