Inventory

Resumen

All Out proporciona una API de inventario de jugador que te permite crear objetos, dárselos a los jugadores y permitir que los jugadores organicen, usen y suelten objetos en tu juego.

Hay tres conceptos principales:

• Definiciones de objetos (Item_Definition): qué es un objeto es (nombre/icono/apilamiento + tus propios campos)

• Instancias de objetos (Item_Instance): una pila real en el mundo/en un inventario

• Inventarios (Inventory): un contenedor de ranuras que almacena instancias de objetos

Cada jugador tiene un inventario integrado en player.default_inventory.

Persistencia

Si quieres que los inventarios de los jugadores se guarden automáticamente entre sesiones de juego, habilita la casilla "Auto Save Player Inventory" en la sección Edit -> Game Settings del editor

Referencia de la API de inventario

Item_Definition_Desc :: struct {
    id:         string;
    name:       string;
    icon:       Texture_Asset;
    stack_size: s64;    // 1 = no apilable, -1 = infinito
    tier:       Item_Tier;
}

Items :: struct {
    // Inventarios
    create_inventory  :: proc(unique_id: string, capacity: s64) -> Inventory;
    destroy_inventory :: proc(inventory: Inventory) -> bool;
    set_capacity      :: proc(inventory: Inventory, capacity: s64);

    // Definiciones e instancias de objetos
    register_item_definition :: proc(desc: Item_Definition_Desc, $Definition_Type: typeid = Item_Definition, instance_type: typeid = Item_Instance) -> Definition_Type;
    create_item_instance     :: proc(definition: Item_Definition, count: s64 = 1) -> Item_Instance;
    create_item_instance     :: proc(definition: Item_Definition, $T: typeid, count: s64 = 1) -> T;
    destroy_item_instance    :: proc(instance: Item_Instance, count: s64 = -1);

    // Mover objetos
    can_move_item_to_inventory                  :: proc(instance: Item_Instance, inventory: Inventory, will_destroy_item: ref bool) -> bool;
    move_item_to_inventory                      :: proc(instance: Item_Instance, inventory: Inventory);
    move_as_many_items_as_possible_to_inventory :: proc(instance: Item_Instance, inventory: Inventory, destroyed_item: ref bool) -> s64;
    remove_item_from_inventory                  :: proc(instance: Item_Instance, inventory: Inventory);
    can_swap_items                              :: proc(inventory_a: Inventory, inventory_b: Inventory, slot_a: s64, slot_b: s64) -> bool;
    swap_items                                  :: proc(inventory_a: Inventory, inventory_b: Inventory, slot_a: s64, slot_b: s64);

    // Consultas
    calculate_room_in_inventory_for_item :: proc(definition: Item_Definition, inventory: Inventory) -> s64;
    destroy_all_items :: proc(inventory: Inventory);

    // UI (opcional)
    draw_inventory :: proc(rect: Rect, inventory: Inventory, options: Inventory_Draw_Options) -> bool;
    draw_hotbar    :: proc(player: Player, inventory: Inventory, options: Inventory_Draw_Options) -> Draw_Hotbar_Result;
}

Inventory :: class : Inventory_Base {
    get_item :: proc(inventory: Inventory, index: s64) -> Item_Instance;
}

Item_Definition :: class : Item_Definition_Base {
    get_name :: method() -> string;
    get_id   :: method() -> string;
    get_icon :: method() -> Texture_Asset;
}

Item_Instance :: class : Item_Instance_Base {
    get_definition :: method() -> Item_Definition;
}

Inicio rápido (registrar + dar un objeto)

Registra las definiciones de objetos una sola vez en ao_before_scene_load, luego crea instancias y muévelas al inventario de un jugador.

// Opcional: tipos personalizados de objetos
Weapon_Definition :: class : Item_Definition {
    damage: s64;
}

Weapon_Item :: class : Item_Instance {
    durability: s64 @ao_serialize; // @ao_serialize hace que este campo se guarde automáticamente entre sesiones
}

sword_defn: Weapon_Definition;

ao_before_scene_load :: proc() {
    sword_defn = Items.register_item_definition(
        {id="sword", name="Espada de Hierro", icon=get_asset(Texture_Asset, "icons/sword.png"), stack_size=1, tier=.COMMON},
        Weapon_Definition,
        Weapon_Item
    );
    sword_defn.damage = 10;
}

give_sword :: proc(player: Player) {
    item := Items.create_item_instance(sword_defn, Weapon_Item);

    will_destroy: bool;
    if Items.can_move_item_to_inventory(item, player.default_inventory, ref will_destroy) {
        item.durability = 100;
        Items.move_item_to_inventory(item, player.default_inventory);
    }
    else {
        // Inventario lleno → destruye la instancia que creamos
        Items.destroy_item_instance(item);
    }
}

Mostrando la barra rápida

Para mostrar en pantalla la interfaz estándar de barra rápida del inventario, llama a Items.draw_hotbar dentro del ao_late_update método de tu Player. ¡Sin esto, el sistema de inventario funciona en segundo plano pero el jugador no lo verá!

Player :: class : Player_Base {
    ao_late_update :: method(dt: float) {
        if this->is_local_or_server() {
            draw_player_hotbar(this);
        }
    }
}

draw_player_hotbar :: proc(player: Player) {
    options := Inventory_Draw_Options.default();
    result := Items.draw_hotbar(player, player.default_inventory, options);

    // result.selected_item es el objeto actualmente resaltado (o null)
    // result.inventory_open te indica si la UI completa de la mochila está visible
}

Items.draw_hotbar maneja por ti toda la UI de la barra rápida + el interruptor de mochila. Devuelve un Draw_Hotbar_Result con selected_item, selected_item_index, inventory_open, y dropped_item campos.

Comprobar si un jugador ya tiene un objeto

Un patrón común es dar un objeto solo si el jugador no tiene ya uno:

player_has_item :: proc(player: Player, definition: Item_Definition) -> bool {
    inv := player.default_inventory;
    for i: 0..inv.capacity-1 {
        item := inv->get_item(i);
        if item != null && item->get_definition() == definition {
            return true;
        }
    }
    return false;
}

give_sword_if_needed :: proc(player: Player) {
    if player_has_item(player, sword_defn) return;
    give_sword(player);
}

También puedes comprobar cuánto espacio queda para un tipo de objeto específico antes de crearlo:

room := Items.calculate_room_in_inventory_for_item(sword_defn, player.default_inventory);
if room > 0 {
    give_sword(player);
}

Inventarios personalizados

Puedes crear inventarios que no estén ligados a un jugador, para cosas como:

• Cofres / contenedores de almacenamiento

• Equipos de peces/mobs

chest_inventory := Items.create_inventory("chest_01", 12);

Para acceder a los objetos:

for i: 0..chest_inventory.capacity-1 {
    item := chest_inventory->get_item(i);
    if item == null continue;
    defn := item->get_definition();
    log_info("Ranura %: %", {i, defn->get_name()});
}

Objetos sueltos

Si quieres que los jugadores suelten objetos en el mundo (y que otros jugadores puedan recogerlos), usa el sistema de objetos sueltos:

import "core:dropped_items"

Generar un objeto suelto

item := Items.create_item_instance(sword_defn, Weapon_Item);
dropped := Dropped_Item.spawn(player.entity.world_position, item);

Animación de soltar + ajuste a la navmesh

server_rng: u64;

dropped->do_spawn_animation(ref server_rng, navmesh); // navmesh es opcional

Gestionar arrastrar y soltar desde la UI de la barra rápida

Si usas Items.draw_hotbar, los jugadores pueden arrastrar un objeto fuera de la UI para soltarlo. Dropped_Item.handle_dropped_item lo elimina del inventario y genera una entidad de objeto suelto.

result := Items.draw_hotbar(player, player.default_inventory, Inventory_Draw_Options.default());

dropped: Dropped_Item;
if Dropped_Item.handle_dropped_item(result, player.entity.world_position, ref dropped) {
    dropped->do_spawn_animation(ref server_rng, navmesh);
}

Los objetos sueltos desaparecen automáticamente con el tiempo (con una barra de advertencia). Mantener pulsado el botón de interactuar sobre un objeto reinicia su temporizador de desaparición.

Puedes hacer que un objeto suelto sea exclusivo (solo visible/recogible por un jugador) usando dropped->set_exclusive(player).