CS:GO - RCS(recoil control system) Source Code

#include "memory.h"
#include <iostream>
#include <thread>

namespace offset
{

    constexpr ::std::ptrdiff_t dwLocalPlayer = 0xDB558C;

    constexpr ::std::ptrdiff_t dwClientState = 0x589FC4;
    constexpr ::std::ptrdiff_t dwClientState_ViewAngles = 0x4D90;

    constexpr ::std::ptrdiff_t m_aimPunchAngle = 0x303C;
    constexpr ::std::ptrdiff_t m_iShotsFired = 0x103E0;


}

struct Vector2
{
    float x = { }, y = { };
};

int main()
{
    std::cout << "----- Cheat Global -----\n";
    std::cout << "[+] Hile Baslatildi.";

    const auto memory = Memory{ "csgo.exe" };

    const auto client = memory.GetModuleAddress("client.dll");
    const auto engine = memory.GetModuleAddress("engine.dll");

    auto oldPunch = Vector2{ };

    while (true)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(1));

        const auto& localPlayer = memory.Read<std::uintptr_t>(client + offset::dwLocalPlayer);
        const auto& shotsFired = memory.Read<std::int32_t>(localPlayer + offset::m_iShotsFired);

        if (shotsFired)
        {
            const auto& clientState = memory.Read<std::uintptr_t>(engine + offset::dwClientState);
            const auto& viewAngles = memory.Read<Vector2>(clientState + offset::dwClientState_ViewAngles);

            const auto& aimPunch = memory.Read<Vector2>(localPlayer + offset::m_aimPunchAngle);

            auto newAngles = Vector2
            {

                viewAngles.x + oldPunch.x - aimPunch.x * 2.f,
                viewAngles.y + oldPunch.y - aimPunch.y * 2.f,


            };

            if (newAngles.x > 89.f)
                newAngles.x = 89.f;

            if (newAngles.x < -89.f)
                newAngles.x = -89.f;


            while (newAngles.y > 180.f)
                newAngles.y -= 360.f;

            while (newAngles.y < -180.f)
                newAngles.y += 360.f;


            memory.Write<Vector2>(clientState + offset::dwClientState_ViewAngles, newAngles);

            oldPunch.x = aimPunch.x * 2.f;
            oldPunch.y = aimPunch.y * 2.f;
        }
        else
        {
            oldPunch.x = oldPunch.y = 0.f;
        }






    }
    


    return 0;
}

#pragma once
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#include <TlHelp32.h>

#include <cstdint>
#include <string_view>

class Memory
{
private:
    std::uintptr_t processId = 0;
    void* processHandle = nullptr;

public:
    Memory(const std::string_view processName) noexcept
    {
        ::PROCESSENTRY32 entry = { };
        entry.dwSize = sizeof(::PROCESSENTRY32);

        const auto snapShot = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

        while (::Process32Next(snapShot, &entry))
        {
            if (!processName.compare(entry.szExeFile))
            {
                processId = entry.th32ProcessID;
                processHandle = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId);
                break;
            }
        }

        if (snapShot) ::CloseHandle(snapShot);
    }

    ~Memory() { if (processHandle) ::CloseHandle(processHandle); }

    const std::uintptr_t GetModuleAddress(const std::string_view moduleName) const noexcept
    {
        ::MODULEENTRY32 entry = { };
        entry.dwSize = sizeof(::MODULEENTRY32);

        const auto snapShot = ::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, processId);

        std::uintptr_t result = 0;

        while (::Module32Next(snapShot, &entry))
        {
            if (!moduleName.compare(entry.szModule))
            {
                result = reinterpret_cast<std::uintptr_t>(entry.modBaseAddr);
                break;
            }
        }

        if (snapShot) ::CloseHandle(snapShot);

        return result;
    }

    // process memory oku
    template <typename T>
    constexpr const T& Read(const std::uintptr_t& address) const noexcept
    {
        T value = { };
        ::ReadProcessMemory(processHandle, reinterpret_cast<const void*>(address), &value, sizeof(T), NULL);
        return value;
    }

    // process memory yaz
    template <typename T>
    constexpr void Write(const std::uintptr_t& address, const T& value) const noexcept
    {
        ::WriteProcessMemory(processHandle, reinterpret_cast<void*>(address), &value, sizeof(T), NULL);
    }
};