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

[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

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

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. ]