Inventario

Descripción general

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

Hay tres conceptos principales:

• Definiciones de objetos (Definición_de_objeto): lo que un objeto es (nombre/icono/apilamiento + tus propios campos)

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

• Inventarios (Inventario): un contenedor de casillas que contiene instancias de objetos

Cada jugador tiene un inventario incorporado en player.default_inventory.

Persistencia

Si deseas que los inventarios de los jugadores se guarden automáticamente entre sesiones de juego, activa la casilla "Auto Guardar Inventario del Jugador" en Editar -> Configuración del Juego del editor

Referencia de la API de inventario

Item_Definition_Desc :: struct {
    id:         string;
    name:       string;
    icon:       string; // ruta en /res (omitir "/res/")
    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 de objetos + instancias
    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);

    // 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 definiciones de objetos una vez en ao_before_scene_load, luego crea instancias y muévelas al inventario de un jugador.

// Opcional: tipos de objetos personalizados
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="Iron Sword", icon="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 → destruir la instancia que creamos
        Items.destroy_item_instance(item);
    }
}

Inventarios personalizados

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

• Cofres / contenedores de almacenamiento

• Equipos de peces/enemigos

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

Para acceder a 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 soltados

Si quieres que los jugadores suelten objetos en el mundo (y permitir que otros jugadores los recojan), usa el sistema de objetos soltados:

import "core:dropped_items"

Generar un objeto soltado

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

Animación de caída + ajuste a la malla de navegación

server_rng: u64;

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

Manejo de arrastrar-soltar desde la interfaz de barra rápida

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

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 soltados desaparecen automáticamente con el tiempo (con una barra de advertencia). Mantener presionado el botón de interactuar sobre un objeto reinicia su temporizador de desaparición.

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