[C++] -=[TFS]=- 0.3.6 - 8.60 - PROBLEMA ENCONTRADO FOI NO PLAYER.CPP O ITEM CAI NO SLOT AGORA NÃO CAI MAIS NO CHÃO ITEM AGRUPA EMPILHA AUTOMATICAMENTE NO SLOT MAIS NAO DENTRO DA BACKPACK

[Muvuka 1]

[C++] -=[TFS]=- 0.3.6 - 8.60 - PROBLEMA ENCONTRADO FOI NO PLAYER.CPP

 

O ITEM AGORA CAI SLOT DO PLAYER NÃO CAI MAIS NO CHÃO AQUI ESTA PROBLEMA O ITEM CAI NO SLOT DO PLAYER ELE AGRUPA ITENS EMPILHA AUTOMATICAMENTE MAIS SÓ NO SLOT ELE NAO EMPILHA NA BACKPACK

Cylinder* Player::__queryDestination(int32_t& index, const Thing* thing, Item** destItem, uint32_t& flags)
{
    if (index == 0 /* drop to capacity window */ || index == INDEX_WHEREEVER)
    {
        *destItem = NULL;
        const Item* item = thing->getItem();
        if (!item)
            return this;

        // Tentar encontrar um slot apropriado no inventário
        for (int32_t i = SLOT_FIRST; i < SLOT_LAST; ++i)
        {
            if (!inventory[i])
            {
                if (__queryAdd(i, item, item->getItemCount(), 0) == RET_NOERROR)
                {
                    index = i;
                    return this;
                }
            }
            else if (inventory[i] != tradeItem)
            {
                if (Item* inventoryItem = inventory[i])
                {
                    // Tentar empilhar itens
                    if (inventoryItem->getID() == item->getID() && inventoryItem->isStackable() && inventoryItem->getItemCount() < 100)
                    {
                        *destItem = inventoryItem;
                        index = i;
                        return this;
                    }
                }
            }
        }

        // Tentar adicionar aos containers do inventário
        std::list<std::pair<Container*, int32_t> > deepList;
        for (int32_t i = SLOT_FIRST; i < SLOT_LAST; ++i)
        {
            if (inventory[i] == tradeItem)
                continue;

            if (Container* container = dynamic_cast<Container*>(inventory[i]))
            {
                if (container->__queryAdd(-1, item, item->getItemCount(), 0) == RET_NOERROR)
                {
                    index = INDEX_WHEREEVER;
                    *destItem = NULL;
                    return container;
                }
                deepList.push_back(std::make_pair(container, 0));
            }
        }

        // Verificar mais profundamente nos containers
        int32_t deepness = g_config.getNumber(ConfigManager::PLAYER_DEEPNESS);
        for (std::list<std::pair<Container*, int32_t> >::iterator dit = deepList.begin(); dit != deepList.end(); ++dit)
        {
            Container* c = (*dit).first;
            if (!c || c->empty())
                continue;

            int32_t level = (*dit).second;
            for (ItemList::const_iterator it = c->getItems(); it != c->getEnd(); ++it)
            {
                if ((*it) == tradeItem)
                    continue;

                if (Container* subContainer = dynamic_cast<Container*>(*it))
                {
                    if (subContainer->__queryAdd(-1, item, item->getItemCount(), 0) == RET_NOERROR)
                    {
                        index = INDEX_WHEREEVER;
                        *destItem = NULL;
                        return subContainer;
                    }

                    if (deepness < 0 || level < deepness)
                        deepList.push_back(std::make_pair(subContainer, (level + 1)));
                }
            }
        }

        // Se não encontrou lugar adequado, retorna this
        return this;
    }

    Thing* destThing = __getThing(index);
    if (destThing)
        *destItem = destThing->getItem();

    if (Cylinder* subCylinder = dynamic_cast<Cylinder*>(destThing))
    {
        index = INDEX_WHEREEVER;
        *destItem = NULL;
        return subCylinder;
    }

    return this;
}

 

 

 

Editado Julho 25 por Muvuka

[El Rusher 37]

Aqui está uma modificação na lógica para garantir que os itens sejam empilhados corretamente nos containers (backpacks) dentro do inventário do jogador:
 

Cylinder* Player::__queryDestination(int32_t& index, const Thing* thing, Item** destItem, uint32_t& flags)
{
    if (index == 0 /* drop to capacity window */ || index == INDEX_WHEREEVER)
    {
        *destItem = NULL;
        const Item* item = thing->getItem();
        if (!item)
            return this;

        // Tentar encontrar um slot apropriado no inventário
        for (int32_t i = SLOT_FIRST; i < SLOT_LAST; ++i)
        {
            if (!inventory[i])
            {
                if (__queryAdd(i, item, item->getItemCount(), 0) == RET_NOERROR)
                {
                    index = i;
                    return this;
                }
            }
            else if (inventory[i] != tradeItem)
            {
                if (Item* inventoryItem = inventory[i])
                {
                    // Tentar empilhar itens no inventário
                    if (inventoryItem->getID() == item->getID() && inventoryItem->isStackable() && inventoryItem->getItemCount() < 100)
                    {
                        *destItem = inventoryItem;
                        index = i;
                        return this;
                    }
                }
            }
        }

        // Tentar adicionar ou empilhar nos containers do inventário
        std::list<std::pair<Container*, int32_t> > deepList;
        for (int32_t i = SLOT_FIRST; i < SLOT_LAST; ++i)
        {
            if (inventory[i] == tradeItem)
                continue;

            if (Container* container = dynamic_cast<Container*>(inventory[i]))
            {
                // Verificar se o item pode ser empilhado em um container
                for (Item* containerItem : container->getItemList())
                {
                    if (containerItem->getID() == item->getID() && containerItem->isStackable() && containerItem->getItemCount() < 100)
                    {
                        *destItem = containerItem;
                        index = INDEX_WHEREEVER;
                        return container;
                    }
                }

                // Caso não possa ser empilhado, tentar adicionar no container
                if (container->__queryAdd(-1, item, item->getItemCount(), 0) == RET_NOERROR)
                {
                    index = INDEX_WHEREEVER;
                    *destItem = NULL;
                    return container;
                }

                // Adicionar container ao deepList para verificação em níveis mais profundos
                deepList.push_back(std::make_pair(container, 0));
            }
        }

        // Verificar mais profundamente nos containers (backpacks dentro de backpacks)
        int32_t deepness = g_config.getNumber(ConfigManager::PLAYER_DEEPNESS);
        for (std::list<std::pair<Container*, int32_t> >::iterator dit = deepList.begin(); dit != deepList.end(); ++dit)
        {
            Container* c = (*dit).first;
            if (!c || c->empty())
                continue;

            int32_t level = (*dit).second;
            for (ItemList::const_iterator it = c->getItems(); it != c->getEnd(); ++it)
            {
                if ((*it) == tradeItem)
                    continue;

                if (Container* subContainer = dynamic_cast<Container*>(*it))
                {
                    // Verificar se o item pode ser empilhado em um subContainer
                    for (Item* subContainerItem : subContainer->getItemList())
                    {
                        if (subContainerItem->getID() == item->getID() && subContainerItem->isStackable() && subContainerItem->getItemCount() < 100)
                        {
                            *destItem = subContainerItem;
                            index = INDEX_WHEREEVER;
                            return subContainer;
                        }
                    }

                    // Adicionar item no subContainer
                    if (subContainer->__queryAdd(-1, item, item->getItemCount(), 0) == RET_NOERROR)
                    {
                        index = INDEX_WHEREEVER;
                        *destItem = NULL;
                        return subContainer;
                    }

                    // Verificar profundidade
                    if (deepness < 0 || level < deepness)
                        deepList.push_back(std::make_pair(subContainer, (level + 1)));
                }
            }
        }

        // Se não encontrou lugar adequado, retorna this
        return this;
    }

    Thing* destThing = __getThing(index);
    if (destThing)
        *destItem = destThing->getItem();

    if (Cylinder* subCylinder = dynamic_cast<Cylinder*>(destThing))
    {
        index = INDEX_WHEREEVER;
        *destItem = NULL;
        return subCylinder;
    }

    return this;
}

O que mudou:

• Adicionei uma verificação dentro dos containers para empilhar os itens (loop através dos itens dentro de containers, procurando por itens empilháveis).
• Verifico tanto o nível principal dos containers no inventário quanto containers dentro de containers (como backpacks aninhadas).
• O item será empilhado sempre que possível antes de ser adicionado em um novo espaço.