Base para un sistema de inventario

#define MAX_INVENTORY_SLOTS 28 //Slots maximos
#define MAX_ITEM_TYPES 5 //Items maximos de la array "ItemInfo"

enum
{
    e_ITEM_COFRE_HIERRO,
    e_ITEM_COFRE_BRONCE,
    e_ITEM_COFRE_PLATA,
    e_ITEM_COFRE_ORO,
    e_ITEM_COFRE_CRYSTAL
}
enum e_ITEMS
{
    e_Item_TYPE,
    bool:e_Item_SLOT_USED,
    e_ITEM_SLOT,
    e_ITEM_SLOT_CANTIDAD_ALMACENADA
};

new Inventory[MAX_PLAYERS][ e_ITEMS ][ MAX_INVENTORY_SLOTS ];
new ItemCount[MAX_PLAYERS][MAX_ITEM_TYPES];

enum enum_ItemInfo
{
    ID_ITEM_Inventory,
    Item_MaxSave_Slot,
    Item_Name[24]
}
new ItemInfo[MAX_ITEM_TYPES][ enum_ItemInfo ] = //Aca se añaden los objetos o items, el id, la cantidad maxima para guardar en cada slot, y el nombre
{
    {e_ITEM_COFRE_HIERRO, 10, "HIERRO"},
    {e_ITEM_COFRE_BRONCE, 5, "BRONCE"},
    {e_ITEM_COFRE_PLATA, 100, "PLATA"},
    {e_ITEM_COFRE_ORO, 1, "ORO"},
    {e_ITEM_COFRE_CRYSTAL, 1, "CRYSTAL"}
};


CMD:inventarioprueba(playerid, params[]) //Agregar ID del item y la cantidad
{
    new iddd,iddd1;
    if(sscanf(params, "dd",iddd,iddd1)) return SendClientMessage(playerid, -1,"Agregar ID del item y la cantidad");
    AddItemToInventory(playerid, iddd,iddd1);
    return 1;
}
CMD:borrarinventario(playerid, params[]) //Borrar id del item y la cantidad
{
    new iddd,iddd1;
    if(sscanf(params, "dd",iddd,iddd1)) return SendClientMessage(playerid, -1,"Borrar id del item y la cantidad");
    RemoveItemFromInventory(playerid, iddd, iddd1);
    return 1;
}
CMD:buscaritem(playerid, params[]) //Buscar la cantidad especifica de un item mediante la id
{
    new itemid;
    if(sscanf(params, "d",itemid)) return 1;
    CountItemInInventory(playerid, itemid);
    return 1;
}
CMD:inventarioxd(playerid, params[]) //Mostrar los items del inventario. Slot y cantidad.
{
    new string[128];
    format(string, sizeof(string), "Inventario de %s:", GetName(playerid));
    SendClientMessage(playerid, -1, string);

    for(new i = 0; i < MAX_INVENTORY_SLOTS; i++)
    {
        if(Inventory[playerid][e_Item_SLOT_USED][i])
        {
            new itemid = Inventory[playerid][e_Item_TYPE][i];
            new name[24];
            strmid(name, ItemInfo[itemid][Item_Name], 0, sizeof(name));
            new amount = Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][i];
            format(string, sizeof(string), "Slot %d: %s x%d", i + 1, name, amount);
            SendClientMessage(playerid, -1, string);
        }
    }
    return 1;
}


stock AddItemToInventory(playerid, itemid, amount)
{
    if(CanAddItemToInventory(playerid, itemid, amount) == 0) return SendClientMessage(playerid, -1,"** No se puede llenar el inventario con esa cantidad de objetos, intentalo de nuevo.");
    if(CountAvailableSlots(playerid) == 0) return SendClientMessage(playerid, -1,"** No hay slots disponibles.");
    new maxPerSlot = ItemInfo[itemid][Item_MaxSave_Slot];

    //intentamos llenar los slots existentes que ya contienen el mismo tipo de ítem
    for(new i = 0; i < MAX_INVENTORY_SLOTS; i++)
    {
        if(Inventory[playerid][e_Item_SLOT_USED][i] && Inventory[playerid][e_Item_TYPE][i] == itemid)
        {
            new spaceLeft = maxPerSlot - Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][i];
            new toAdd = min(amount, spaceLeft);
            Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][i] += toAdd;
            amount -= toAdd;
            if(amount <= 0)
            {
                break;
            }
        }
    }

    // Si aún quedan ítems por agregar, creamos nuevos slots
    if(amount > 0)
    {
        for(new i = 0; i < MAX_INVENTORY_SLOTS; i++)
        {
            if(!Inventory[playerid][e_Item_SLOT_USED][i])
            {
                Inventory[playerid][e_Item_TYPE][i] = itemid;
                Inventory[playerid][e_Item_SLOT_USED][i] = true;
                Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][i] = min(amount, maxPerSlot);
                amount -= Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][i];
                if(amount <= 0)
                {
                    break;
                }
            }
        }
    }

    if(amount > 0)
    {
        printf("No hay suficientes slots de inventario para almacenar el ítem.");
        return 0;
    }

    ItemCount[playerid][itemid] += amount;

    //reorganizamos el inventario para asegurarnos de que todos los slots estén ordenados correctamente
    OrganizeInventory(playerid);

    return 1;
}
/*
stock RemoveItemFromInventory(playerid, itemid, amount)
{
    // Primero, verificamos si el jugador tiene suficientes ítems para remover
    if(ItemCount[playerid][itemid] < amount)
    {
        SendClientMessage(playerid, -1, "No tienes suficientes ítems para remover esa cantidad.");
        return 0;
    }

    // Luego, removemos los ítems de los slots del inventario
    for(new i = 0; i < MAX_INVENTORY_SLOTS; i++)
    {
        if(Inventory[playerid][e_Item_SLOT_USED][i] && Inventory[playerid][e_Item_TYPE][i] == itemid)
        {
            new toRemove = min(amount, Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][i]);
            Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][i] -= toRemove;
            amount -= toRemove;
            if(Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][i] == 0)
            {
                Inventory[playerid][e_Item_SLOT_USED][i] = false;
                Inventory[playerid][e_Item_TYPE][i] = -1;
            }
            if(amount <= 0)
            {
                break;
            }
        }
    }

    // Actualizamos el recuento total de ítems del jugador
    ItemCount[playerid][itemid] -= amount;

    // Finalmente, reorganizamos el inventario para asegurarnos de que todos los slots estén ordenados correctamente
    OrganizeInventory(playerid);

    return 1;
}
*/
stock RemoveItemFromInventory(playerid, itemid, amount)
{
    //verificamos si el jugador tiene suficientes ítems para remover
    if(ItemCount[playerid][itemid] < amount)
    {
        SendClientMessage(playerid, -1, "No tienes suficientes ítems para remover esa cantidad.");
        return 0;
    }

    //removemos los ítems de los slots del inventario, empezando por los slots con menor cantidad
    new minSlot = -1;
    new minAmount = 999999;
    while(amount > 0)
    {
        minSlot = -1;
        minAmount = 999999;
        for(new i = 0; i < MAX_INVENTORY_SLOTS; i++)
        {
            if(Inventory[playerid][e_Item_SLOT_USED][i] && Inventory[playerid][e_Item_TYPE][i] == itemid && Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][i] < minAmount)
            {
                minSlot = i;
                minAmount = Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][i];
            }
        }
        if(minSlot == -1)
            break;
        new toRemove = min(amount, Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][minSlot]);
        Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][minSlot] -= toRemove;
        amount -= toRemove;
        if(Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][minSlot] == 0)
        {
            Inventory[playerid][e_Item_SLOT_USED][minSlot] = false;
            Inventory[playerid][e_Item_TYPE][minSlot] = -1;
        }
    }

    // Actualizamos el recuento total de ítems del jugador
    ItemCount[playerid][itemid] -= amount;

    //reorganizamos el inventario para asegurarnos de que todos los slots estén ordenados correctamente
    OrganizeInventory(playerid);

    return 1;
}


stock CountAvailableSlots(playerid)
{
    new countxd = 0;
    for(new i = 0; i < MAX_INVENTORY_SLOTS; i++)
    {
        if(!Inventory[playerid][e_Item_SLOT_USED][i])
        {
            countxd++;
        }
    }
    return countxd;
}

stock CanAddItemToInventory(playerid, itemid, amount)
{
    new maxPerSlot = ItemInfo[itemid][Item_MaxSave_Slot];

    //intentamos llenar los slots existentes que ya contienen el mismo tipo de ítem
    for(new i = 0; i < MAX_INVENTORY_SLOTS; i++)
    {
        if(Inventory[playerid][e_Item_SLOT_USED][i] && Inventory[playerid][e_Item_TYPE][i] == itemid)
        {
            new spaceLeft = maxPerSlot - Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][i];
            amount -= min(amount, spaceLeft);
            if(amount <= 0)
            {
                return 1;
            }
        }
    }

    //si aún quedan ítems por agregar, verificamos si hay suficientes slots vacíos
    for(new i = 0; i < MAX_INVENTORY_SLOTS; i++)
    {
        if(!Inventory[playerid][e_Item_SLOT_USED][i])
        {
            amount -= min(amount, maxPerSlot);
            if(amount <= 0)
            {
                return 1;
            }
        }
    }

    //Si aún quedan ítems por agregar, significa que no hay suficiente espacio en el inventario
    if(amount > 0)
    {
        return 0;
    }

    return 1;
}

stock OrganizeInventory(playerid)
{
    new tempInventory[MAX_INVENTORY_SLOTS][3];
    new count = 0;

    // Copiamos todos los slots usados a una matriz temporal
    for(new i = 0; i < MAX_INVENTORY_SLOTS; i++)
    {
        if(Inventory[playerid][e_Item_SLOT_USED][i])
        {
            tempInventory[count][0] = Inventory[playerid][e_Item_TYPE][i];
            tempInventory[count][1] = Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][i];
            tempInventory[count++][2] = ItemInfo[Inventory[playerid][e_Item_TYPE][i]][Item_MaxSave_Slot];
        }
    }

    // Ordenamos la matriz temporal por tipo de ítem y cantidad almacenada
    for(new i = 0; i < count - 1; i++)
    {
        for(new j = i + 1; j < count; j++)
        {
            if(tempInventory[i][0] > tempInventory[j][0] || (tempInventory[i][0] == tempInventory[j][0] && tempInventory[i][1] < tempInventory[j][1]))
            {
                SwapArray(tempInventory[i], tempInventory[j], 3);
            }
        }
    }

    // Copiamos la matriz temporal ordenada de vuelta al inventario del jugador
    for(new i = 0; i < MAX_INVENTORY_SLOTS; i++)
    {
        if(i < count)
        {
            Inventory[playerid][e_Item_TYPE][i] = tempInventory[i][0];
            Inventory[playerid][e_Item_SLOT_USED][i] = true;
            Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][i] = tempInventory[i][1];
            ItemCount[playerid][i] = tempInventory[i][1];

        }
    }

    return 1;
}


stock CountItemInInventory(playerid, itemid)
{
    if(!HasItem(playerid, itemid)) return SendClientMessage(playerid,-1,"No hay de esos items en el inventario");
    new total = 0;
    new string[128];
    format(string, sizeof(string), "Inventario de %s:", GetName(playerid));
    SendClientMessage(playerid, -1, string);

    for(new i = 0; i < MAX_INVENTORY_SLOTS; i++)
    {
        if(Inventory[playerid][e_Item_SLOT_USED][i] && Inventory[playerid][e_Item_TYPE][i] == itemid)
        {
            new amount = Inventory[playerid][e_ITEM_SLOT_CANTIDAD_ALMACENADA][i];
            total += amount;
            format(string, sizeof(string), "Slot %d: %d", i + 1, amount);
            SendClientMessage(playerid, -1, string);
        }
    }

    format(string, sizeof(string), "Total: %d", total);
    SendClientMessage(playerid, -1, string);

    return total;
}


stock HasItem(playerid, itemid)
{
    for(new i = 0; i < MAX_INVENTORY_SLOTS; i++)
    {
        if(Inventory[playerid][e_Item_SLOT_USED][i] && Inventory[playerid][e_Item_TYPE][i] == itemid)
        {
            return 1;
        }
    }
    return 0;
}


stock SwapArray(arr1[], arr2[], size)
{
    new temp;
    for(new i = 0; i < size; i++)
    {
        temp = arr1[i];
        arr1[i] = arr2[i];
        arr2[i] = temp;
    }
}