Guide FiveM — Bypassing Camera-Based Aimbot & Damage-Modifier Silent AC

byte_corvus · Saturday at 11:08 PM

Code:

AC:
local _STR_TABLE = {}
local function _STR_DECRYPT(k)
    return _STR_TABLE[k]
end
--- Ban Handler
RegisterNetEvent("__RVSaimbot:detect")
AddEventHandler(
    "__RVSaimbot:detect",
    function(reason)
        TriggerServerEvent("__RVSaimbot:detect", reason)
    end
)
--- Anti Rage Bot
local shootCount = 0
local lastReset = GetGameTimer()
if Config.AntiRageBot then
    CreateThread(
        function()
            while true do
                local sleep = 1000
                if GetSelectedPedWeapon(PlayerPedId()) ~= GetHashKey("WEAPON_UNARMED") then
                    sleep = 20
                    if IsPedShooting(PlayerPedId()) then
                        shootCount = shootCount + 1
                    end
                    if GetGameTimer() - lastReset >= 1000 then
                        if shootCount > 20 then
                            TriggerServerEvent("__RVSaimbot:detect", "RageBot Detected (1)")
                        end
                        shootCount = 0
                        lastReset = GetGameTimer()
                    end
                end
                Wait(sleep)
            end
        end
    )
end
--- Disable AimBot
local sniperignore = {205991906, 177293209, -952879014, 1785463520, 100416529, 1853742572}
local function isIgnored(hash)
    for _, v in ipairs(sniperignore) do
        if v == hash then
            return true
        end
    end
    return false
end
if Config.DisableAimbot then
    Citizen.CreateThread(
        function()
            while true do
                Citizen.Wait(0)
                local ped = PlayerPedId()
                if IsPedArmed(ped, 4) and (IsAimCamActive() or IsControlPressed(0, 25)) then
                    local w = GetSelectedPedWeapon(ped)
                    if not isIgnored(w) then
                        local h1 = GetGameplayCamRelativeHeading()
                        local p1 = GetGameplayCamRelativePitch()
                        if Config.DisableAimbotMode == "STRICT" then
                            if not IsPedRagdoll(ped) then
                                SetGameplayCamRelativePitch(p1, 0.0)
                                SetGameplayCamRelativeHeading(h1)
                            end
                        elseif Config.DisableAimbotMode == "AGGRESSIVE" then
                            SetGameplayCamRelativePitch(p1, 0.0)
                            SetGameplayCamRelativeHeading(h1)
                        end
                    end
                end
            end
        end
    )
end
-- Anti Trigger Bot
local WATCH_KEYS = {24, 257}
local state = {
    acc = 0
}
local THRESHOLD = 3
local POLL_MS = 1
local function any_watch_key_down()
    for i = 1, #WATCH_KEYS do
        local k = WATCH_KEYS[i]
        if IsControlPressed(0, k) or IsControlJustPressed(0, k) then
            return true
        end
    end
    return false
end
local function should_inspect(ped, pid)
    if not IsPedShooting(ped) then
        return false
    end
    if not HasPlayerDamagedAtLeastOnePed(pid) then
        return false
    end
    if IsPedInAnyVehicle(ped, false) then
        return false
    end
    local aiming, ent = GetEntityPlayerIsFreeAimingAt(pid)
    if not aiming or ent == 0 then
        return false
    end
    if not IsEntityAPed(ent) then
        return false
    end
    if not GetEntityCanBeDamaged(ent) then
        return false
    end
    if GetPlayerInvincible(ent) then
        return false
    end
    return true
end
if Config.AntiTriggerBot then
    CreateThread(
        function()
            while true do
                Wait(POLL_MS)
                local myPed = PlayerPedId()
                local myId = PlayerId()
                if should_inspect(myPed, myId) then
                    if any_watch_key_down() then
                        state.acc = 0
                    else
                        state.acc = state.acc + 1
                        if state.acc >= THRESHOLD then
                            print("Triggerbot detected")
                            TriggerServerEvent("__RVSaimbot:detect", "Triggerbot Detected (1)")
                            state.acc = 0
                        end
                    end
                end
            end
        end
    )
end
-- Disable Silent Aim
local originalWeaponDamageByHash = {}
local originalPlayerDamageModifier = nil
local originalAiDamageModifier = nil
local lastWeapon = 0
local function getSelectedWeapon()
    return GetSelectedPedWeapon(PlayerPedId()) or 0
end
local function cacheGlobalOriginals()
    if originalPlayerDamageModifier == nil then
        originalPlayerDamageModifier = 1.0
    end
    if originalAiDamageModifier == nil then
        originalAiDamageModifier = 1.0
    end
end
local function cacheWeaponOriginal(hash)
    if not hash or hash == 0 then
        return
    end
    if originalWeaponDamageByHash[hash] ~= nil then
        return
    end
    local ok, cur =
        pcall(
        function()
            return GetWeaponDamageModifier(hash)
        end
    )
    if ok and tonumber(cur) and tonumber(cur) > 0 then
        originalWeaponDamageByHash[hash] = tonumber(cur)
    else
        originalWeaponDamageByHash[hash] = 1.0
    end
end
local function applyOutgoingModifiers()
    local ped = PlayerPedId()
    if not DoesEntityExist(ped) then
        return
    end
    cacheGlobalOriginals()
    local w = getSelectedWeapon()
    if w == 0 then
        if lastWeapon and lastWeapon ~= 0 and originalWeaponDamageByHash[lastWeapon] then
            SetWeaponDamageModifier(lastWeapon, originalWeaponDamageByHash[lastWeapon])
        end
        SetPlayerWeaponDamageModifier(PlayerId(), originalPlayerDamageModifier)
        SetAiWeaponDamageModifier(originalAiDamageModifier)
        lastWeapon = 0
        return
    end
    if lastWeapon ~= 0 and lastWeapon ~= w then
        if originalWeaponDamageByHash[lastWeapon] then
            SetWeaponDamageModifier(lastWeapon, originalWeaponDamageByHash[lastWeapon])
        end
    end
    cacheWeaponOriginal(w)
    local isAiming, aimedEntity = GetEntityPlayerIsFreeAimingAt(PlayerId())
    local desiredDamage = 0.0
    if originalWeaponDamageByHash[w] then
        if isAiming and aimedEntity ~= 0 and IsEntityAPed(aimedEntity) then
            desiredDamage = originalWeaponDamageByHash[w]
        else
            desiredDamage = 0.0
        end
        SetPlayerWeaponDamageModifier(PlayerId(), desiredDamage)
        SetAiWeaponDamageModifier(desiredDamage) -- spoofed
        SetWeaponDamageModifier(w, desiredDamage)
    end
    lastWeapon = w
end
local function restoreAll()
    for hash, val in pairs(originalWeaponDamageByHash) do
        if hash and val then
            print("Hash:", hash, "Value:", val)
            SetWeaponDamageModifier(hash, val)
        end
    end
    cacheGlobalOriginals()
    SetPlayerWeaponDamageModifier(PlayerId(), originalPlayerDamageModifier or 1.0)
    SetAiWeaponDamageModifier(originalAiDamageModifier or 1.0)
    lastWeapon = 0
end
if Config.AntiSilent then
    Citizen.CreateThread(
        function()
            Citizen.Wait(100)
            cacheGlobalOriginals()
            while true do
                Citizen.Wait(0)
                local ped = PlayerPedId()
                if DoesEntityExist(ped) and not IsEntityDead(ped) then
                    applyOutgoingModifiers()
                else
                    if lastWeapon and lastWeapon ~= 0 then
                        restoreAll()
                    end
                end
            end
        end
    )
end
---
if Config.AntiLockON then
    Citizen.CreateThread(
        function()
            while true do
                Citizen.Wait(500)
                local ped = PlayerPedId()
                if DoesEntityExist(ped) and not IsEntityDead(ped) then
                    SetPedConfigFlag(ped, 43, false)
                    SetPlayerLockon(PlayerId(), true)
                    SetPlayerLockonRangeOverride(PlayerId(), 3.0)
                end
            end
        end
    )
end
-- Aimbot 2
local aimingStart = 0
local triggered = false
local function getThreshold()
    if Config.DisableAimbot2Mode == "AGGRESSIVE" then
        return 100
    elseif Config.DisableAimbot2Mode == "RELAX" then
        return 400
    else
        return 400
    end
end
if Config.DisableAimbot2 then
    Citizen.CreateThread(
        function()
            while true do
                Citizen.Wait(0)
                local playerId = PlayerId()
                local ped = PlayerPedId()
                local threshold = getThreshold()
                if IsPedArmed(ped, 4) and IsPlayerFreeAiming(playerId) then
                    if aimingStart == 0 then
                        aimingStart = GetGameTimer()
                    end
                    local elapsed = GetGameTimer() - aimingStart
                    if elapsed >= threshold then
                        local h1 = GetGameplayCamRelativeHeading()
                        local p1 = GetGameplayCamRelativePitch()
                        SetGameplayCamRelativePitch(p1, 0.0)
                        SetGameplayCamRelativeHeading(h1)
                        if not triggered then
                            triggered = true
                        end
                    end
                else
                    aimingStart = 0
                    triggered = false
                end
            end
        end
    )
end
AddEventHandler("onResourceStop", function(resourceName)
    if (resourceName == GetCurrentResourceName()) then
        print("Restoring all..")
        restoreAll()
    end
end)
 
 
===================
 
AIMBOT:
namespace Core::Features
{
    namespace
    {
        
        D3DXVECTOR3 GetTargetBonePosition(CPed* Ped, int hitbox)
        {
            if (!Ped) return { 0, 0, 0 };
            switch (hitbox)
            {
            case 0: return Ped->GetBonePosDefault(0); 
            case 1: return Ped->GetBonePosDefault(7);  //
            case 2: return Ped->GetBonePosDefault(8);  //
            default: return Ped->GetBonePosDefault(0);
            }
        }
    }
 
    
    void cAimbot::SetViewAngles(D3DXVECTOR3 BonePos)
    {
#ifdef USE_VMPROTECT
        VMProtectBeginMutation("SetViewAngles");
#endif
 
        uintptr_t CamFollowPedCamera = Mem.Read<uintptr_t>(Core::SDK::Pointers::pCamGamePlayDirector + 0x2C0);
        if (!CamFollowPedCamera) return;
 
        D3DXVECTOR3 ViewAngles = Mem.Read<D3DXVECTOR3>(CamFollowPedCamera + 0x40);
        D3DXVECTOR3 CrosshairPos = Mem.Read<D3DXVECTOR3>(CamFollowPedCamera + 0x60);
 
        D3DXVECTOR3 DeltaPos = BonePos - CrosshairPos;
        float Distance = sqrtf(DeltaPos.x * DeltaPos.x + DeltaPos.y * DeltaPos.y + DeltaPos.z * DeltaPos.z);
 
        if (Distance < 0.01f) return;
 
        D3DXVECTOR3 AimAngles;
        AimAngles.x = DeltaPos.x / Distance;
        AimAngles.y = DeltaPos.y / Distance;
        AimAngles.z = DeltaPos.z / Distance;
 
        D3DXVECTOR3 CameraDelta = AimAngles - ViewAngles;
        D3DXVECTOR3 FinalAngles = AimAngles;
 
        if (g_Config.Aimbot->SmoothX > 1.0f) {
            FinalAngles.x = ViewAngles.x + (CameraDelta.x / g_Config.Aimbot->SmoothX);
            FinalAngles.y = ViewAngles.y + (CameraDelta.y / g_Config.Aimbot->SmoothX);
        }
 
        if (g_Config.Aimbot->SmoothY > 1.0f) {
            FinalAngles.z = ViewAngles.z + (CameraDelta.z / g_Config.Aimbot->SmoothY);
        }
 
        D3DXVECTOR3 CurrentTPV = Mem.Read<D3DXVECTOR3>(CamFollowPedCamera + 0x3D0);
        float AimbotFixZ = ViewAngles.z - CurrentTPV.z;
 
        D3DXVECTOR3 ThirdPersonAngles = FinalAngles;
        ThirdPersonAngles.z = ThirdPersonAngles.z - AimbotFixZ;
 
        Mem.Write<D3DXVECTOR3>(CamFollowPedCamera + 0x40, FinalAngles);
        Mem.Write<D3DXVECTOR3>(CamFollowPedCamera + 0x3D0, ThirdPersonAngles);
 
#ifdef USE_VMPROTECT
        VMProtectEnd();
#endif
    }
 
    
    bool IsVisible(CPed* Ped) {
        if (!Ped) return false;
        // Lê o bit de visibilidade no offset 0x145C
        uint32_t visible_flag = Mem.Read<uint32_t>((uintptr_t)Ped + 0x145C);
        return (visible_flag & (1 << 4));
    }
 
    void cAimbot::Start()
    {
        while (true)
        {
            std::this_thread::sleep_for(std::chrono::milliseconds(2));
 
            if (!g_Config.Aimbot->Enabled || !(GetAsyncKeyState(g_Config.Aimbot->KeyBind) & 0x8000))
                continue;
 
            if (GetForegroundWindow() == g_Variables.g_hCheatWindow)
                continue;
 
            
            CPed* TargetPed = Core::SDK::Game::GetClosestPed(
                (int)g_Config.Aimbot->MaxDistance,
                g_Config.Aimbot->IgnoreNPCs,
                g_Config.Aimbot->OnlyVisible
            );
 
            if (!TargetPed) continue;
 
            
            D3DXVECTOR3 targetPos = GetTargetBonePosition(TargetPed, g_Config.Aimbot->HitBox);
            if (targetPos == D3DXVECTOR3(0, 0, 0)) continue;
 
            D3DXVECTOR2 ScreenPos = Core::SDK::Game::WorldToScreen(targetPos);
            if (Core::SDK::Game::IsOnScreen(ScreenPos))
            {
                float DistToCenter = std::hypot(ScreenPos.x - g_Variables.g_vGameWindowCenter.x, ScreenPos.y - g_Variables.g_vGameWindowCenter.y);
 
                o
                if (DistToCenter <= (float)g_Config.Aimbot->FOV)
                {
                    SetViewAngles(targetPos);
                }
            }
        }
    }
}
 
 
===============
 
SILENT:
 
#include "SilentAim.hpp"
 
bool Core::Features::cSilentAim::SilentAimInitialized;
std::uintptr_t Core::Features::cSilentAim::StartAddy;
 
void Core::Features::cSilentAim::InitializeSilentAim( )
{
    StartAddy = g_Offsets.m_SilentAim;
    SilentAimHook = Mem.CreateCodeCave( 500 );
 
    if ( !SilentAimHook )return;
 
    Mem.WriteBytes( SilentAimHook, SilentAimShell );
 
    OriginalFuncTable = Mem.ReadBytes( StartAddy, 38 );
 
    Mem.HookJMP( StartAddy, SilentAimHook );
}
 
void Core::Features::cSilentAim::RestoreSilent( )
{
    Mem.WriteBytes( StartAddy, OriginalFuncTable );
    Mem.FreeCave( SilentAimHook );
}
 
void Core::Features::cSilentAim::HookSilent()
{
    while (true)
    {
        if (g_Config.SilentAim->Enabled && g_Config.SilentAim->KeyBind != 0 && GetAsyncKeyState(g_Config.SilentAim->KeyBind) & 0x8000 && GetForegroundWindow() != g_Variables.g_hCheatWindow)
        {
            
            CPed* Ped = Core::SDK::Game::GetClosestPed(
                (int)g_Config.SilentAim->MaxDistance,
                g_Config.SilentAim->IgnoreNPCs,
                g_Config.SilentAim->OnlyVisible
            );
 
            if (!Ped) {
                
                if (SilentAimInitialized) {
                    RestoreSilent();
                    SilentAimInitialized = false;
                }
                continue;
            }
 
            
            D3DXVECTOR3 HeadPos = Ped->GetBonePosDefault(0);
            D3DXVECTOR2 HeadToScreen = Core::SDK::Game::WorldToScreen(HeadPos);
 
            if (Core::SDK::Game::IsOnScreen(HeadToScreen)) {
                
                float Fov = std::hypot(HeadToScreen.x - g_Variables.g_vGameWindowCenter.x, HeadToScreen.y - g_Variables.g_vGameWindowCenter.y);
 
                if (Fov <= (float)g_Config.SilentAim->FOV) {
 
                    if (!SilentAimInitialized) {
                        InitializeSilentAim();
                        SilentAimInitialized = true;
                    }
 
                    bool Miss = g_Config.SilentAim->MissChance >= (float)Utils::GenRandomInt(0, 100);
                    auto FinalPos = Miss ? HeadPos + D3DXVECTOR3(0.0, 0.4, 0) : HeadPos + D3DXVECTOR3(0, 0, 0.08);
 
                    memcpy(SilentAimShell.data() + 3, &FinalPos.x, sizeof(float));
                    memcpy(SilentAimShell.data() + 10, &FinalPos.y, sizeof(float));
                    memcpy(SilentAimShell.data() + 17, &FinalPos.z, sizeof(float));
 
                    uintptr_t BackAddress = (uintptr_t)(StartAddy + 0x26);
                    memcpy(SilentAimShell.data() + 27, &BackAddress, sizeof(BackAddress));
 
                    Mem.WriteBytes(SilentAimHook, SilentAimShell);
                }
                else {
                    if (SilentAimInitialized) {
                        RestoreSilent();
                        SilentAimInitialized = false;
                    }
                }
            }
            else {
                if (SilentAimInitialized) {
                    RestoreSilent();
                    SilentAimInitialized = false;
                }
            }
        }
        else {
            if (SilentAimInitialized) {
                RestoreSilent();
                SilentAimInitialized = false;
            }
        }
 
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
}

Ran into a specific server environment where the usual internal writes and silent aim hooks are getting absolutely clapped by a custom Lua-based anti-cheat. It looks like they are targeting the specific way most public bases handle view angle manipulation and damage modification.

The Anti-Cheat Logic Breakdown
Looking at the leaked AC script, they aren't even doing anything complex, but it's effective for catching low-tier pastes.

Detailed Rage Detection: They track shootCount within a GetGameTimer loop. If you're pushing more than 20 shots per second without an unarmed reset, it triggers a server-side detection event.
Camera Reset (Aimbot Kill): This is the annoying part. The AC monitors IsAimCamActive and IsControlPressed(0, 25). If active, it forcefully resets SetGameplayCamRelativePitch and Heading to 0.0. If your internal aimbot is writing to the camera offsets, the engine and the script are fighting for control, causing that "pulling wrong" feeling.
Silent Aim Mitigation: They've implemented a damage modifier spoof. If GetEntityPlayerIsFreeAimingAt returns 0 (meaning your crosshair isn't physically on the target), they set the weapon damage modifier to 0.0. Since silent aim doesn't move the actual crosshair/camera, your shots register as zeros.

Analyzing the Aimbot Source
The provided C++ aimbot is writing directly to CamFollowPedCamera at

Code:

pCamGamePlayDirector + 0x2C0

Code:

// ViewAngles at + 0x40
// CrosshairPos at + 0x60
// TPV Angles at + 0x3D0
Mem.Write<D3DXVECTOR3>(CamFollowPedCamera + 0x40, FinalAngles);
Mem.Write<D3DXVECTOR3>(CamFollowPedCamera + 0x3D0, ThirdPersonAngles);

To bypass the relative pitch resets from the Lua script, you likely need to hook the native SetGameplayCamRelativePitch or find the flag in the camera manager that the script uses to check if it should reset you.

The Silent Aim Problem
The silent aim implementation uses a code cave to redirect execution. However, the AC's applyOutgoingModifiers function is constantly polling.

Code:

local isAiming, aimedEntity = GetEntityPlayerIsFreeAimingAt(PlayerId())
local desiredDamage = 0.0
if originalWeaponDamageByHash[w] then
    if isAiming and aimedEntity ~= 0 and IsEntityAPed(aimedEntity) then
        desiredDamage = originalWeaponDamageByHash[w]
    else
        desiredDamage = 0.0
    end
    SetPlayerWeaponDamageModifier(PlayerId(), desiredDamage)
end

If you want silent aim to work here, you can't just redirect the bullet vector. You have to spoof the result of GetEntityPlayerIsFreeAimingAt to return the target entity, or hook the SetPlayerWeaponDamageModifier native so it can't be set to 0.0 by the server scripts.

Preventive Troubleshooting
— Disable IsAimCamActive checks if possible.
— Nuke the specific NetEvent

Code:

__RVSaimbot:detect

if you're running an executor with event blocking.
— For the "pulling" issue, check if the server is also forced-resetting your SetPedConfigFlag(ped, 43, false) which affects lock-on capabilities.

Anyone else dealt with this specific camera-locking method on FiveM lately?

Guide FiveM — Bypassing Camera-Based Aimbot & Damage-Modifier Silent AC

byte_corvus

Expert

Forum statistics