Spine Animations

You can add animated interactable objects to your game using our existing library of 50k+ Spine rigs.

Spine is how animated characters and props work in All Out (chests, animals, props, VFX rigs, and the player).

To make Spine feel simpler, keep this mental model:

• Spine rig (.spine): the “blueprint” (bones + animation names + skin names)

• Spine_Animator: a component on an entity that renders/updates a Spine rig in the world

• Spine_Instance: the underlying instance you control in code (play animations, switch skins, etc)

• Skins: “outfits/variants” that decide which images are visible

• Animations: named timelines (e.g. "idle", "walk", "open")

When to use Spine_Animator vs Spine_Instance

• Use Spine_Animator for anything that exists in the world (props, NPCs, interactables).

• Use Spine_Instance directly when you want to draw a Spine in UI or you need manual lifetime control.

If you call Spine_Instance.create(), you must call instance->destroy() when you're done (otherwise you leak).

Spine API reference (CSL)

Spine_Animator :: class : Component {
    depth_offset: float;
    layer: s32;
    instance: Spine_Instance #read_only;
}

Spine_Instance :: class {
    create  :: proc() -> Spine_Instance;
    destroy :: method();
    update  :: method(dt: float);

    set_skeleton :: method(asset: Spine_Asset);
    get_skeleton :: method() -> Spine_Asset;

    set_animation :: method(animation: string, loop: bool, track: s64, speed: float = 1);

    // Skins
    set_skin          :: method(skin: string);
    enable_skin       :: method(skin: string);
    disable_skin      :: method(skin: string);
    disable_all_skins :: method();
    refresh_skins     :: method();
    get_skins         :: method() -> []string;

    // Bone local offsets (advanced)
    get_bone_local_position :: method(bone_name: string) -> v2;
    set_bone_local_position :: method(bone_name: string, position: v2);

    // Optional: drive animations via a state machine
    set_state_machine :: method(new_state_machine: State_Machine, transfer_ownership: bool);

    // Visuals
    color_multiplier: v4;
    set_color_replace_color :: method(color: Color_Replace_Color);
}

Adding animated objects to your world

There are 3 ways to add animated objects to your scene, all of which will create a Spine_Animator component.

• Drag any animated asset from the Asset Cataloginto your scene

• Create a new entity and add the Spine_Animator component

  • Set the Skeleton Data Asset field to a .spine file in your assets

• Add a spine animator to your world using scripting (covered in the examples)

If your code and the Spine_Animator are on the same entity and start at the same time, call spine->awaken() before accessing spine.instance.

Examples

Openable Chest

An interactable chest that plays an “open” animation and then stays open:

Chest :: class : Interactable {
    opened: bool;

    ao_start :: method() {
        this->set_listener(this);
        this->set_text("Open");
        radius = 1.25;
        required_hold_time = 0.15;

        spine := entity->get_component(Spine_Animator);
        spine->awaken();
        spine.instance->set_animation("idle", true, 0);
    }

    can_use :: method(player: Player) -> bool {
        return !opened;
    }

    on_interact :: method(player: Player) {
        opened = true;
        this->set_text("Opened");

        spine := entity->get_component(Spine_Animator);
        spine.instance->set_animation("open", false, 0);
    }
}

Walking Chicken

A simple “idle vs walk” loop based on movement:

Chicken :: class : Component {
    speed: float @ao_serialize;
    last_pos: v2;
    was_moving: bool;

    ao_start :: method() {
        speed = 1.5;
        last_pos = entity.world_position;

        spine := entity->get_component(Spine_Animator);
        spine->awaken();
        spine.instance->set_animation("idle", true, 0);
    }

    ao_update :: method(dt: float) {
        // Example motion (patrol)
        entity->add_local_position({speed * dt, 0});

        moving := length_squared(entity.world_position - last_pos) > 0.0001;
        last_pos = entity.world_position;

        if moving != was_moving {
            was_moving = moving;
            spine := entity->get_component(Spine_Animator);
            spine.instance->set_animation(moving ? "walk" : "idle", true, 0);
        }
    }
}

Driveable Car

If you want "driveable" behavior, the simplest approach is to drive the movement with your own gameplay logic, and drive the animation based on whether the car is moving.

Car :: class : Component {
    agent: Movement_Agent @ao_serialize;
    target: Entity @ao_serialize;

    ao_start :: method() {
        spine := entity->get_component(Spine_Animator);
        spine->awaken();
        spine.instance->set_animation("idle", true, 0);
    }

    ao_update :: method(dt: float) {
        if #alive(target) {
            agent->set_path_target(target.world_position, agent.movement_speed);
        }

        moving := length_squared(agent.velocity) > 0.01;
        spine := entity->get_component(Spine_Animator);
        spine.instance->set_animation(moving ? "drive" : "idle", true, 0);
    }
}

If you're switching between only two looping animations, direct set_animation calls are usually simpler than building a state machine.

Skins (variants/outfits)

Some spines don't start with a default skin. If your entity is "invisible", you likely need to pick a skin.

spine := entity->get_component(Spine_Animator);
spine->awaken();

// Option A: set a single skin
spine.instance->set_skin("default");
spine.instance->refresh_skins();

// Option B: combine multiple skins
spine.instance->disable_all_skins();
spine.instance->enable_skin("body");
spine.instance->enable_skin("hat");
spine.instance->refresh_skins();

Always call refresh_skins() after changing skins.

State machines (optional, for complex animation logic)

You can keep animation logic simple by calling set_animation directly. If you have many states (idle/run/attack/hit/death), a State_Machine helps you define transitions once and then just set variables/triggers.

The key idea: state names must match animation names in your Spine file.

What a state machine does

Think of a state machine as a tiny “animation controller”:

• You define states (each state name should match a Spine animation name)

• You define variables (bool, trigger, int, float)

• You define transitions between states based on those variables

• At runtime, you only update variables (the state machine chooses the animation)

Minimal example: idle/walk + attack trigger

NPC_Anim :: class : Component {
    state_machine: State_Machine;
    is_moving: bool;

    ao_start :: method() {
        // 1) Create the state machine + variables
        state_machine = State_Machine.create();
        moving_var := state_machine->create_variable("is_moving", .BOOL);
        attack_var := state_machine->create_variable("attack", .TRIGGER);

        // 2) Create a layer (maps to a Spine track, usually 0)
        layer := state_machine->create_layer("main", 0);

        // 3) Create states (names must match animations in the Spine rig)
        idle := layer->create_state("idle", true);
        walk := layer->create_state("walk", true);
        attack := layer->create_state("attack", false);
        layer->set_initial_state(idle);

        // 4) Movement transitions
        idle_to_walk := layer->create_transition(idle, walk, false);
        idle_to_walk->create_bool_condition(moving_var, true);

        walk_to_idle := layer->create_transition(walk, idle, false);
        walk_to_idle->create_bool_condition(moving_var, false);

        // 5) Attack from any state, then return to idle when complete
        to_attack := layer->create_global_transition(attack, true);
        to_attack->create_trigger_condition(attack_var);

        attack_to_idle := layer->create_transition(attack, idle, true); // require_state_complete = true

        // 6) Attach to the spine instance
        spine := entity->get_component(Spine_Animator);
        spine->awaken();
        spine.instance->set_state_machine(state_machine, true); // transfer_ownership = true
    }

    ao_update :: method(dt: float) {
        state_machine->set_bool("is_moving", is_moving);
    }

    do_attack :: method() {
        state_machine->set_trigger("attack");
    }
}

If you pass transfer_ownership = true to set_state_machine, the Spine_Instance will destroy the state machine for you. Otherwise, you must destroy it yourself.

Troubleshooting

Q: I dragged a spine asset into my scene and I don't see any object, it's just an empty entity

A: Make sure to click "Add Skin" and select a variant of the spine to apply! Some spines don't start with a default skin.

Q: My script crashes when I access spine.instance

A: If your script and the Spine_Animator start at the same time, call spine->awaken() before using spine.instance.

Q: I changed skins but nothing happened

A: After any skin change (set_skin, enable_skin, disable_skin, disable_all_skins), you must call refresh_skins().

Custom Player Skins/Animations

If you want to add custom animations to your player, you can do so by merging the base All Out player spine rig together with a custom rig containing more animations (we can provide many of these, just contact usDeveloper Support)

The Spine Rig Format

Spines rigs are made up of 3 files (automatically downloaded for you when you use the Asset Catalog)

• The skeleton file (.spine) provides information about the bones, skins, and structure of your animated object.

• The atlas image (.png) has the actual textures used to draw the spine in the world.

• The atlas file (.atlas) provides information about where inside the .png atlas image each part of the animated object is.

Creating your own animations

Currently to make your own animations or rigs, you'll need to own a copy of Esoteric Spine. However, we provide a massive library of existing spine rigs and animations as part of the Asset Catalogfor you to use and we recommend starting there!

Export Format

To use a custom Spine rig in All Out, you need to export the standard 3-file Spine bundle into your res folder:

• something.spine

• something.atlas

• something.png (atlas texture)

If you're unsure about export settings, start from an existing All Out Spine asset from the Asset Catalog and mirror its structure or reach out to us!