C++ Team Fortress 2 BunnyHop Yapımı

Wunlysa · 20 Mar 2023

1- C++ Boş bir proje oluşturun ve main.cpp memory.h isminde iki adet dosya oluşturun
2- Size verdiğim kodu yapıştırın

Derleyip kullanabilirsiniz iyi eğlenceler.

memory.h

C++:

#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:
    // Constructor that finds the process id
    // and opens a handle
    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;
            }
        }

        // Free handle
        if (snapShot)
            ::CloseHandle(snapShot);
    }

    // Destructor that frees the opened handle
    ~Memory()
    {
        if (processHandle)
            ::CloseHandle(processHandle);
    }

    // Returns the base address of a module by name
    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;
    }

    // Read process memory
    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;
    }

    // Write process memory
    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);
    }
};

Main.cpp

C++:

#include "memory.h"

#include <thread>
#include <iostream>

namespace offsets
{
    constexpr auto localPlayer = 0xC3F6C0;
    constexpr auto flags = 0x37C;
    constexpr auto forceJump = 0xC6E460;
    constexpr auto entityList = 0xC4D1EC;
    constexpr auto teamNum = 0xB0;
}

__declspec(align(16)) struct Color
{
    constexpr Color(const float r, const float g, const float b, const float a = 1.f) noexcept :
        r(r), g(g), b(b), a(a) { }

    float r, g, b, a;
};

int main()
{
    const auto mem = Memory("hl2.exe");

    std::cout << "Team Fortess 2 found!" << std::endl;

    const auto client = mem.GetModuleAddress("client.dll");
    std::cout << "client.dll -> " << "0x" << std::hex << client << std::dec << std::endl;

    constexpr const auto color = Color{ 1.f, 0.f, 1.f };

    while (true)
    {
        // we don't need this running a billion times per second :)
        std::this_thread::sleep_for(std::chrono::milliseconds(1));

        const auto localPlayer = mem.Read<std::uintptr_t>(client + offsets::localPlayer);

        if (!localPlayer)
            continue;

        const auto localPlayerTeam = mem.Read<std::uintptr_t>(localPlayer + offsets::teamNum);
        const auto localPlayerFlags = mem.Read<std::uintptr_t>(localPlayer + offsets::flags);

        // bhop
        if (GetAsyncKeyState(VK_SPACE))
            (localPlayerFlags & (1 << 0)) ?
            mem.Write<std::uintptr_t>(client + offsets::forceJump, 6) :
            mem.Write<std::uintptr_t>(client + offsets::forceJump, 4);
    }
}

By Legend crazy · 20 Mar 2023

Güzel bir konu olmuş dostum ellerine sağlık

Gazelle · 20 Mar 2023

Gayet başarılı bir konu olmuş. Akarı yok kokarı yok. Kopyala yapıştır derle. Eline sağlık.

boranatakan · 20 Mar 2023

Wunlysa' Alıntı:

1- C++ Boş bir proje oluşturun ve main.cpp memory.h isminde iki adet dosya oluşturun
2- Size verdiğim kodu yapıştırın

Derleyip kullanabilirsiniz iyi eğlenceler.

memory.h

C++:

#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:
    // Constructor that finds the process id
    // and opens a handle
    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;
            }
        }

        // Free handle
        if (snapShot)
            ::CloseHandle(snapShot);
    }

    // Destructor that frees the opened handle
    ~Memory()
    {
        if (processHandle)
            ::CloseHandle(processHandle);
    }

    // Returns the base address of a module by name
    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;
    }

    // Read process memory
    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;
    }

    // Write process memory
    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);
    }
};

Main.cpp

C++:

#include "memory.h"

#include <thread>
#include <iostream>

namespace offsets
{
    constexpr auto localPlayer = 0xC3F6C0;
    constexpr auto flags = 0x37C;
    constexpr auto forceJump = 0xC6E460;
    constexpr auto entityList = 0xC4D1EC;
    constexpr auto teamNum = 0xB0;
}

__declspec(align(16)) struct Color
{
    constexpr Color(const float r, const float g, const float b, const float a = 1.f) noexcept :
        r(r), g(g), b(b), a(a) { }

    float r, g, b, a;
};

int main()
{
    const auto mem = Memory("hl2.exe");

    std::cout << "Team Fortess 2 found!" << std::endl;

    const auto client = mem.GetModuleAddress("client.dll");
    std::cout << "client.dll -> " << "0x" << std::hex << client << std::dec << std::endl;

    constexpr const auto color = Color{ 1.f, 0.f, 1.f };

    while (true)
    {
        // we don't need this running a billion times per second :)
        std::this_thread::sleep_for(std::chrono::milliseconds(1));

        const auto localPlayer = mem.Read<std::uintptr_t>(client + offsets::localPlayer);

        if (!localPlayer)
            continue;

        const auto localPlayerTeam = mem.Read<std::uintptr_t>(localPlayer + offsets::teamNum);
        const auto localPlayerFlags = mem.Read<std::uintptr_t>(localPlayer + offsets::flags);

        // bhop
        if (GetAsyncKeyState(VK_SPACE))
            (localPlayerFlags & (1 << 0)) ?
            mem.Write<std::uintptr_t>(client + offsets::forceJump, 6) :
            mem.Write<std::uintptr_t>(client + offsets::forceJump, 4);
    }
}

Eline koluna sağlık güzel iş

oyundelisi321321 · 20 Mar 2023

Dostum çok iyi olmuş Daha güzellerinide bekliyoruz eline sağlıkk.

furkansrby · 20 Mar 2023

Visual studio code ile derleyebilir miyiz?

Fazal Sultan · 20 Mar 2023

My fauorite language is C++ pyhton and java

Troxen · 20 Mar 2023

baya iyi hocam aştınız artık kendinizi

duhangul59 · 20 Mar 2023

teşekkürler brom. genelde fare makrolarıyla yapıyorlar bunlar yakalanırsa 3. parti yazılım olarak ban yeme ihtimalini de arttırır diye düşünüyorıum

emirhan taş 3182 · 20 Mar 2023

Wunlysa' Alıntı:

1- C++ Boş bir proje oluşturun ve main.cpp memory.h isminde iki adet dosya oluşturun
2- Size verdiğim kodu yapıştırın

Derleyip kullanabilirsiniz iyi eğlenceler.

memory.h

C++:

#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:
    // Constructor that finds the process id
    // and opens a handle
    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;
            }
        }

        // Free handle
        if (snapShot)
            ::CloseHandle(snapShot);
    }

    // Destructor that frees the opened handle
    ~Memory()
    {
        if (processHandle)
            ::CloseHandle(processHandle);
    }

    // Returns the base address of a module by name
    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;
    }

    // Read process memory
    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;
    }

    // Write process memory
    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);
    }
};

Main.cpp

C++:

#include "memory.h"

#include <thread>
#include <iostream>

namespace offsets
{
    constexpr auto localPlayer = 0xC3F6C0;
    constexpr auto flags = 0x37C;
    constexpr auto forceJump = 0xC6E460;
    constexpr auto entityList = 0xC4D1EC;
    constexpr auto teamNum = 0xB0;
}

__declspec(align(16)) struct Color
{
    constexpr Color(const float r, const float g, const float b, const float a = 1.f) noexcept :
        r(r), g(g), b(b), a(a) { }

    float r, g, b, a;
};

int main()
{
    const auto mem = Memory("hl2.exe");

    std::cout << "Team Fortess 2 found!" << std::endl;

    const auto client = mem.GetModuleAddress("client.dll");
    std::cout << "client.dll -> " << "0x" << std::hex << client << std::dec << std::endl;

    constexpr const auto color = Color{ 1.f, 0.f, 1.f };

    while (true)
    {
        // we don't need this running a billion times per second :)
        std::this_thread::sleep_for(std::chrono::milliseconds(1));

        const auto localPlayer = mem.Read<std::uintptr_t>(client + offsets::localPlayer);

        if (!localPlayer)
            continue;

        const auto localPlayerTeam = mem.Read<std::uintptr_t>(localPlayer + offsets::teamNum);
        const auto localPlayerFlags = mem.Read<std::uintptr_t>(localPlayer + offsets::flags);

        // bhop
        if (GetAsyncKeyState(VK_SPACE))
            (localPlayerFlags & (1 << 0)) ?
            mem.Write<std::uintptr_t>(client + offsets::forceJump, 6) :
            mem.Write<std::uintptr_t>(client + offsets::forceJump, 4);
    }
}

Hocam ben tam olarak bilmiyorum kullanmayı oyuna girip napıcam bunu yaptıktan sonra

muhteremx3 · 14 May 2023

bu tarz konular gelmesi çok iyi yavaştan c++ başlamak için harika.

utku1676 · 14 May 2023

Gelişime açık bir kaynak eline sağlık paylaşım için teşekkürler ama merak ettiğim konu bunny hop denilen olay oyunun içindeki zıplama kuvvetinin değişimi ile nasıl sağlanıyor olabilir mantıken aklıma gelen cevap zıplama animasyonu bitmeden yeniden girmesi bu sayede döngüye giriyor

Serakn Topkay · 29 Haz 2023

nasıl aktif ediceğiz

learkhoss · 11 Tem 2023

biraz karısık görünüyor ama göz asinalıgı olunca yapılmayacak ögrenilmeyecek degil

caganaga01 · 11 Tem 2023

dostum tam olarak nasıl aktifleştiriyoruz

sersimfer · 23 Tem 2023

eline emeğine sağlık güzel bir konu ybilgi yararıma oldu teşekkürler

ahmy baba · 15 Ağu 2023

By Legend crazy' Alıntı:
Güzel bir konu olmuş dostum ellerine sağlık

sağol dostum

darmx1 · 20 Ağu 2023

ben bilmiyorumda nası calıstırıcağımı ögrete bilirmisin

Onurcengizx · 25 Ağu 2023

nasıl aktif ediliyor

suxooz · 31 Ağu 2023

iyi yayın iyi çalışıyor

Ara

C++ Team Fortress 2 BunnyHop Yapımı

Wunlysa

By Legend crazy

☆☆Her oyun bir gün hileyi tadacaktır☆☆

Gazelle

boranatakan

oyundelisi321321

HER OYUNUN BİR AÇIĞI VARDIR

furkansrby

Fazal Sultan

Sultan Yousafzai

Troxen

duhangul59

emirhan taş 3182

muhteremx3

utku1676

Serakn Topkay

learkhoss

caganaga01

sersimfer

ahmy baba

darmx1

Onurcengizx

suxooz

Benzer Konular