#include "main.h"
#include "DriverManager.h"
#include "encypt.h"

using namespace std;

std::unique_ptr<DriverManager> driver = std::make_unique<DriverManager>("\\\\.\\NTIOLib_MB");

#define offset_game_manager 0x53c1670
#define offset_fov_manager 0x53c1668
#define offset_entity_list 0xC8
#define offset_entity_count 0xD0
#define offset_round_manager 0x53B0F40
#define weapon_recoil_Enabler 0x168
#define weapon_recoil_x 0x014C
#define weapon_recoil_y 0x015C
#define weapon_crosshair_gap 0x20
#define offset_v_table 0x3a83e58
#define offset_glow_manager 0x607aa50
#define offset_glow_base 0xB8
#define offset_glow_color 0x110
#define offset_glow_distance 0x130
#define offset_glow_opacity 0x13C
#define offset_profile_manager 0x53ae810
#define offset_glow_manager 0x607aa50

#define ADDRESS_GAMEMANAGER 0x53c1670
#define OFFSET_GAMEMANAGER_ENTITYLIST 0xC8
#define OFFSET_GAMEMANAGER_ENTITY_COUNT 0xD0
#define ADDRESS_VTMARKER 0x3a83e58

uintptr_t base_address;
uintptr_t game_manager;
uintptr_t round_manager;
uintptr_t entity_list;
int       entity_count;


bool ESP(uint64_t Base)
{
    uintptr_t GameManager = driver->ReadMemory<uintptr_t>(Base + ADDRESS_GAMEMANAGER);

    if (!GameManager)
    {
        return false;
    }

    uintptr_t EntityList = driver->ReadMemory<uintptr_t>(GameManager + OFFSET_GAMEMANAGER_ENTITYLIST);

    if (!EntityList)
    {
        return false;
    }

    int EntityCount = driver->ReadMemory<DWORD>(GameManager + OFFSET_GAMEMANAGER_ENTITY_COUNT) & 0x3fffffff;

    if (!EntityCount)
    {
        return false;
    }

    for (int i = 0; i < EntityCount; i++)
    {
        uintptr_t EntityObject = driver->ReadMemory<uintptr_t>(EntityList + i * 0x8);

        if (!EntityObject)
        {
            continue;
        }

        uintptr_t PtrChain1 = driver->ReadMemory<uintptr_t>(EntityObject + 0x28); if (!PtrChain1) continue;
        uintptr_t PtrChain2 = driver->ReadMemory<uintptr_t>(PtrChain1 + 0xD8); if (!PtrChain2) continue;

        for (auto Component = 0x80; Component < 0xf0; Component += sizeof(uintptr_t))
        {
            uintptr_t PtrChain3 = driver->ReadMemory<uintptr_t>(PtrChain2 + Component);

            if (!PtrChain3)
            {
                continue;
            }

            if (driver->ReadMemory<uintptr_t>(PtrChain3) != (Base + ADDRESS_VTMARKER))
            {
                continue;
            }

            driver->WriteMemory<BYTE>(PtrChain3 + 0x552, true);
            driver->WriteMemory<BYTE>(PtrChain3 + 0x554, true);
        }
    }
}


int main() {
    std::cout << _xor_("Launch Rainbow Retarded Coon").c_str() << std::endl;


    // this loops until rainbow is open and gets the pid.
    // sleeps for 1 sec.
    while (!driver->GetProcessID(_xor_("RainbowSix.exe").c_str()))
        std::this_thread::sleep_for(std::chrono::seconds(30));

    // clears screen
    std::system("cls");

    // 5 seconds sleep
    std::this_thread::sleep_for(std::chrono::seconds(15));

    std::cout << _xor_("[+] Initializing...").c_str() << std::endl;

    // get base address
    base_address = driver->GetModuleBaseAddr(_xor_("RainbowSix.exe").c_str());

    std::cout << "[+] Found " << _xor_("base_address").c_str() << " : " << std::hex << "0x" << base_address << std::endl;

    // get game manager
    game_manager = driver->ReadMemory<uintptr_t>(base_address + offset_game_manager);
    std::cout << "[+] Found " << _xor_ ("game_manager").c_str() << " : " << std::hex << "0x" << game_manager << std::endl;

    // get round manager
    round_manager = driver->ReadMemory<uintptr_t>(base_address + offset_round_manager);
    std::cout << "[+] Found " << _xor_("round_manager").c_str() << " : " << std::hex << "0x" << round_manager << std::endl;

    // get entity list
    entity_list = driver->ReadMemory<uintptr_t>(base_address + offset_game_manager + offset_entity_list);
    std::cout << "[+] Found " << _xor_("entity_list").c_str() << " : " << std::hex << "0x" << entity_list << std::endl;

    // get entity count
    entity_count = driver->ReadMemory<DWORD>(base_address + offset_game_manager + offset_entity_count) & 0x3fffffff;
    std::cout << "[+] Found " << _xor_("entity_count").c_str() << " : " << std::hex << "0x" << entity_count << std::endl;

    std::cout << _xor_("[+] Initialized.").c_str() << std::endl;

    while(true)

    ESP(base_address);

    std::cin.get();

}