Source Code Mega Thread

#include <windows.h>
#include <initializer_list>

#define naked __declspec(naked)

struct Ptr
{
    DWORD64 pointer;

    explicit Ptr(DWORD64 ptr, std::initializer_list<DWORD64> offsets = {}) : pointer(ptr)
    {
        for each (DWORD64 offset in offsets)
        {
            pointer = *reinterpret_cast<DWORD64*>(pointer);
            pointer += offset;
        }
    }

    template <typename T> T get(DWORD64 offset = 0)
    {
        return *reinterpret_cast<T*>(pointer + offset);
    }

    template <typename T> void set(T value, DWORD64 offset = 0)
    {
        *reinterpret_cast<T*>(pointer + offset) = value;
    }

    void nop(DWORD64 length) const
    {
        for (int i = 0; i < length; ++i)
        {
            *reinterpret_cast<BYTE*>(pointer + i) = 0x90; // nop
        }
    }
};

#include <windows.h>
#include <Psapi.h>
#include <string>
#include <vector>
#include <sstream>
#include <cassert>

DWORD64 AOBScan(DWORD64 begin, DWORD64 end, std::string pattern)
{
    struct PByte
    {
        byte byte;
        bool ignore;
    };

    std::vector<PByte> patterns;

    std::stringstream ss;
    ss << pattern;

    std::string sByte;

    while (ss >> sByte)
    {
        if (sByte == "?" || sByte == "??")
        {
            patterns.push_back({ NULL, true });
        }
        else
        {
            int iByte = stoi(sByte, nullptr, 16);
            assert(iByte >= 0 && iByte <= 255);
            patterns.push_back({ byte(iByte), false });
        }
    }

    for (DWORD64 i = begin; i < end - DWORD64(patterns.size()); ++i)
    {
        bool success = true;

        for (DWORD64 j = 0; j < DWORD64(patterns.size()); ++j)
        {
            byte memByte = *reinterpret_cast<byte*>(i + j);
            PByte pByte = patterns[j];
            if (memByte != pByte.byte && !pByte.ignore)
            {
                success = false;
                break;
            }
        }

        if (success)
        {
            return i;
        }
    }

    return NULL;
}

DWORD64 AOBScan(MODULEINFO moduleInfo, std::string pattern)
{
    DWORD64 begin = DWORD64(moduleInfo.lpBaseOfDll);
    DWORD64 end = begin + DWORD64(moduleInfo.SizeOfImage);
    return AOBScan(begin, end, pattern);
}

Ptr TunablesPointer()
{
    DWORD64 base = DWORD64(g_MainModuleInfo.lpBaseOfDll);
    int patternResult = *reinterpret_cast<int*>(AOBScan(g_MainModuleInfo, "48 8B 8C C2 ? ? ? ? 48 85 C9 74 19") + 4);
    return Ptr(base + patternResult + 8, { 16 });
}

template <typename T> void SetTunable(int index, T value)
{
    static Ptr tunablesPointer = TunablesPointer();
    return tunablesPointer.set(value, index * 8);
}

template <typename T> T GetTunable(int index)
{
    static Ptr tunablesPointer = TunablesPointer();
    return tunablesPointer.get<T>(index * 8);
}

SET_EXPLOSIVE_AMMO_THIS_FRAME(playerhandle);

if(godmode[0]){
        PLAYER::SET_PLAYER_INVINCIBLE(PLAYER, true);
        PED::CLEAR_PED_BLOOD_DAMAGE(PLAYER_PED);
        PED::RESET_PED_VISIBLE_DAMAGE(PLAYER_PED);
}
else{
	PLAYER::SET_PLAYER_INVINCIBLE(PLAYER, false);
}

addBoolOption("GodMode", &godmode[0]);

case 1: if (!godmode[0]){
        drawNotification("GodMode ~r~Disabled");
}
else{
        drawNotification("GodMode ~g~Enabled");
}
break;

bool godmode[50];