TotalLockDown - Instance Logger

#include <Windows.h>
#include <stdio.h>
#include <Psapi.h>

#include <cstring>

DWORD64   GObjObjects_offset = NULL;
DWORD64   Names_offset = NULL;
DWORD   Offset_Name = 0x18;

MODULEINFO GetModuleInfo(LPCTSTR lpModuleName)
{
    MODULEINFO miInfos = { NULL };

    HMODULE hmModule = GetModuleHandle(lpModuleName);

    if (hmModule)
    {
        GetModuleInformation(GetCurrentProcess(), hmModule, &miInfos, sizeof(MODULEINFO));
    }

    return miInfos;
}

template < class T > struct TArray
{
    T*              Data;
    DWORD   Num;
    DWORD   Max;
};

struct UObject
{
    UCHAR   Unknown[0x18];       // unknowed data
    DWORD   NameIndex;                              // struct FName
};

class FUObjectItem
{
public:
    UObject * Object;
    __int32 Flags;
    __int32 ClusterIndex;
    __int32 SerialNumber;
    char unknowndata_00[0x4]; //New
};

class PreFUObjectItem
{
public:
    FUObjectItem * Object_1;
    FUObjectItem * Object_2;
};

class TUObjectArray
{
public:
    PreFUObjectItem * Objects;
    char unknowndata_00[0x8]; //New
    __int32 MaxElements;
    __int32 NumElements;
};

class FUObjectArray
{
public:
    __int32 ObjFirstGCIndex; //0x0000
    __int32 ObjLastNonGCIndex; //0x0004
    __int32 MaxObjectsNotConsideredByGC; //0x0008
    __int32 OpenForDisregardForGC; //0x000C

    TUObjectArray ObjObjects;
};

struct FNameEntry
{
    int Index;
    char pad_0x0004[0x4];
    FNameEntry* HashNext;
    char AnsiName[1024];
};

class TNameEntryArray
{
private:
    DWORD64 * chunks;

public:
    FNameEntry const* const& GetById(int Index) const
    {
        if (!chunks ||
            !*(DWORD64*)chunks ||
            !(DWORD64*)(*(DWORD64*)chunks) ||
            !(DWORD64*)(*(DWORD64*)(chunks + 1)) ||
            !(DWORD64*)(*(DWORD64*)(chunks + 2)) ||
            !(DWORD64*)(*(DWORD64*)(chunks + 3))) return NULL;

        if (Index * 0x8 < 0x20000)
            return *(FNameEntry**)(*(DWORD64*)chunks + (Index * 0x8));
        else if (Index * 0x8 >= 0x20000
            && Index * 0x8 < (0x20000 * 2))
            return *(FNameEntry**)(*(DWORD64*)(chunks + 1) + (Index * 0x8 - 0x20000));
        else if (Index * 0x8 >= (0x20000 * 2)
            && Index * 0x8 < (0x20000 * 3))
            return *(FNameEntry**)(*(DWORD64*)(chunks + 2) + (Index * 0x8 - (0x20000 * 2)));
        else if (Index * 0x8 >= (0x20000 * 3)
            && Index * 0x8 < (0x20000 * 4))
        {
            if (!*(DWORD64*)(chunks + 3)
                || !*(DWORD64*)(*(DWORD64*)(chunks + 3) + (Index * 0x8 - (0x20000 * 3)))
                || !*(DWORD64**)(*(DWORD64*)(chunks + 3) + (Index * 0x8 - (0x20000 * 3))))
                return NULL;

            return *(FNameEntry**)(*(DWORD64*)(chunks + 3) + (Index * 0x8 - (0x20000 * 3)));
        }
        else
            return NULL;
    }

    bool IsValidIndex(int index) const
    {
        return index >= 0 && index < (0x20000 * 4) && GetById(index) != nullptr;
    }
};

FUObjectArray* GObjObjects = NULL;
TNameEntryArray* Names = NULL;

char* GetName(UObject* Object)
{
    DWORD NameIndex = *(PDWORD)((DWORD64)Object + Offset_Name);

    if (NameIndex < 0 || NameIndex >(0x20000 * 4))
    {
        static char ret[256];
        sprintf_s(ret, "INVALID NAME INDEX : %i > %i", NameIndex, (0x20000 * 4));
        return ret;
    }
    else
    {
        return (char*)Names->GetById(NameIndex)->AnsiName;
    }
}

void ObjectDump()
{
    FILE* Log = NULL;
    fopen_s(&Log, "ObjectDump.txt", "w+");

    for (DWORD64 i = 0x0; i < (GObjObjects->ObjObjects.NumElements - 2); i++)
    {
        if (i <= 0xFFFF)
        {
            if (!GObjObjects->ObjObjects.Objects->Object_1[i].Object) { continue; }

            fprintf(Log, "UObject[%06i] %-50s 0x%llX\n", i, GetName(GObjObjects->ObjObjects.Objects->Object_1[i].Object), GObjObjects->ObjObjects.Objects->Object_1[i].Object);
        }
        else if (i > 0xFFFF && i <= 0x1FFFE)
        {
            if (!GObjObjects->ObjObjects.Objects->Object_2[(i - 0xFFFF)].Object) { continue; }

            fprintf(Log, "UObject[%06i] %-50s 0x%llX\n", i, GetName(GObjObjects->ObjObjects.Objects->Object_2[(i - 0xFFFF)].Object), GObjObjects->ObjObjects.Objects->Object_2[(i - 0xFFFF)].Object);
        }
        else
        {
            fclose(Log);
            return;
        }
    }

    fclose(Log);
}

void NameDump()
{
    FILE* Log = NULL;
    fopen_s(&Log, "NameDump.txt", "w+");

    for (DWORD64 i = 0x0; i < (0x20000 * 4); i++)
    {
        if (!Names->GetById(i)) { continue; }

        fprintf(Log, "Name[%06i] %s\n", i, Names->GetById(i)->AnsiName);
    }

    fclose(Log);
}

void onAttach()
{
    MODULEINFO miGame = GetModuleInfo(NULL);

    GObjObjects_offset = (DWORD64)((DWORD64)miGame.lpBaseOfDll + 0x3272CE8);
    Names_offset = ((DWORD64)miGame.lpBaseOfDll + 0x326E880);

    GObjObjects = (FUObjectArray*)GObjObjects_offset;
    Names = (TNameEntryArray*)Names_offset;

    NameDump();
    ObjectDump();
}

BOOL WINAPI DllMain(HMODULE hModule, DWORD dwReason, LPVOID lpReserved)
{
    switch (dwReason)
    {
    case DLL_PROCESS_ATTACH:
        DisableThreadLibraryCalls(hModule);
        CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)onAttach, NULL, 0, NULL);
        return true;
        break;

    case DLL_PROCESS_DETACH:
        return true;
        break;
    }
}