features.cpp

#include <cmath>
#include <iostream>
#include "features.hpp"
#include "config.hpp" // to access config variables
#include "structs.hpp"
#include "tramp.hpp"

namespace mem 
{
    void Patch(BYTE* dst, BYTE* src, unsigned int size) 
    {
        DWORD oldprotect;
        // 1. Change to RWX (Read, Write, Execute)
        VirtualProtect(dst, size, PAGE_EXECUTE_READWRITE, &oldprotect);
        
        // 2. Perform the copy
        memcpy(dst, src, size);
        
        // 3. Restore original protection
        VirtualProtect(dst, size, oldprotect, &oldprotect);
    }

    void Nop(BYTE* dst, unsigned int size) 
    {
        DWORD oldprotect;
        VirtualProtect(dst, size, PAGE_EXECUTE_READWRITE, &oldprotect);
        
        // Fill the memory with 0x90 (NOP)
        memset(dst, 0x90, size);
        
        VirtualProtect(dst, size, oldprotect, &oldprotect);
    }
}

inline bool is_in_team_mode()
{
    const std::uint8_t game_type = *reinterpret_cast<std::uint8_t*>(features::offsets::game_mode);

    return !(game_type
        && game_type != 4
        && game_type != 5
        && game_type != 7
        && game_type != 11
        && game_type != 13
        && game_type != 14
        && game_type != 16
        && game_type != 17
        && game_type != 20
        && game_type != 21);
}

inline std::size_t get_player_count()
{
    uintptr_t module_base = (uintptr_t)GetModuleHandle(nullptr);
    const auto players = *reinterpret_cast<std::size_t*>(module_base + features::offsets::num_players);
    return players < 1 || players > 32 ? 0 : players - 1;
}

entity* get_closest_enemy()
{
    uintptr_t base = (uintptr_t)GetModuleHandle(nullptr);
    entity* closest_entity = nullptr;

    entity* local_player = *(entity**)(base + features::offsets::localPlayer);
    vec3 local_pos = local_player->head_pos;
    auto closest_dist = 1000000.0f;

    for (size_t i = 0; i < get_player_count(); i++)
    {
        const auto current_player = (*reinterpret_cast<entity_list**>(features::offsets::entityList))->entities[i];
        printf("current player: %p\n", current_player);

        if (current_player->health <= 0 || is_in_team_mode() && current_player->team == local_player->team)
            continue;

        const auto cur_player_pos = current_player->head_pos;
        const auto dist = (local_pos - cur_player_pos).magnitude();

        printf("distance to player %d: %f\n", i, dist);

        if (closest_dist > dist)
        {
            closest_dist = dist;
            closest_entity = current_player;
        }
    }

    return closest_entity;
}

entity* get_closest_player()
{
    uintptr_t base = (uintptr_t)GetModuleHandle(nullptr);
    entity* closest_entity = nullptr;

    entity* local_player = *(entity**)(base + features::offsets::localPlayer);
    vec3 local_pos = local_player->head_pos;
    auto closest_dist = 1000000.0f;

    for (size_t i = 0; i < get_player_count(); i++)
    {
        const auto current_player = (*reinterpret_cast<entity_list**>(features::offsets::entityList))->entities[i];
        printf("current player: %p\n", current_player);

        if (current_player->health <= 0)
            continue;

        const auto cur_player_pos = current_player->head_pos;
        const auto dist = (local_pos - cur_player_pos).magnitude();

        printf("distance to player %d: %f\n", i, dist);

        if (closest_dist > dist)
        {
            closest_dist = dist;
            closest_entity = current_player;
        }
    }

    return closest_entity;
}

void __stdcall ApplySilentAimLogic(uintptr_t dest_ptr) {
    if (!config.b_aimbot) return;

    entity* target = config.b_target_teammates ? get_closest_player() : get_closest_enemy();
    if (target) {
        vec3* bullet_dst = reinterpret_cast<vec3*>(dest_ptr);
        bullet_dst->x = target->head_pos.x;
        bullet_dst->y = target->head_pos.y;
        bullet_dst->z = target->head_pos.z;
    }
}

static bool silent_aim_setup = false;
static uint32_t firing_gateway = 0;
void __declspec(naked) silent_aim_handler() {
    __asm {
        // 1. Grab the destination vector pointer from the stack [esp + 0x3C]
        mov eax, [esp + 0x3C]
        
        // 2. Save everything
        pushad
        
        // 3. Push EAX (the pointer) as an argument for our C++ function
        push eax
        call ApplySilentAimLogic
        
        // 4. Restore everything
        popad
        
        // 5. Jump back to the game
        jmp [firing_gateway]
    }
}

void features::execute()
{
    uintptr_t module_base = (uintptr_t)GetModuleHandle(nullptr);
    uintptr_t localPlayerPtr = (module_base + offsets::localPlayer);

    if (!localPlayerPtr) return;

    uintptr_t localPlayer = *(uintptr_t*)localPlayerPtr;

    if (!localPlayer) return;

    // God Mode Logic
    if (config.b_god_mode)
    {
        entity* player = (entity*)localPlayer;
        //int* health = (int*)(localPlayer + offsets::health); // offset for health
        if (player->health > 0)
        {
            //*health = config.god_mode_health; // set health to a high value
            player->health = config.god_mode_health;
        }
    }

    //eventually im just gonna nop out the part that decrease ammo but this is cool cause you can set custom ammo count
    if (config.b_inf_ammo)
    {
        entity* local_player = (entity*)localPlayer;

        //sets all ammo types to the inf_ammo_amount specified
        local_player->pistol_ammo = config.inf_ammo_amount;
        local_player->carbine_ammo = config.inf_ammo_amount;
        local_player->shotgun_ammo = config.inf_ammo_amount;
        local_player->machinegun_ammo = config.inf_ammo_amount;
        local_player->sniper_ammo = config.inf_ammo_amount;
        local_player->rifle_ammo = config.inf_ammo_amount;
    }

    if (config.b_inf_grenades)
    {
        entity* local_player = (entity*)localPlayer;
        local_player->grenade_count = config.inf_ammo_amount; 
    }

    if (config.b_rapid_grenades)
    {
        entity* local_player = (entity*)localPlayer;
        local_player->grenade_cooldown = 0; // set grenade cooldown to 0 to allow rapid throwing
    }

    if (config.b_rapid_knife)
    {
        entity* local_player = (entity*)localPlayer;
        local_player->knife_cooldown = 0;
    }

    // Aimbot Logic
    if (config.b_aimbot && !silent_aim_setup)
    {
            uintptr_t base = (uintptr_t)GetModuleHandle(nullptr);
            uintptr_t hook_location = base + features::offsets::silent_aim_hook_location;

            firing_gateway = tramp_hook(hook_location, (uintptr_t)silent_aim_handler, 3);
            silent_aim_setup = true;
    }

    static bool recoil_patched = false;

    // Original bytes for restoration
    BYTE orig_vertical[]   = { 0xF3, 0x0F, 0x5D, 0xD0 };       // 0xC8E4E
    BYTE orig_velocity_x[] = { 0xF3, 0x0F, 0x58, 0x40, 0x10 }; // 0xC8DCD (+10)
    BYTE orig_velocity_y[] = { 0xF3, 0x0F, 0x58, 0x40, 0x14 }; // 0xC8DF1 (+14)
    BYTE orig_velocity_z[] = { 0xF3, 0x0F, 0x58, 0x48, 0x18 }; // 0xC8DF6 (+18)

    if (config.b_norecoil && !recoil_patched)
    {
        // Vertical Visual Recoil (The Climb)
        BYTE xor_xmm2[] = { 0x0F, 0x57, 0xD2 }; 
        mem::Patch((BYTE*)(module_base + 0xC8E4E), xor_xmm2, 3);
        mem::Nop((BYTE*)(module_base + 0xC8E51), 1);

        // Physical Kick (The Push)
        // NOP all three axes to ensure NO movement is added when firing
        mem::Nop((BYTE*)(module_base + 0xC8DCD), 5); // Kill X-Push (+10)
        mem::Nop((BYTE*)(module_base + 0xC8DF1), 5); // Kill Y-Push (+14)
        mem::Nop((BYTE*)(module_base + 0xC8DF6), 5); // Kill Z-Push (+18)

        recoil_patched = true;
    }
    else if (!config.b_norecoil && recoil_patched)
    {
        // RESTORE 
        mem::Patch((BYTE*)(module_base + 0xC8E4E), orig_vertical, 4);
        mem::Patch((BYTE*)(module_base + 0xC8DCD), orig_velocity_x, 5);
        mem::Patch((BYTE*)(module_base + 0xC8DF1), orig_velocity_y, 5);
        mem::Patch((BYTE*)(module_base + 0xC8DF6), orig_velocity_z, 5);

        recoil_patched = false;
    }

    static bool rapid_fire_patched = false;
    uintptr_t rapidfire_offset = module_base + offsets::rapidfire;
    if (config.b_rapid_fire && !rapid_fire_patched)
    {
        mem::Nop((BYTE*)rapidfire_offset, 2); // nop the instruction at the rapid fire offset
        rapid_fire_patched = true;
    }
    else if (!config.b_rapid_fire && rapid_fire_patched)
    {
        BYTE originalRapidFireBytes[2] = { 0x89, 0x08 }; // original bytes to restore
        mem::Patch((BYTE*)rapidfire_offset, originalRapidFireBytes, 2); // restore the original bytes at the rapid fire offset
        rapid_fire_patched = false;
    }

    if (config.b_speed_hack)
    {
        entity* player = (entity*)localPlayer;
        if (player->accel.x != 0.f )
        {
            player->accel.x *= config.speed_difference;
        }
        if (player->accel.y != 0.f)
        {
            player->accel.y *= config.speed_difference;
    }
}