pedido Agrupando itens

[Caktchup 9]

Galera no meu servidor dropa itens dos pokemon ai arrasta pra mochila ele não fica agrupado de 100 em 100 ele apenas joga sem agrupa ai tem que arrasta junto com os outros. Como eu coloco so arrasta na BP ele automaticamente ja agrupa? de 100 em 100?

[Lordbaxx 291]

Bom primeiro devo dizer que você precisará das sources!

(TESTADO NO TFS 0.3.6)

 

No arquivo container.cpp procure por:

 Cylinder* Container::__queryDestination(int32_t& index, const Thing* thing, Item** destItem, uint32_t&)

troque toda a function por essa:

 

 Cylinder* Container::__queryDestination(int32_t& index, const Thing* thing, Item** destItem, uint32_t&)
{
        if(index == 254 /*move up*/)
        {
                index = INDEX_WHEREEVER;
                *destItem = NULL;
 
                Container* parentContainer = dynamic_cast(getParent());
                if(parentContainer)
                        return parentContainer;
 
                return this;
        }
        else if(index == 255 /*add wherever*/){
                index = INDEX_WHEREEVER;
                *destItem = NULL;
        }
        else if(index >= (int32_t)capacity()){
                        /*
                        if you have a container, maximize it to show all 20 slots
                        then you open a bag that is inside the container you will have a bag with 8 slots
                        and a "grey" area where the other 12 slots where from the container
                        if you drop the item on that grey area
                        the client calculates the slot position as if the bag has 20 slots
                        */
                        index = INDEX_WHEREEVER;
                *destItem = NULL;
        }
 
        const Item* item = thing->getItem();
        if(item == NULL){
                return this;
        }
 
        if(item->isStackable()){
                if(item->getParent() != this){
                        //try find a suitable item to stack with
                        uint32_t n = 0;
                        for(ItemList::iterator cit = itemlist.begin(); cit != itemlist.end(); ++cit){
                                if((*cit) != item && (*cit)->getID() == item->getID() && (*cit)->getItemCount() < 100){
                                        *destItem = (*cit);
                                        index = n;
                                        return this;
                                }
 
                                ++n;
                        }
                }
        }
 
        if(index != INDEX_WHEREEVER){
                Thing* destThing = __getThing(index);
                if(destThing)
                        *destItem = destThing->getItem();
 
                Cylinder* subCylinder = dynamic_cast(*destItem);
 
                if(subCylinder){
                        index = INDEX_WHEREEVER;
                        *destItem = NULL;
                        return subCylinder;
                }
        }
 
        return this;
}

 

 

 

 

2° - De novo container.cpp procure por:

 ReturnValue Container::__queryMaxCount(int32_t index, const Thing* thing, uint32_t count,

Troque a function por essa:

 

 ReturnValue Container::__queryMaxCount(int32_t index, const Thing* thing, uint32_t count,
    uint32_t& maxQueryCount, uint32_t flags) const
{
    const Item* item = thing->getItem();
    if(!item)
    {
        maxQueryCount = 0;
        return RET_NOTPOSSIBLE;
    }

    if(((flags & FLAG_NOLIMIT) == FLAG_NOLIMIT))
    {
        maxQueryCount = std::max((uint32_t)1, count);
        return RET_NOERROR;
    }

    int32_t freeSlots = std::max((int32_t)(capacity() - size()), (int32_t)0);
    if(item->isStackable())
    {
        uint32_t n = 0;
        if(index != INDEX_WHEREEVER)
        {
            const Thing* destThing = __getThing(index);
            const Item* destItem = NULL;
            if(destThing)
                destItem = destThing->getItem();

            if(destItem && destItem->getID() == item->getID())
                n = 100 - destItem->getItemCount();
        }

        maxQueryCount = freeSlots * 100 + n;
        if(maxQueryCount < count)
            return RET_CONTAINERNOTENOUGHROOM;
    }
    else
    {
        maxQueryCount = freeSlots;
        if(maxQueryCount == 0)
            return RET_CONTAINERNOTENOUGHROOM;
    }

    return RET_NOERROR;
}

 

 

 

 

3° - De novo em container cpp procure por:

 

 ReturnValue Container::__queryRemove(const Thing* thing, uint32_t count, uint32_t flags) const

 

 

 

Troque a function por essa:

 

 ReturnValue Container::__queryRemove(const Thing* thing, uint32_t count, uint32_t flags) const
{
    int32_t index = __getIndexOfThing(thing);
    if(index == -1)
        return RET_NOTPOSSIBLE;

    const Item* item = thing->getItem();
    if(item == NULL)
        return RET_NOTPOSSIBLE;

    if(count == 0 || (item->isStackable() && count > item->getItemCount()))
        return RET_NOTPOSSIBLE;

    if(item->isNotMoveable() && !hasBitSet(FLAG_IGNORENOTMOVEABLE, flags))
        return RET_NOTMOVEABLE;

    return RET_NOERROR;
}

 

 

 

 

Créditos: Otland

[Caktchup 9]

Mais meu servidor se eu não tiver enganado e PDA

[Lordbaxx 291]

Mais meu servidor se eu não tiver enganado e PDA

 

Então lamento!

Editado Maio 25, 2015 por Lordbaxx

[Caktchup 9]

Não tem como mesmo?....

[Furabio 257]

^ Não.

 

You see!~

[notle2012 233]

da pra fazer sim em lua mais não tem nem comparação do que fazer pela source

pq pela lua você tem que adicionar os item que vai conhecer para agrupar

eu fiz um sisteminha aqui segue o tutor

 

pasta lib

cria um agrupando.lua

cola isso

 

 

-- config by uotl£
local config = {item = {
    7366,
    7367

}
}
storage_de_notle_agrupamentos = 157852
-- config by uotl£

function onCheckItemDeNotle (cid)
    if isPlayer (cid) then
        for i = 1,#config.item do
			local x = getPlayerItemCount (cid,config.item[i])
            if x ~= 0 then
                doPlayerRemoveItem(cid,config.item[i],x)
                doPlayerAddItem(cid,config.item[i],x)
            end
        end
        if getPlayerStorageValue(cid, storage_de_notle_agrupamentos) == -1 then
            addEvent(onCheckItemDeNotle,750,cid)
        end
    end
    return true
end

nessa parte

local config = {item = {
7366,
7367

}

você tem que colocar os item que vai ser agrupado

 

 

 

agora vai em

data\creaturescripts\scripts

cria agrupando.lua

 

 

    -- config by uotl£

function onLogin(cid)
    doPlayerSendTextMessage(cid,27, "Grupamento Automático Foi Ativado [Para Desativar Diga !agrupando off]")
    setPlayerStorageValue(cid, storage_de_notle_agrupamentos,-1)
    onCheckItemDeNotle (cid)
    return true
end

TAG

<event type="login" name="agrupando" script="agrupando.lua"/> 

 

 

e para finalizar vai em

data\talkactions\scripts

cria agrupando.lua

 

 

function onSay(cid, words, param)
    if isPlayer (cid) then
        if param == "off" then
            setPlayerStorageValue(cid,storage_de_notle_agrupamentos,1)
            doPlayerSendTextMessage(cid,27, "Grupamento Automático Foi Desativar [Para Ativar Diga !agrupando on]")
        elseif param == "on" then
            if isPlayer (cid) then
                if getPlayerStorageValue(cid, storage_de_notle_agrupamentos) == 1 then
                    doPlayerSendTextMessage(cid,27, "Grupamento Automático Foi Ativado")
                    setPlayerStorageValue(cid, storage_de_notle_agrupamentos,-1)
                    onCheckItemDeNotle (cid)
                else
                    doPlayerSendTextMessage(cid,27, "Já Esta Ativado")
                end
                return true
            end
        end
    end
    return true
end

TAG

<talkaction words="!agrupando" script="agrupando.lua"/>

 

 

 

amostra rápida

https://www.youtube.com/watch?v=qlGqCstRosM

Editado Maio 26, 2015 por notle2012

[Bruno 535]

O tópico foi fechado e movido para lixeira por estar inativo a mais de 10 dias. Caso seja preciso reabrir o mesmo, favor entrar em contato com a equipe.