Potion Stack automatico

[ADMTec]

Queria saber se alguem poderia me ajudar a descobrir como eu posso fazer com que as potions se juntem automaticamente!!!

exemplo: quando tem no inventario potions separadas, e possivel pegar e colocar uma encima da outra e formar um pacote de duas potions, indo ate 3 potion!!

eu queria saber se e possivel fazer ir ate 255 potions!!

[LEGENDARY]

Queria saber se alguem poderia me ajudar a descobrir como eu posso fazer com que as potions se juntem automaticamente!!!

exemplo: quando tem no inventario potions separadas, e possivel pegar e colocar uma encima da outra e formar um pacote de duas potions, indo ate 3 potion!!

eu queria saber se e possivel fazer ir ate 255 potions!!

Olá tudo bem?
O maximo realmente seria 255 , não tem como alterar...
nessa questão de colocar potion um em cima do outro - precisa saber mexer na source do emulador se casso tiver...
caso não , é impossível.
Eu não sei fazer tal mas, fica meu Up para o post...

Up.

[antoniodel]

Se for muemu vc vai em MuServer/Data/Item/ItemStack.txt
em seguida vc pode adicionar a linha do pot com a quantidade máxima que desejar, exemplo, 20 pot de hp, se passar dos 20 automaticamente ele cria um outro pot no inventario no espaço que estiver vazio, vou lhe dar um exemplo do meu servidor.

//Index   MaxStack   CreateIndex   Comment
7168      50          *             //Apple
7169      20          *             //Small Healing Potion
7170      20          *             //Healing Potion
7171      20          *             //Large Healing Potion
7172      20          *             //Small Mana Potion
7173      20          *             //Mana Potion
7174      20          *             //Large Mana Potion
7197      5          7196          //Symbol of Kundun
end

Em Index, vc tem que calcular a categoria e a index do item, isso com certeza vc deve saber, a apple é 14*512 + 0 = 7168, em MaxStarck é o limite que vc deseja colocar, lembrando que o máximo é de 255, CreateIndex funciona apenas em items que criar outro item, exemplo se juntar 5 Symbol of Kundun ele criar o mapa que serve de portal para Kalima, então vc coloca o Index do Symbol of Kundun e em CreateIndex vc colocar a index do Mapa que vai para kalima.

Eu coloquei para no máximo ser comprimida em apenas 50 maçãs, para pot de hp tanto o pequeno, médio e grande coloquei para se ter um limite de 20 pot, passando disso ele cria outro pot e recomeça a contagem ate os 20.

[ADMTec]

Se for muemu vc vai em MuServer/Data/Item/ItemStack.txt
em seguida vc pode adicionar a linha do pot com a quantidade máxima que desejar, exemplo, 20 pot de hp, se passar dos 20 automaticamente ele cria um outro pot no inventario no espaço que estiver vazio, vou lhe dar um exemplo do meu servidor.

//Index   MaxStack   CreateIndex   Comment
7168      50          *             //Apple
7169      20          *             //Small Healing Potion
7170      20          *             //Healing Potion
7171      20          *             //Large Healing Potion
7172      20          *             //Small Mana Potion
7173      20          *             //Mana Potion
7174      20          *             //Large Mana Potion
7197      5          7196          //Symbol of Kundun
end

Em Index, vc tem que calcular a categoria e a index do item, isso com certeza vc deve saber, a apple é 14*512 + 0 = 7168, em MaxStarck é o limite que vc deseja colocar, lembrando que o máximo é de 255, CreateIndex funciona apenas em items que criar outro item, exemplo se juntar 5 Symbol of Kundun ele criar o mapa que serve de portal para Kalima, então vc coloca o Index do Symbol of Kundun e em CreateIndex vc colocar a index do Mapa que vai para kalima.

Eu coloquei para no máximo ser comprimida em apenas 50 maçãs, para pot de hp tanto o pequeno, médio e grande coloquei para se ter um limite de 20 pot, passando disso ele cria outro pot e recomeça a contagem ate os 20.

E isso que eu quero fazer mas, eu utilizo o muserver da IGCN, eu consigo fazer a potion das shops ficarem com pacotes de 255, mas elas não se juntam se eu tiver dois pacotes de 25 potions no meu inventario e eu por um encima do outro !!!

[antoniodel]

Esta utilizando o servidor Free da IGC ou o Premium? eu posso rever isso para vc, de 2015 para cá ando mexendo muito no server da xteam/muemu.

[ADMTec]

to usando a source liberada !!

Esta utilizando o servidor Free da IGC ou o Premium? eu posso rever isso para vc, de 2015 para cá ando mexendo muito no server da xteam/muemu.

to tentando descobrir um jeito de fazer isso, ja achei algo que me parece ser o caminho, mas onde eu cheguei foi meu limite de conhecimento !

vou deixar algumas imagens aqui

se alguem puder me ajudar com isso agradeceria muito!



Pelo que eu entendi deste código alguns items tem relação com o máximo de itens overlep com a durabilidade deles, so que a categoria 14 não tem durabilidade nos arquivos da IGCN.

<Section Index="14" Name="Jewel and Misc">        <Item Index="0" Slot="-1" SkillIndex="0" Width="1" Height="1" Serial="0" Option="0" Drop="1" Money="5" DropLevel="1" Type="0" Dump="1" Transaction="1" PersonalStore="1" StoreWarehouse="1" SellToNPC="1" Repair="0" KindA="0" KindB="51" Overlap="255" Name="Apple" ModelPath="Data\Item\" ModelFile="Potion01.bmd" />
        <Item Index="1" Slot="-1" SkillIndex="0" Width="1" Height="1" Serial="0" Option="0" Drop="1" Money="10" DropLevel="10" Type="0" Dump="1" Transaction="1" PersonalStore="1" StoreWarehouse="1" SellToNPC="1" Repair="0" KindA="0" KindB="51" Overlap="255" Name="Small Healing Potion" ModelPath="Data\Item\" ModelFile="Potion02.bmd" />
        <Item Index="2" Slot="-1" SkillIndex="0" Width="1" Height="1" Serial="0" Option="0" Drop="1" Money="20" DropLevel="25" Type="0" Dump="1" Transaction="1" PersonalStore="1" StoreWarehouse="1" SellToNPC="1" Repair="0" KindA="0" KindB="51" Overlap="255" Name="Healing Potion" ModelPath="Data\Item\" ModelFile="Potion03.bmd" />
        <Item Index="3" Slot="-1" SkillIndex="0" Width="1" Height="1" Serial="0" Option="0" Drop="1" Money="30" DropLevel="40" Type="0" Dump="1" Transaction="1" PersonalStore="1" StoreWarehouse="1" SellToNPC="1" Repair="0" KindA="0" KindB="51" Overlap="255" Name="Large Healing Potion" ModelPath="Data\Item\" ModelFile="Potion04.bmd" />
        <Item Index="4" Slot="-1" SkillIndex="0" Width="1" Height="1" Serial="0" Option="0" Drop="1" Money="10" DropLevel="10" Type="0" Dump="1" Transaction="1" PersonalStore="1" StoreWarehouse="1" SellToNPC="1" Repair="0" KindA="0" KindB="51" Overlap="255" Name="Small Mana Potion" ModelPath="Data\Item\" ModelFile="Potion05.bmd" />
        <Item Index="5" Slot="-1" SkillIndex="0" Width="1" Height="1" Serial="0" Option="0" Drop="1" Money="20" DropLevel="25" Type="0" Dump="1" Transaction="1" PersonalStore="1" StoreWarehouse="1" SellToNPC="1" Repair="0" KindA="0" KindB="51" Overlap="255" Name="Mana Potion" ModelPath="Data\Item\" ModelFile="Potion06.bmd" />
        <Item Index="6" Slot="-1" SkillIndex="0" Width="1" Height="1" Serial="0" Option="0" Drop="1" Money="30" DropLevel="40" Type="0" Dump="1" Transaction="1" PersonalStore="1" StoreWarehouse="1" SellToNPC="1" Repair="0" KindA="0" KindB="51" Overlap="255" Name="Large Mana Potion" ModelPath="Data\Item\" ModelFile="Potion07.bmd" />

Eu to estudando a source da MUEMU pra tentar entender como eles fizeram mas to com dificuldade!

segue algumas linhas do codigo da MUEMU

ItemStack.h:

// ItemStack.h: interface for the CItemStack class.//
//////////////////////////////////////////////////////////////////////


#pragma once


struct ITEM_STACK_INFO
{
    int Index;
    int MaxStack;
    int CreateItemIndex;
};


class CItemStack
{
public:
    CItemStack();
    virtual ~CItemStack();
    void Load(char* path);
    int GetItemMaxStack(int index);
    int GetCreateItemIndex(int index);
private:
    std::map<int,ITEM_STACK_INFO> m_ItemStackInfo;
};


extern CItemStack gItemStack;

ItemStack.cpp:

// ItemStack.cpp: implementation of the CItemStack class.//
//////////////////////////////////////////////////////////////////////


#include "stdafx.h"
#include "ItemStack.h"
#include "ItemManager.h"
#include "MemScript.h"
#include "Util.h"


CItemStack gItemStack;
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////


CItemStack::CItemStack() // OK
{
    this->m_ItemStackInfo.clear();
}


CItemStack::~CItemStack() // OK
{


}


void CItemStack::Load(char* path) // OK
{
    CMemScript* lpMemScript = new CMemScript;


    if(lpMemScript == 0)
    {
        ErrorMessageBox(MEM_SCRIPT_ALLOC_ERROR,path);
        return;
    }


    if(lpMemScript->SetBuffer(path) == 0)
    {
        ErrorMessageBox(lpMemScript->GetLastError());
        delete lpMemScript;
        return;
    }


    this->m_ItemStackInfo.clear();


    try
    {
        while(true)
        {
            if(lpMemScript->GetToken() == TOKEN_END)
            {
                break;
            }


            if(strcmp("end",lpMemScript->GetString()) == 0)
            {
                break;
            }


            ITEM_STACK_INFO info;


            info.Index = lpMemScript->GetNumber();


            info.MaxStack = lpMemScript->GetAsNumber();


            info.CreateItemIndex = lpMemScript->GetAsNumber();


            this->m_ItemStackInfo.insert(std::pair<int,ITEM_STACK_INFO>(info.Index,info));
        }
    }
    catch(...)
    {
        ErrorMessageBox(lpMemScript->GetLastError());
    }


    delete lpMemScript;
}


int CItemStack::GetItemMaxStack(int index) // OK
{
    std::map<int,ITEM_STACK_INFO>::iterator it = this->m_ItemStackInfo.find(index);


    if(it == this->m_ItemStackInfo.end())
    {
        return 0;
    }
    else
    {
        return it->second.MaxStack;
    }
}


int CItemStack::GetCreateItemIndex(int index) // OK
{
    std::map<int,ITEM_STACK_INFO>::iterator it = this->m_ItemStackInfo.find(index);


    if(it == this->m_ItemStackInfo.end())
    {
        return -1;
    }
    else
    {
        return it->second.CreateItemIndex;
    }
}

EventeInventory.cpp:

//////Linha 254 Inicio //////

bool CEventInventory::EventInventoryInsertItemStack(LPOBJ lpObj,CItem* lpItem) // OK
{
    #if(GAMESERVER_UPDATE>=802)


    int MaxStack,CreateItemIndex;


    if(lpItem->IsItem() == 0)
    {
        return 0;
    }


    if((MaxStack=gItemStack.GetItemMaxStack(lpItem->m_Index)) <= 0)
    {
        return 0;
    }


    for(int n=0;n < EVENT_INVENTORY_SIZE;n++)
    {
        if(lpObj->EventInventory[n].IsItem() != 0)
        {
            if(lpObj->EventInventory[n].m_Index == lpItem->m_Index && lpObj->EventInventory[n].m_Level == lpItem->m_Level && lpObj->EventInventory[n].m_SocketOptionBonus == lpItem->m_SocketOptionBonus)
            {
                if(lpObj->EventInventory[n].m_Durability < MaxStack)
                {
                    int AddDur = (int)(MaxStack-lpObj->EventInventory[n].m_Durability);


                    AddDur = ((AddDur>lpItem->m_Durability)?(int)lpItem->m_Durability:AddDur);


                    lpItem->m_Durability -= AddDur;


                    lpObj->EventInventory[n].m_Durability += AddDur;


                    if(lpObj->EventInventory[n].m_Durability == MaxStack && (CreateItemIndex=gItemStack.GetCreateItemIndex(lpItem->m_Index)) != -1)
                    {
                        this->EventInventoryDelItem(lpObj->Index,n);
                        this->GCEventItemDeleteSend(lpObj->Index,n,1);
                        GDCreateItemSend(lpObj->Index,0xEB,0,0,CreateItemIndex,(BYTE)lpItem->m_Level,1,0,0,0,lpObj->Index,0,0,0,0,0,lpItem->m_SocketOptionBonus,0);
                        if(lpItem->m_Durability < 1){return 1;}
                    }
                    else
                    {
                        this->GCEventItemDurSend(lpObj->Index,n,(BYTE)lpObj->EventInventory[n].m_Durability);
                        if(lpItem->m_Durability < 1){return 1;}
                    }
                }
            }
        }
    }


    return 0;


    #else


    return 0;


    #endif
}


bool CEventInventory::EventInventoryAddItemStack(LPOBJ lpObj,int SourceSlot,int TargetSlot) // OK{
    #if(GAMESERVER_UPDATE>=802)


    int MaxStack,CreateItemIndex;


    if(lpObj->EventInventory[SourceSlot].IsItem() == 0 || lpObj->EventInventory[TargetSlot].IsItem() == 0)
    {
        return 0;
    }


    if(lpObj->EventInventory[SourceSlot].m_Index != lpObj->EventInventory[TargetSlot].m_Index || lpObj->EventInventory[SourceSlot].m_Level != lpObj->EventInventory[TargetSlot].m_Level || lpObj->EventInventory[SourceSlot].m_SocketOptionBonus != lpObj->EventInventory[TargetSlot].m_SocketOptionBonus)
    {
        return 0;
    }


    if((MaxStack=gItemStack.GetItemMaxStack(lpObj->EventInventory[SourceSlot].m_Index)) <= 0)
    {
        return 0;
    }


    if(lpObj->EventInventory[TargetSlot].m_Durability >= MaxStack)
    {
        return 0;
    }


    int AddDur = (int)(MaxStack-lpObj->EventInventory[TargetSlot].m_Durability);


    AddDur = ((AddDur>lpObj->EventInventory[SourceSlot].m_Durability)?(int)lpObj->EventInventory[SourceSlot].m_Durability:AddDur);


    lpObj->EventInventory[SourceSlot].m_Durability -= AddDur;


    lpObj->EventInventory[TargetSlot].m_Durability += AddDur;


    if(lpObj->EventInventory[TargetSlot].m_Durability == MaxStack && (CreateItemIndex=gItemStack.GetCreateItemIndex(lpObj->EventInventory[SourceSlot].m_Index)) != -1)
    {
        this->EventInventoryDelItem(lpObj->Index,TargetSlot);
        this->GCEventItemDeleteSend(lpObj->Index,TargetSlot,1);
        GDCreateItemSend(lpObj->Index,0xEB,0,0,CreateItemIndex,(BYTE)lpObj->EventInventory[SourceSlot].m_Level,0,0,0,0,lpObj->Index,0,0,0,0,0,lpObj->EventInventory[SourceSlot].m_SocketOptionBonus,0);
    }
    else
    {
        this->GCEventItemDurSend(lpObj->Index,TargetSlot,(BYTE)lpObj->EventInventory[TargetSlot].m_Durability);
    }


    if(lpObj->EventInventory[SourceSlot].m_Durability < 1)
    {
        this->EventInventoryDelItem(lpObj->Index,SourceSlot);
        this->GCEventItemDeleteSend(lpObj->Index,SourceSlot,1);
    }


    return 1;


    #else


    return 0;


    #endif
}

////linha 370 fim///



/////////linha 507 inicio ////////

int CItemManager::GetInventoryItemCount(LPOBJ lpObj,int index,int level) // OK
{
    int count = 0;


    int MaxValue = this->GetInventoryMaxValue(lpObj);


    for(int n=0;n < MaxValue;n++)
    {
        if(lpObj->Inventory[n].IsItem() != 0)
        {
            if(lpObj->Inventory[n].m_Index == index && (level == -1 || lpObj->Inventory[n].m_Level == level))
            {
                if(gItemStack.GetItemMaxStack(lpObj->Inventory[n].m_Index) == 0)
                {
                    count++;
                }
                else
                {
                    count += (int)lpObj->Inventory[n].m_Durability;
                }
            }
        }
    }


    return count;
}
///Linha 532 Fim///



/////////Linha 1178 Inicio////////



bool CItemManager::InventoryInsertItemStack(LPOBJ lpObj,CItem* lpItem) // OK
{
    int MaxStack,CreateItemIndex;


    if(lpItem->IsItem() == 0)
    {
        return 0;
    }


    if((MaxStack=gItemStack.GetItemMaxStack(lpItem->m_Index)) <= 0)
    {
        return 0;
    }


    int MaxValue = this->GetInventoryMaxValue(lpObj);


    for(int n=INVENTORY_WEAR_SIZE;n < MaxValue;n++)
    {
        if(lpObj->Inventory[n].IsItem() != 0)
        {
            if(lpObj->Inventory[n].m_Index == lpItem->m_Index && lpObj->Inventory[n].m_Level == lpItem->m_Level && lpObj->Inventory[n].m_SocketOptionBonus == lpItem->m_SocketOptionBonus)
            {
                if(lpObj->Inventory[n].m_Durability < MaxStack)
                {
                    int AddDur = (int)(MaxStack-lpObj->Inventory[n].m_Durability);


                    AddDur = ((AddDur>lpItem->m_Durability)?(int)lpItem->m_Durability:AddDur);


                    lpItem->m_Durability -= AddDur;


                    lpObj->Inventory[n].m_Durability += AddDur;


                    if(lpObj->Inventory[n].m_Durability == MaxStack && (CreateItemIndex=gItemStack.GetCreateItemIndex(lpItem->m_Index)) != -1)
                    {
                        this->InventoryDelItem(lpObj->Index,n);
                        this->GCItemDeleteSend(lpObj->Index,n,1);
                        GDCreateItemSend(lpObj->Index,0xEB,0,0,CreateItemIndex,(BYTE)lpItem->m_Level,1,0,0,0,lpObj->Index,0,0,0,0,0,lpItem->m_SocketOptionBonus,0);
                        if(lpItem->m_Durability < 1){return 1;}
                    }
                    else
                    {
                        this->GCItemDurSend(lpObj->Index,n,(BYTE)lpObj->Inventory[n].m_Durability,0);
                        if(lpItem->m_Durability < 1){return 1;}
                    }
                }
            }
        }
    }


    return 0;
}



bool CItemManager::InventoryAddItemStack(LPOBJ lpObj,int SourceSlot,int TargetSlot) // OK{
    int MaxStack,CreateItemIndex;


    if(lpObj->Inventory[SourceSlot].IsItem() == 0 || lpObj->Inventory[TargetSlot].IsItem() == 0)
    {
        return 0;
    }


    if(lpObj->Inventory[SourceSlot].m_Index != lpObj->Inventory[TargetSlot].m_Index || lpObj->Inventory[SourceSlot].m_Level != lpObj->Inventory[TargetSlot].m_Level || lpObj->Inventory[SourceSlot].m_SocketOptionBonus != lpObj->Inventory[TargetSlot].m_SocketOptionBonus)
    {
        return 0;
    }


    if((MaxStack=gItemStack.GetItemMaxStack(lpObj->Inventory[SourceSlot].m_Index)) <= 0)
    {
        return 0;
    }


    if(lpObj->Inventory[TargetSlot].m_Durability >= MaxStack)
    {
        return 0;
    }


    int AddDur = (int)(MaxStack-lpObj->Inventory[TargetSlot].m_Durability);


    AddDur = ((AddDur>lpObj->Inventory[SourceSlot].m_Durability)?(int)lpObj->Inventory[SourceSlot].m_Durability:AddDur);


    lpObj->Inventory[SourceSlot].m_Durability -= AddDur;


    lpObj->Inventory[TargetSlot].m_Durability += AddDur;


    if(lpObj->Inventory[TargetSlot].m_Durability == MaxStack && (CreateItemIndex=gItemStack.GetCreateItemIndex(lpObj->Inventory[SourceSlot].m_Index)) != -1)
    {
        this->InventoryDelItem(lpObj->Index,TargetSlot);
        this->GCItemDeleteSend(lpObj->Index,TargetSlot,1);
        GDCreateItemSend(lpObj->Index,0xEB,0,0,CreateItemIndex,(BYTE)lpObj->Inventory[SourceSlot].m_Level,0,0,0,0,lpObj->Index,0,0,0,0,0,lpObj->Inventory[SourceSlot].m_SocketOptionBonus,0);
    }
    else
    {
        this->GCItemDurSend(lpObj->Index,TargetSlot,(BYTE)lpObj->Inventory[TargetSlot].m_Durability,0);
    }


    if(lpObj->Inventory[SourceSlot].m_Durability < 1)
    {
        this->InventoryDelItem(lpObj->Index,SourceSlot);
        this->GCItemDeleteSend(lpObj->Index,SourceSlot,1);
    }


    return 1;
}
//// Linha 1280 Fim


/////////////////Linha 1970 Inicio///////////

int MaxStack = gItemStack.GetItemMaxStack(lpItem->m_Index);

//////// Linha 1970 fim///////



/////////////////Linha 2088 Inicio///////////

void CItemManager::DeleteInventoryItemCount(LPOBJ lpObj,int index,int level,int count) // OK
{
    int MaxValue = this->GetInventoryMaxValue(lpObj);


    for(int n=0;n < MaxValue,count > 0;n++)
    {
        if(lpObj->Inventory[n].IsItem() != 0)
        {
            if(lpObj->Inventory[n].m_Index == index && lpObj->Inventory[n].m_Level == level)
            {
                if(gItemStack.GetItemMaxStack(lpObj->Inventory[n].m_Index) <= 0)
                {
                    this->InventoryDelItem(lpObj->Index,n);
                    this->GCItemDeleteSend(lpObj->Index,n,1);
                    count--;
                }
                else
                {
                    if(lpObj->Inventory[n].m_Durability > count)
                    {
                        lpObj->Inventory[n].m_Durability -= count;
                        this->GCItemDurSend(lpObj->Index,n,(BYTE)lpObj->Inventory[n].m_Durability,0);
                        count = 0;
                    }
                    else
                    {
                        count -= (int)lpObj->Inventory[n].m_Durability;
                        this->InventoryDelItem(lpObj->Index,n);
                        this->GCItemDeleteSend(lpObj->Index,n,1);
                    }
                }
            }
        }
    }
}

//////////Linha 2122 Fim////////

ItemValue.cpp:

/////////////////Linha 81 Inicio///////////


bool CItemValue::GetItemValue(CItem* lpItem,int* value) // OK
{
    for(std::vector<ITEM_VALUE_INFO>::iterator it=this->m_ItemValueInfo.begin();it != this->m_ItemValueInfo.end();it++)
    {
        if(it->Index == lpItem->m_Index)
        {
            if(it->Level == -1 || it->Level == lpItem->m_Level)
            {
                if(it->Grade == -1 || it->Grade == lpItem->m_NewOption)
                {
                    if(gItemStack.GetItemMaxStack(it->Index) == 0 || it->Index == GET_ITEM(4,7) || it->Index == GET_ITEM(4,15))
                    {
                        (*value) = it->Value;
                        return 1;
                    }
                    else
                    {
                        (*value) = (int)(it->Value*lpItem->m_Durability);
                        return 1;
                    }
                }
            }
        }
    }


    return 0;
}


///////Linha 108 Fim//////

ServerInfo.cpp:

//////////////////Linha 401 Inicio////////////////

gItemStack.Load(gPath.GetFullPath("Item\\ItemStack.txt"));

/////////////////////Linha 401 Fim///////////

[ADMBone]

alguem poderia dar essa ajuda tambem quero saber como fazer isso na IGCN season 12 ja que sao sources bem parecidas !

[cronusmaker]

a gs tem quem tar copilada com essa função amigo

[ADMTec]

a gs tem quem tar copilada com essa função amigo

Amigo eu estou querendo descobrir como adicionar isso no meu muserver, eu estou editando a source, nao quero usar o mesmo que tem no da muemu mas sim colocar na minha source da IGCN algo que permita fazer a mesma função. não sei se consegui passar com clareza o que eu quero!

[cronusmaker]

Amigo eu estou querendo descobrir como adicionar isso no meu muserver, eu estou editando a source, nao quero usar o mesmo que tem no da muemu mas sim colocar na minha source da IGCN algo que permita fazer a mesma função. não sei se consegui passar com clareza o que eu quero!

por ser da IGCN ninguem aqui no brasil praticamente vai ter a sorce amigo so eles ou a galera da mu emu que vive crakeando