Main 1.0m (1.0.12) Com Item.bmd de 8 Mil Slots

**romariols** · 11/06/2020, 02:36 AM

A um tempo eu venho trabalhando com este Main, aqui estou trazendo uma versão que eu uso para testes na liberação de um novo Item.bmd com 8000 slots, ele está 90% funcional, ainda não está concluído, mas pode servir para alguém que tenha interesse em fazer o mesmo, não irei disponibilizar os meus códigos completos por motivos pessoais, mas posso garantir que falta apenas algumas funções a serem refeitas, como a releitura das linhas do arquivo. Abaixo deixarei uma parte do código que está sendo trabalhado, uma decompilação parcial do Main feita por meio de um soft de decompilação está inclusa nos arquivos.

Por enquanto eu tive que parar o desenvolvimento para fazer outras coisas mais urgente, isso pode ser de interesse apenas de desenvolvedores.

UnlockSlot.h

Código:

char* __cdecl ReadyCustomSlot(unsigned int a1, int a2);

#define MAX_SLOT_ITEM 8100
#define SlotsX *(DWORD*)0x7CDCDF0
#define SlotsY *(DWORD*)0x7CDCDE4
#define Slot *(DWORD*)0x07CDCDF4;


struct CUSTOM_SLOT
{
    float    X;
    float    Y;
};


class CustomSlots
{
public:
    (void(*)    X);
    DWORD    Y;
private:
    CUSTOM_SLOT MaxSlot[8100];
};
extern CustomSlots CustomSlot;

UnlockSlot.cpp

Código:

size_t __cdecl UnlokFile(void* a1, size_t a2, size_t a3, FILE* a4){
    size_t v4;


    _lock_file(a4);
    v4 = fread(a1, a2, a3, a4);
    _unlock_file(a4);
    return v4;
}


char* __cdecl ReadyCustomSlot(unsigned int a1, int a2)
{
    char* result; int v3; unsigned int v4; signed int v5; int v6; unsigned int v7; char* v8; unsigned int v9; bool v10;    char* v11;
    unsigned int v12; int v13; unsigned int v14; unsigned int v15; unsigned int v16; unsigned int v17; int v18;    void* v19; char* v20;
    signed int v21;    signed int v22;    int v23; int v24; int v25; char v26; result = *(char**)(a1 + 16); v3 = a2 - 4; v4 = (unsigned int)(a2 - *(DWORD*)(a1 + 12)) >> 15;
    v20 = &result[516 * v4 + 324]; v5 = *(DWORD*)(a2 - 4) - 1; v23 = *(DWORD*)(a2 - 4) - 1;


    CustomSlots CustomSlot;


    if (!(v5 & 1))
    {
        v6 = v5 + v3;
        v21 = *(DWORD*)(v5 + v3);
        v22 = *(DWORD*)(a2 - 8);
        v24 = v5 + v3;


        if (!(v21 & 1))
        {
            v7 = (v21 >> 4) - 1;
            if (v7 > 0x3F)
                v7 = 63;
            if (*(DWORD*)(v6 + 4) == *(DWORD*)(v6 + 8))
            {
                if (v7 >= 0x20)
                {
                    v11 = &result[v7 + 4];
                    v12 = ~(0x80000000 >> (v7 - 32));
                    *(DWORD*)&result[4 * v4 + 196] &= v12;
                    v10 = (*v11)-- == 1;
                    if (v10)
                        *(DWORD*)(a1 + 4) &= v12;
                }
                else
                {
                    v8 = &result[v7 + 4];
                    v9 = ~(0x80000000 >> v7);
                    *(DWORD*)&result[4 * v4 + 68] &= v9;
                    v10 = (*v8)-- == 1;
                    if (v10) *(DWORD*)a1 &= v9;
                }
                v13 = v23;
                v6 = v24;
            }
            else
            {
                v13 = v23;
            }
            v5 = v21 + v13;
            *(DWORD*)(*(DWORD*)(v6 + 8) + 4) = *(DWORD*)(v6 + 4);
            v23 = v5;
            *(DWORD*)(*(DWORD*)(v24 + 4) + 8) = *(DWORD*)(v24 + 8);
        }
        v14 = (v5 >> 4) - 1;
        if (v14 > 0x3F)
            v14 = 63;
        if (v22 & 1)
        {
            v15 = a1;
        }
        else
        {
            v25 = v3 - v22;
            v15 = (v22 >> 4) - 1;
            if (v15 > 0x3F)
                v15 = 63;
            v23 = v22 + v5;
            v14 = ((v22 + v5) >> 4) - 1;
            if (v14 > 0x3F)
                v14 = 63;
            if (v15 != v14)
            {
                if (*(DWORD*)(v25 + 4) == *(DWORD*)(v25 + 8))
                {
                    if (v15 >= 0x20)
                    {
                        v17 = ~(0x80000000 >> (v15 - 32));
                        *(DWORD*)&result[4 * v4 + 196] &= v17;
                        v10 = result[v15 + 4]-- == 1;
                        if (v10)
                            *(DWORD*)(a1 + 4) &= v17;
                    }
                    else
                    {
                        v16 = ~(0x80000000 >> v15);
                        *(DWORD*)&result[4 * v4 + 68] &= v16;
                        v10 = result[v15 + 4]-- == 1;
                        if (v10)
                            *(DWORD*)a1 &= v16;
                    }
                }
                *(DWORD*)(*(DWORD*)(v25 + 8) + 4) = *(DWORD*)(v25 + 4);
                *(DWORD*)(*(DWORD*)(v25 + 4) + 8) = *(DWORD*)(v25 + 8);
            }
            v3 = v25;
        }
        if (v22 & 1 || v15 != v14)
        {
            v18 = (int)&v20[8 * v14];
            *(DWORD*)(v3 + 4) = *(DWORD*)&v20[8 * v14 + 4];
            *(DWORD*)(v3 + 8) = v18;
            *(DWORD*)(v18 + 4) = v3;
            *(DWORD*)(*(DWORD*)(v3 + 4) + 8) = v3;
            if (*(DWORD*)(v3 + 4) == *(DWORD*)(v3 + 8))
            {
                v26 = result[v14 + 4];
                result[v14 + 4] = v26 + 1;
                if (v14 >= 0x20)
                {
                    if (!v26)
                        *(DWORD*)(a1 + 4) |= 0x80000000 >> (v14 - 32);
                    *(DWORD*)&result[4 * v4 + 196] |= 0x80000000 >> (v14 - 32);
                }
                else
                {
                    if (!v26)
                        *(DWORD*)a1 |= 0x80000000 >> v14;
                    *(DWORD*)&result[4 * v4 + 68] |= 0x80000000 >> v14;
                }
            }
        }
        *(DWORD*)v3 = v23;    *(DWORD*)(v23 + v3 - 4) = v23;    result += 516 * v4 + 324;    v10 = *(DWORD*)v20 == 1; --* (DWORD*)result;


        if (v10)
        {


            DWORD CustomSlot = (SlotsX + SlotsY * 512);    DWORD CustomSlotX = SlotsX;    DWORD CustomSlotY = SlotsY;


            if (!CustomSlot) // Verifica espaço
            {
                VirtualFree((LPVOID)(*((DWORD*)CustomSlotX + 3) + (CustomSlotY << 15)), 0x8000u, 0x4000u);


                *((DWORD*)CustomSlotX + 2) |= 0x80000000 >> CustomSlotY;
                *(DWORD*)(*((DWORD*)CustomSlotX + 4) + 4 * CustomSlotY + 196) = 0;
                (BYTE*)(*((DWORD*)CustomSlotX + 4) + 67);
                v19 = (BYTE*)(*((DWORD*)CustomSlotX));


                if (!*(BYTE*)(*((DWORD*)CustomSlotX + 4) + 67))
                {
                    *((DWORD*)CustomSlotX + 1) &= 0xFFFFFFFE;
                    v19 = (BYTE*)(*((DWORD*)CustomSlotX));
                }
                if (*((DWORD*)v19 + 2) == -1)
                {
                    VirtualFree(*((LPVOID*)v19 + 3), 0, 0x8000u);
                    //HeapFree(hHeap, 0, *((LPVOID*)CustomSlotX + 4));
                    //memcpy((BYTE*)(*((DWORD*)CustomSlotX)), (char*)CustomSlotX + 20, (size_t)lp + 20 * Slot - (DWORD)CustomSlotX - 20);
                    ((void(*)())0x7CDCDF4)();
                    if (a1 > (unsigned int)CustomSlotX)
                        a1 -= 20;
                    //dword_7CDCDE8 = (int)lp;
                }
            }
            result = (char*)a1;
            CustomSlotY = v4;
            //CustomSlotX = (void*)a1;
        }
    }
    return result;
}

[Somente membros podem ver os links. ]

**Goten** · 11/06/2020, 01:13 PM

Muito bom @[Somente membros podem ver os links. ] espero que você consiga resolver seus problemas pessoais e retorne o mais breve possível com seu desenvolvimento

**benjitrench** · 26/08/2020, 02:14 PM

@[Somente membros podem ver os links. ]
Bad Link :C

**LaMO** · 03/04/2021, 08:48 PM

Originally Posted by romariols

A um tempo eu venho trabalhando com este Main, aqui estou trazendo uma versão que eu uso para testes na liberação de um novo Item.bmd com 8000 slots, ele está 90% funcional, ainda não está concluído, mas pode servir para alguém que tenha interesse em fazer o mesmo, não irei disponibilizar os meus códigos completos por motivos pessoais, mas posso garantir que falta apenas algumas funções a serem refeitas, como a releitura das linhas do arquivo. Abaixo deixarei uma parte do código que está sendo trabalhado, uma decompilação parcial do Main feita por meio de um soft de decompilação está inclusa nos arquivos.

Por enquanto eu tive que parar o desenvolvimento para fazer outras coisas mais urgente, isso pode ser de interesse apenas de desenvolvedores.

UnlockSlot.h

Código:

char* __cdecl ReadyCustomSlot(unsigned int a1, int a2);

#define MAX_SLOT_ITEM 8100
#define SlotsX *(DWORD*)0x7CDCDF0
#define SlotsY *(DWORD*)0x7CDCDE4
#define Slot *(DWORD*)0x07CDCDF4;


struct CUSTOM_SLOT
{
    float    X;
    float    Y;
};


class CustomSlots
{
public:
    (void(*)    X);
    DWORD    Y;
private:
    CUSTOM_SLOT MaxSlot[8100];
};
extern CustomSlots CustomSlot;

UnlockSlot.cpp

Código:

size_t __cdecl UnlokFile(void* a1, size_t a2, size_t a3, FILE* a4){
    size_t v4;


    _lock_file(a4);
    v4 = fread(a1, a2, a3, a4);
    _unlock_file(a4);
    return v4;
}


char* __cdecl ReadyCustomSlot(unsigned int a1, int a2)
{
    char* result; int v3; unsigned int v4; signed int v5; int v6; unsigned int v7; char* v8; unsigned int v9; bool v10;    char* v11;
    unsigned int v12; int v13; unsigned int v14; unsigned int v15; unsigned int v16; unsigned int v17; int v18;    void* v19; char* v20;
    signed int v21;    signed int v22;    int v23; int v24; int v25; char v26; result = *(char**)(a1 + 16); v3 = a2 - 4; v4 = (unsigned int)(a2 - *(DWORD*)(a1 + 12)) >> 15;
    v20 = &result[516 * v4 + 324]; v5 = *(DWORD*)(a2 - 4) - 1; v23 = *(DWORD*)(a2 - 4) - 1;


    CustomSlots CustomSlot;


    if (!(v5 & 1))
    {
        v6 = v5 + v3;
        v21 = *(DWORD*)(v5 + v3);
        v22 = *(DWORD*)(a2 - 8);
        v24 = v5 + v3;


        if (!(v21 & 1))
        {
            v7 = (v21 >> 4) - 1;
            if (v7 > 0x3F)
                v7 = 63;
            if (*(DWORD*)(v6 + 4) == *(DWORD*)(v6 + 8))
            {
                if (v7 >= 0x20)
                {
                    v11 = &result[v7 + 4];
                    v12 = ~(0x80000000 >> (v7 - 32));
                    *(DWORD*)&result[4 * v4 + 196] &= v12;
                    v10 = (*v11)-- == 1;
                    if (v10)
                        *(DWORD*)(a1 + 4) &= v12;
                }
                else
                {
                    v8 = &result[v7 + 4];
                    v9 = ~(0x80000000 >> v7);
                    *(DWORD*)&result[4 * v4 + 68] &= v9;
                    v10 = (*v8)-- == 1;
                    if (v10) *(DWORD*)a1 &= v9;
                }
                v13 = v23;
                v6 = v24;
            }
            else
            {
                v13 = v23;
            }
            v5 = v21 + v13;
            *(DWORD*)(*(DWORD*)(v6 + 8) + 4) = *(DWORD*)(v6 + 4);
            v23 = v5;
            *(DWORD*)(*(DWORD*)(v24 + 4) + 8) = *(DWORD*)(v24 + 8);
        }
        v14 = (v5 >> 4) - 1;
        if (v14 > 0x3F)
            v14 = 63;
        if (v22 & 1)
        {
            v15 = a1;
        }
        else
        {
            v25 = v3 - v22;
            v15 = (v22 >> 4) - 1;
            if (v15 > 0x3F)
                v15 = 63;
            v23 = v22 + v5;
            v14 = ((v22 + v5) >> 4) - 1;
            if (v14 > 0x3F)
                v14 = 63;
            if (v15 != v14)
            {
                if (*(DWORD*)(v25 + 4) == *(DWORD*)(v25 + 8))
                {
                    if (v15 >= 0x20)
                    {
                        v17 = ~(0x80000000 >> (v15 - 32));
                        *(DWORD*)&result[4 * v4 + 196] &= v17;
                        v10 = result[v15 + 4]-- == 1;
                        if (v10)
                            *(DWORD*)(a1 + 4) &= v17;
                    }
                    else
                    {
                        v16 = ~(0x80000000 >> v15);
                        *(DWORD*)&result[4 * v4 + 68] &= v16;
                        v10 = result[v15 + 4]-- == 1;
                        if (v10)
                            *(DWORD*)a1 &= v16;
                    }
                }
                *(DWORD*)(*(DWORD*)(v25 + 8) + 4) = *(DWORD*)(v25 + 4);
                *(DWORD*)(*(DWORD*)(v25 + 4) + 8) = *(DWORD*)(v25 + 8);
            }
            v3 = v25;
        }
        if (v22 & 1 || v15 != v14)
        {
            v18 = (int)&v20[8 * v14];
            *(DWORD*)(v3 + 4) = *(DWORD*)&v20[8 * v14 + 4];
            *(DWORD*)(v3 + 8) = v18;
            *(DWORD*)(v18 + 4) = v3;
            *(DWORD*)(*(DWORD*)(v3 + 4) + 8) = v3;
            if (*(DWORD*)(v3 + 4) == *(DWORD*)(v3 + 8))
            {
                v26 = result[v14 + 4];
                result[v14 + 4] = v26 + 1;
                if (v14 >= 0x20)
                {
                    if (!v26)
                        *(DWORD*)(a1 + 4) |= 0x80000000 >> (v14 - 32);
                    *(DWORD*)&result[4 * v4 + 196] |= 0x80000000 >> (v14 - 32);
                }
                else
                {
                    if (!v26)
                        *(DWORD*)a1 |= 0x80000000 >> v14;
                    *(DWORD*)&result[4 * v4 + 68] |= 0x80000000 >> v14;
                }
            }
        }
        *(DWORD*)v3 = v23;    *(DWORD*)(v23 + v3 - 4) = v23;    result += 516 * v4 + 324;    v10 = *(DWORD*)v20 == 1; --* (DWORD*)result;


        if (v10)
        {


            DWORD CustomSlot = (SlotsX + SlotsY * 512);    DWORD CustomSlotX = SlotsX;    DWORD CustomSlotY = SlotsY;


            if (!CustomSlot) // Verifica espaço
            {
                VirtualFree((LPVOID)(*((DWORD*)CustomSlotX + 3) + (CustomSlotY << 15)), 0x8000u, 0x4000u);


                *((DWORD*)CustomSlotX + 2) |= 0x80000000 >> CustomSlotY;
                *(DWORD*)(*((DWORD*)CustomSlotX + 4) + 4 * CustomSlotY + 196) = 0;
                (BYTE*)(*((DWORD*)CustomSlotX + 4) + 67);
                v19 = (BYTE*)(*((DWORD*)CustomSlotX));


                if (!*(BYTE*)(*((DWORD*)CustomSlotX + 4) + 67))
                {
                    *((DWORD*)CustomSlotX + 1) &= 0xFFFFFFFE;
                    v19 = (BYTE*)(*((DWORD*)CustomSlotX));
                }
                if (*((DWORD*)v19 + 2) == -1)
                {
                    VirtualFree(*((LPVOID*)v19 + 3), 0, 0x8000u);
                    //HeapFree(hHeap, 0, *((LPVOID*)CustomSlotX + 4));
                    //memcpy((BYTE*)(*((DWORD*)CustomSlotX)), (char*)CustomSlotX + 20, (size_t)lp + 20 * Slot - (DWORD)CustomSlotX - 20);
                    ((void(*)())0x7CDCDF4)();
                    if (a1 > (unsigned int)CustomSlotX)
                        a1 -= 20;
                    //dword_7CDCDE8 = (int)lp;
                }
            }
            result = (char*)a1;
            CustomSlotY = v4;
            //CustomSlotX = (void*)a1;
        }
    }
    return result;
}

[Somente membros podem ver os links. ]

Link offline :/

**labmu** · 30/05/2021, 11:10 PM

Peço que verifique o link de Download e nome do tópico por favor pois o main.exe 1.0.12 na verdade é o 1.0L, excelente main.exe e post.

**G00d** · 31/05/2021, 11:33 AM

Link offline :/

**romariols** · 02/06/2021, 11:21 AM

Vou ver nas minhas coisas se ainda tenho isso, deixei isso de lado, se conseguir achar, atualizo o link.

**labmu** · 02/06/2021, 11:26 AM

Vai ajuda muito obrigado é um main.exe muito interessante.

**praquenome** · 23/04/2023, 03:48 PM

Alguem poderia reupar?

**Jukas** · 09/11/2023, 09:56 PM

como eu usaria esse main no muserver do titans mano pode me ajuda

Tópico: Main 1.0m (1.0.12) Com Item.bmd de 8 Mil Slots

Thread Tools

Pesquisar Tópico

Display

Main 1.0m (1.0.12) Com Item.bmd de 8 Mil Slots

The Following 4 Users Say Thank You to romariols For This Useful Post:

The Following User Says Thank You to romariols For This Useful Post:

Permissões de Postagem

Sobre nós

Nossos anunciantes

Rede Sociais