ghook/ground0 cheats

/*
    Ground0 Cheats

    Coded by cdriza and Q2F2/Cave

    Credits:
        cdriza - Almost everything
        Q2F2 - Localization & help
        Im Friendly - Silent Aim, some of the ESP, and help
        2cash - AAA stuff

    Update log:
    v1 - gHook
    v1.1 - add silent aim + move-fix
    v1.2 - fix move-fix
    v1.3 - add menu + anti-anti-aim
    v1.4 - add anti-aim
    v1.5 - random changes
    v1.6 - autostrafe + bhop fixes
    v1.7 - added comments
    v1.8 - added permanent nospread
    v1.9 - added experimental fakelag
    v2.0 - fixed fakelag, improved aimbot speeds, anti-anti-aim rewrite
*/

local _R                = debug.getregistry() // get the registry

// nice localization cdriza
// why thank you

local vAngle            = _R.Vector.Angle
local vLength           = _R.Vector.Length
local vDistance         = _R.Vector.Distance
local vToScreen         = _R.Vector.ToScreen
local aForward          = _R.Angle.Forward

local pGetShootPos      = _R.Player.GetShootPos
local pGetFriendStatus  = _R.Player.GetFriendStatus
local pGetActiveWeapon  = _R.Player.GetActiveWeapon
local pNick             = _R.Player.Nick
local pEyePos           = _R.Player.EyePos
local pTeam             = _R.Player.Team
local pInVehicle        = _R.Player.InVehicle
local pIsBot            = _R.Player.IsBot
local pAlive            = _R.Player.Alive

local eIsOnGround       = _R.Entity.IsOnGround
local eHealth           = _R.Entity.Health
local eIsPlayer         = _R.Entity.IsPlayer
local eLocalToWorld     = _R.Entity.LocalToWorld
local eGetPos           = _R.Entity.GetPos
local eOnGround         = _R.Entity.OnGround
local eOBBCenter        = _R.Entity.OBBCenter
local eDrawModel        = _R.Entity.DrawModel
local eWaterLevel       = _R.Entity.WaterLevel
local eGetMoveType      = _R.Entity.GetMoveType
local eGetClass         = _R.Entity.GetClass
local eLookupBone       = _R.Entity.LookupBone
local eGetVelocity      = _R.Entity.GetVelocity
local eHealth           = _R.Entity.Health
local eGetMaxHealth     = _R.Entity.GetMaxHealth
local eSetPoseParameter = _R.Entity.SetPoseParameter
local eInvalidateBoneCache = _R.Entity.InvalidateBoneCache
local eEyeAngles        = _R.Entity.EyeAngles
local eGetAttachment    = _R.Entity.GetAttachment
local eLookupAttachment = _R.Entity.LookupAttachment
local eOBBMaxs          = _R.Entity.OBBMaxs

local wClip1            = _R.Weapon.Clip1
local wGetNextPrimaryFire = _R.Weapon.GetNextPrimaryFire
local wGetActivity      = _R.Weapon.GetActivity

local cGetForwardMove   = _R.CUserCmd.GetForwardMove
local cGetSideMove      = _R.CUserCmd.GetSideMove
local cGetViewAngles    = _R.CUserCmd.GetViewAngles
local cSetViewAngles    = _R.CUserCmd.SetViewAngles
local cSetForwardMove   = _R.CUserCmd.SetForwardMove
local cSetSideMove      = _R.CUserCmd.SetSideMove
local cGetMouseX        = _R.CUserCmd.GetMouseX
local cGetMouseY        = _R.CUserCmd.GetMouseY
local cGetButtons       = _R.CUserCmd.GetButtons
local cSetButtons       = _R.CUserCmd.SetButtons
local cRemoveKey        = _R.CUserCmd.RemoveKey
local cKeyDown          = _R.CUserCmd.KeyDown
local cCommandNumber    = _R.CUserCmd.CommandNumber

local cvGetBool         = _R.ConVar.GetBool

local iIsMouseDown      = input.IsMouseDown
local iIsKeyDown        = input.IsKeyDown
local fExists           = file.Exists
local uJSONToTable      = util.JSONToTable
local uCRC              = util.CRC
local uTraceLine        = util.TraceLine
local eTickInterval     = engine.TickInterval
local mRandom           = math.random
local mAbs              = math.abs
local mAngleDifference  = math.AngleDifference
local mClamp            = math.Clamp
local mNormalizeAngle   = math.NormalizeAngle
local dSimpleText       = draw.SimpleText
local sSetDrawColor     = surface.SetDrawColor
local sDrawOutlinedRect = surface.DrawOutlinedRect
local tGetColor         = team.GetColor
local hAdd              = hook.Add
local pGetAll           = player.GetAll
local bBor              = bit.bor
local tCopy             = table.Copy
local vCreate           = vgui.Create
local tRandom           = table.Random
local sFind             = string.find

local tostring          = tostring
local next              = next
local Vector            = Vector
local IsEntity          = IsEntity
local IsValid           = IsValid
local Color             = Color
local MsgC              = MsgC
local Lerp              = Lerp
local pcall             = pcall
local CurTime           = CurTime
local IsFirstTimePredicted = IsFirstTimePredicted

local pLocalPlayer      = LocalPlayer() // localize us!

__gcopy = __gcopy || tCopy(_G) // get the existing _G copy, or make a new one!
__rcopy = __rcopy || tCopy(_R) // get the existing registry copy, or make a new one!
__gbackup = __gbackup || tCopy(GAMEMODE) // get the existing GAMEMODE copy, or make a new one!

local gHook             = {} // make our table!
gHook.AASwitch          = false // setup switch
gHook.CurTime           = 0 // set proper curtime var
gHook.FLQueue           = 0 // setup fakelag queue
gHook.SendPacket        = false // set can we fakelag var
gHook.Dickwrap          = nil // no copied dickwrap table right now
gHook.Aimbotting        = false // set are we aimbotting var
gHook.NoSpread          = false // set can we nospread var
gHook.MenuOpen          = false // set menuopen var
gHook.Insert            = false // set delete var
gHook.Insert2           = false // set delete2 var
gHook.FakeAngle         = Angle() // make the fake angle
gHook.Attacking         = false // we aren't attacking
gHook.Target            = nil // add a nil target
gHook.LastAng           = 540 // last yaw ang for aa

gHook.Settings          = { // table for storing our settings
    Aimbot = {
        bEnabled = false, // aimbot enabled var
        bAntiAntiAim = true, // anti-anti-aim var
        bNoSpread = true, // aimbot nospread var
        bTeam = false, // ignore team var
        bFriends = false, // ignore friends var
        bSilent = false, // silent aimbot var
        bAutoShoot = false, // autoshoot var
        bLegit = false, // legit aimbot var
    },

    Visuals = {
        bEnabled = false, // visuals enabled var
        bName = false, // name esp var
        bBox = false, // box esp var
        bHealth = false, // health esp var
        bTeam = false, // team color esp var
        bWatermark = false, // watermark var
    },

    Misc = {
        bBunnyHop = false, // bhop var
        bThirdperson = false, // thirdperson var
    },

    HvH = {
        bAntiAim = false, // aa var
        bJitter = false, // jitter aa var
        bFakeLag = false, // fakelag var
    },
}

gHook.Cones             = {} // weapon cone storage table

_R.Entity.FireBullets = function(pEnt, bul)
    local pWep = pGetActiveWeapon(pLocalPlayer) || NULL // get our active weapon

    if (!bul.Spread || !IsValid(pWep)) then return __rcopy.Entity.FireBullets(pEnt, bul) end // if the bullet doesn't have spread or the weapon isn't valid, return the copy and do nothing more

    if (!gHook.Cones[eGetClass(pWep)] || gHook.Cones[eGetClass(pWep)] != bul.Spread) then // if we don't have the cone or the old cone differs from the new cone
        gHook.Cones[eGetClass(pWep)] = bul.Spread * -1 // set the weapon cone for this weapon!
    end

    return __rcopy.Entity.FireBullets(pEnt, bul) // return the copy
end

function gHook.Notify(strMsg)
    MsgC(Color(0, 0, 255), "[gHook] ", Color(255, 255, 255), strMsg .. " \n") // message
end

gHook.Notify("Loading!") // we are loading!

local suc, err = pcall(require, "dickwrap") // pcall it

if suc and !err then
    gHook.Notify("Found dickwrap module, NoSpread is now enabled.") // notification
    gHook.NoSpread = true // we can nospread!
    require("dickwrap") // require it
    gHook.Dickwrap = tCopy(dickwrap) // copy the table
    _G["dickwrap"] = nil // set it to nil, anti-cheat proofing!
else
    gHook.Notify("The dickwrap module wasn't installed correctly, NoSpread is now disabled.") // notification
end

err = nil // set it to nil, incase you didn't have dickwrap installed and it was something, it would break this check

local suc, err = pcall(require, "bsendpacket") // pcall it

if suc and !err then
    gHook.Notify("Found dickwrap module, NoSpread is now enabled.") // notification
    gHook.SendPacket = true // we can fakelag!
    require("bsendpacket") // require it
    bSendPacket = true // initial true statement
else
    gHook.Notify("The dickwrap module wasn't installed correctly, NoSpread is now disabled.") // notification
end

function gHook.AntiAntiAim(pEnt)
    local angPitch = eEyeAngles(pEnt).p
    local angYaw = eEyeAngles(pEnt).y

    angYaw = mNormalizeAngle(angYaw)
    angYaw = mClamp(angYaw, -180, 180)

    if (angPitch > 89) then
        angPitch = 180 - angPitch
    elseif (-89 > angPitch) then
        angPitch = -88
    end

    eSetPoseParameter(pEnt, "aim_pitch", angPitch)
    eSetPoseParameter(pEnt, "aim_yaw", angYaw)
    eInvalidateBoneCache(pEnt)
end

function gHook.CheckVis(vecPos, pEnt)
    local tblTraceData = {
        ["start"] = pGetShootPos(pLocalPlayer), // the start of our trace is at our eye position!
        ["endpos"] = vecPos, // the end position is the place we want to see is visible
        ["filter"] = pLocalPlayer, // filter out us, we don't want it returning true because we were in the way!
        ["mask"] = MASK_SHOT // set the mask to mask_shot
    }

    if (gHook.Settings.Aimbot["bAntiAntiAim"]) then // if the anti-anti-aim variable is enabled
        gHook.AntiAntiAim(pEnt) // now is the perfect time to anti-anti-aim them!
    end

    local pTrace = uTraceLine(tblTraceData) // make a trace with our trace data
    return (pTrace.Fraction == 1 || pTrace.Entity == pEnt) // if it reached the destination or the entity at the end was the target, return true!
end

function gHook.GetPos(pEnt)
    local vecPos // localize the position variable

    if (eLookupAttachment(pEnt, "forward") != 0 && gHook.CheckVis(eGetAttachment(pEnt, eLookupAttachment(pEnt, "forward")).Pos, pEnt)) then // if it has the forward attachment and the forward attachment is visible
        vecPos = eGetAttachment(pEnt, eLookupAttachment(pEnt, "forward")).Pos // set the position to that attachment
        vecPos = vecPos + (eGetVelocity(pEnt) * eTickInterval()) // predict the target pos
        vecPos = vecPos - (eGetVelocity(pLocalPlayer) * eTickInterval()) // predict our pos

        return vecPos // return it, do nothing else
    end

    vecPos = eGetPos(pEnt) + eOBBCenter(pEnt) // if it doesn't have the forward attachment, get the center
    vecPos = vecPos + (eGetVelocity(pEnt) * eTickInterval()) // predict the target pos
    vecPos = vecPos - (eGetVelocity(pLocalPlayer) * eTickInterval()) // predict our pos

    return vecPos // return it
end

function gHook.CheckValid(pEnt) // huge valid check
    if (!pEnt || !IsEntity(pEnt) || !IsValid(pEnt) || pEnt == pLocalPlayer || !pAlive(pEnt) || 0 >= eHealth(pEnt) || pInVehicle(pEnt) || pTeam(pEnt) == TEAM_SPECTATOR || !gHook.CheckVis(gHook.GetPos(pEnt), pEnt)) then return false end
    if (gHook.Settings.Aimbot["bTeam"] && pTeam(pEnt) == pTeam(pLocalPlayer)) then return false end
    if (gHook.Settings.Aimbot["bFriends"] && pGetFriendStatus(pEnt) == "friend") then return false end

    return true
end

function gHook.OpenMenu()
    if (iIsKeyDown(KEY_DELETE) && !gHook.MenuOpen && !gHook.Insert) then // check if the delete key (menu toggle key) is down, the menu isn't opened, and we weren't pressing delete before
        gHook.Insert = true // we are now pressing delete, set this to true
        gHook.Menu() // open the menu!
    elseif (!iIsKeyDown(KEY_DELETE) && !gHook.MenuOpen) then // now we need a way to set the delete pressing var to false, if the delete key isn't pressed and the menu isn't opened
        gHook.Insert = false // we aren't pressing delete and the MENU ISN'T OPEN
    end

    if (iIsKeyDown(KEY_DELETE) && gHook.Insert && gHook.MenuOpen) then // if the delete key is down, delete var is true, and the menu is open
        gHook.Insert2 = true // set delete2 var to true
    else
        gHook.Insert2 = false // else set it to false
    end

    // DELETE2 VAR IS TO MAKE SURE THE MENU DOESN'T CLOSE WHEN YOU OPEN IT, IF WE DIDN'T HAVE THIS IT WOULD JUST START OPEN AND CLOSE SPAMMING AS SOON AS YOU OPENED IT!
end

function gHook.FindTarget()
    gHook.Target = nil // set the last target to nil
    local iMaxIndexes = #pGetAll() // get the amount of players

    for iPlayerIndex = 1, iMaxIndexes do // loop through them all
        local pEnt = pGetAll()[iPlayerIndex] // get the actual entity of the player
        if (gHook.CheckValid(pEnt)) then gHook.Target = pEnt else continue end // if its a valid aimbot target, set the target to that entity else check the next player
    end
end

function gHook.Attack(cmd)
    if (gHook.Attacking) then // if we're already attacking
        cRemoveKey(cmd, IN_ATTACK) // stop attacking
        gHook.Attacking = false // set attacking to false
    else
        cSetButtons(cmd, bBor(cGetButtons(cmd), IN_ATTACK)) // if we aren't attacking, start attacking
        gHook.Attacking = true // set attacking to true
    end
end

function gHook.Silent(cmd)
    if (gHook.Settings.Aimbot["bSilent"] || gHook.Settings.HvH["bAntiAim"] || gHook.Settings.Aimbot["bNoSpread"]) then // check if silent or anti aim is enabled or nospread
        gHook.FakeAngle = gHook.FakeAngle + Angle(cGetMouseY(cmd) * 0.023, cGetMouseX(cmd) * -0.023, 0) // if they are, make the fakeangle the last fakeangle + the current mouse pos
        gHook.FakeAngle.p = mClamp(gHook.FakeAngle.p, -89, 89) // clamp pitch
        gHook.FakeAngle.y = mNormalizeAngle(gHook.FakeAngle.y) // normalize yaw
    else
        gHook.FakeAngle = cGetViewAngles(cmd) // just set it to regular view angles, we don't need to do anything with it!
    end
end

function gHook.FixMove(cmd, bAntiAim) // NO CLUE WHAT THIS DOES, NOT MINE!
    local vecFix = Vector(cGetForwardMove(cmd), cGetSideMove(cmd), 0)
    vecFix = aForward(vAngle(vecFix) + cGetViewAngles(cmd) -Angle(0, gHook.FakeAngle.y, 0)) * vLength(vecFix)

    if (bAntiAim) then
        cSetForwardMove(cmd, vecFix.x)
        cSetSideMove(cmd, vecFix.y * -1)
        return
    end

    cSetForwardMove(cmd, vecFix.x)
    cSetSideMove(cmd, vecFix.y)
end

function gHook.GetSpread(cmd, angPos)
    if (!gHook.Dickwrap || !gHook.NoSpread) then return angPos end // check if we don't have dickwrap installed
    local pWep = pGetActiveWeapon(pLocalPlayer) or NULL // get the players active weapon or nothing if nothing is equipped
    local vecSpread // localized spread var, we'll use this later

    if (!IsValid(pWep)) then return angPos end // if the weapon isn't valid (NULL) then return the unpredicted position and do nothing more

    if (gHook.Cones[eGetClass(pWep)]) then // do we have this weapons spread?
        local pCone = gHook.Cones[eGetClass(pWep)] // if so get the cone

        if (type(pCone) == "number") then // if it's a number it needs to be a vector!
            vecSpread = Vector(-pCone, -pCone, 0) // make it a vector
        elseif (type(pCone) == "Vector") then // but if it's a vector
            vecSpread = pCone // don't do anything to it!
        end

        return vAngle(gHook.Dickwrap.Predict(cmd, aForward(angPos), pCone)) // use dickwrap's prediction to predict the spread, don't do anything else
    end

    return angPos // if we don't have the cone return the unpredicted position
end

function gHook.CanFire()
    if (!gHook.CurTime || gHook.CurTime == 0) then return false end // if we don't have the curtime variable, don't check anything!
    local pWep = pGetActiveWeapon(pLocalPlayer) or NULL // get the players active weapon or nothing if nothing is equipped

    if (!IsValid(pWep)) then return false end // if the weapon isn't valid (NULL) then return false, you can't fire nothing!
    return (wGetActivity(pWep) != ACT_RELOAD && gHook.CurTime > wGetNextPrimaryFire(pWep)) // return false if we are reloading or we can't fire or true if we can do both
end

function gHook.Aimbot(cmd)
    if (gHook.Settings.Aimbot["bEnabled"] && gHook.Target != nil && gHook.CanFire()) then // check if the aimbot var is enabled, the target is valid, and we can fire
        if (cCommandNumber(cmd) == 0 && !gHook.Settings.Misc["bThirdperson"]) then  // don't aimbot on extra mouse samples
            gHook.Aimbotting = false // we aren't aimbotting!

            if (gHook.Settings.Aimbot["bSilent"] || gHook.Settings.HvH["bAntiAim"] || gHook.Settings.Aimbot["bNoSpread"]) then // check if silent aim or anti aim is enabled or nospread
                cSetViewAngles(cmd, gHook.FakeAngle) // if so set it to our good and dandy fake angle
            end

            return
        end

        local angOView = cGetViewAngles(cmd) // old view angles
        local iOSideMove = cGetSideMove(cmd) // old side movement
        local iOForwardMove = cGetForwardMove(cmd) // old forward movement
        gHook.Aimbotting = true // we are aimbotting

        local angPos = vAngle(gHook.GetPos(gHook.Target) - pGetShootPos(pLocalPlayer)) // get their pos
        angPos.p = mNormalizeAngle(angPos.p) // normalize
        angPos.y = mNormalizeAngle(angPos.y) // normalize
        angPos.r = 0 // set the roll to 0, we don't want our screen flipped!

        if (gHook.Settings.Aimbot["bNoSpread"]) then // check if nospread is enabled
            angPos = gHook.GetSpread(cmd, angPos) // get spread angs
            angPos.p = mNormalizeAngle(angPos.p) // normalize
            angPos.y = mNormalizeAngle(angPos.y) // normalize
            angPos.r = 0 // no more roll pls
        end

        cSetViewAngles(cmd, (gHook.Settings.Aimbot["bLegit"] && Lerp(0.1, cGetViewAngles(cmd), angPos)) || angPos) // set our view angles

        local iDiff = mAbs(mAngleDifference(angPos.p, cGetViewAngles(cmd).p)) + mAbs(mAngleDifference(angPos.y, cGetViewAngles(cmd).y)) // get angle difference

        if (gHook.Settings.Aimbot["bAutoShoot"] && 5 > iDiff) then // check if autoshoot is enabled + check that we are near the players head, if we have legit aimbot enabled we could be ages away from the persons head, why shoot at the air?
            gHook.Attack(cmd) // attack!
        end

        if (gHook.Settings.Aimbot["bSilent"]) then // check if silent aimbot is enabled
            gHook.FixMove(cmd) // fix movement
        end

        return // return nothing and do nothing more, we don't want to say we're not aimbotting or setting our angles to the fake angle!
    end

    gHook.Aimbotting = false // we aren't aimbotting!

    if (gHook.Settings.Aimbot["bSilent"] || gHook.Settings.HvH["bAntiAim"] || gHook.Settings.Aimbot["bNoSpread"]) then // check if silent aim or anti aim is enabled or nospread
        cSetViewAngles(cmd, gHook.FakeAngle) // if so set it to our good and dandy fake angle
    end
end

function gHook.NoSpread(cmd)
    if (gHook.Settings.Aimbot["bNoSpread"] && cKeyDown(cmd, IN_ATTACK) && !gHook.Aimbotting && cmd:CommandNumber() != 0) then // check if nospread is enabled, we're holding down attack, and we aren't aimbotting
        local angSpread = gHook.GetSpread(cmd, cGetViewAngles(cmd)) // if so compensate the spread for our current view angles
        angSpread.x, angSpread.y = mNormalizeAngle(angSpread.x), mNormalizeAngle(angSpread.y) // normalize spread angles
        cSetViewAngles(cmd, angSpread) // then set our view angles!
    end
end

function gHook.AntiAim(cmd)
    if (gHook.Settings.HvH["bAntiAim"] && !iIsMouseDown(MOUSE_LEFT) && !gHook.Aimbotting && eGetMoveType(pLocalPlayer) != MOVETYPE_FLY && eGetMoveType(pLocalPlayer) != MOVETYPE_NOCLIP) then // LOADS OF CHECKS
        if (cCommandNumber(cmd) == 0 && !gHook.Settings.Misc["bThirdperson"]) then return end

        if (gHook.Settings.HvH["bJitter"]) then // check if jitter is enabled
            local angAAP = gHook.Settings.HvH["bJitter"] && mRandom(-180, 180) // random angles
            local angAAY = gHook.Settings.HvH["bJitter"] && mRandom(-360, 360) // random angles
            cSetViewAngles(cmd, Angle(angAAP, angAAY, 0)) // set the angles

            if (angAAP > 89 || angAAP < -89) then // check if we need to do a different movement fix
                gHook.FixMove(cmd, true) // do antiaim movement fix
            else
                gHook.FixMove(cmd) // regular movement fix
            end
        else
            gHook.LastAng = gHook.LastAng + 1 // lastang = lastang + 1

            if (gHook.LastAng > 550) then // if it's bigger than 550
                gHook.LastAng = 540 // set it to 540
            end

            if (gHook.AASwitch) then // if the switch is true
                cSetViewAngles(cmd, Angle(180, gHook.LastAng, 0)) // set it to 180
                if (gHook.SendPacket) then // if we have the bsendpacket module
                    bSendPacket = true // set bsendpacket to true
                end
            else // else
                cSetViewAngles(cmd, Angle(-180, gHook.LastAng, 0)) // set it to -180
                if (gHook.SendPacket) then // if we have the bsendpacket module
                    bSendPacket = false // set bsendpacket to false
                end
            end

            gHook.AASwitch = !gHook.AASwitch // set sideways switch
            gHook.FixMove(cmd, true) // fix our movement!
        end
    end
end

function gHook.FakeLag(cmd)
    if (gHook.Settings.HvH["bFakeLag"] && gHook.SendPacket) then // check if its enabled and we have the bsendpacket module
        if (cCommandNumber(cmd) == 0 || (gHook.Settings.HvH["bAntiAim"] && !gHook.Settings.HvH["bJitter"])) then return end // don't fakelag on extra mouse samples

        gHook.FLQueue = gHook.FLQueue + 1 // add one createmove tick to the queue

        if (gHook.FLQueue >= 0) then // if it's bigger than 0 or it is 0
            if (6 > gHook.FLQueue) then // and 6 (fakelag amount) is bigger than the queue
                bSendPacket = false // don't send packet
            else // else
                bSendPacket = true // send packets
            end
        else
            bSendPacket = true // send packets
        end

        if (gHook.FLQueue >= 15) then // if it's bigger than 15 (max fakelag amount)
            gHook.FLQueue = 0 // reset queue
        end
    else // if it's not enabled
        gHook.FLQueue = 0 // set the queue to nothing
        if (gHook.SendPacket) then bSendPacket = true end // if we have the bsendpacket module, we could've fakelagged earlier and had bsendpacket set to false so start sending packets
    end
end

function gHook.Bhop(cmd)
    if (gHook.Settings.Misc["bBunnyHop"] && eGetMoveType(pLocalPlayer) != MOVETYPE_FLY && eGetMoveType(pLocalPlayer) != MOVETYPE_NOCLIP) then // check if the bhop var is enabled, and make sure we aren't flying or noclipping
        if (eIsOnGround(pLocalPlayer) && cKeyDown(cmd, IN_JUMP)) then // check if we're on the ground and pressing jump
            cSetButtons(cmd, bBor(cGetButtons(cmd), IN_JUMP)) // set jump key
        else
            cRemoveKey(cmd, IN_JUMP) // stop jumping in the air!

            if (gHook.Settings.Misc["bAutoStrafe"] && cKeyDown(cmd, IN_JUMP)) then // broken autostrafe
                if (cGetMouseX(cmd) > 0) then // broken
                    cSetSideMove(cmd, 1000000) // autostrafe
                else
                    cSetSideMove(cmd, -1000000) // how to
                end
            end
        end
    end
end

function gHook.GetCol(pEnt)
    if (pTeam(pEnt) == pTeam(pLocalPlayer)) then // if it's us
        return Color(15, 255, 23) // then color should be green
    else
        return Color(255, 7, 2) // else it should be red
    end
end

function gHook.Visuals()
    if (!gHook.Settings.Visuals["bEnabled"]) then return end // check if visuals are enabled, if not then return nothing and do nothing

    for iPlayerIndex,pEnt in next, pGetAll() do // make a loop with all the players
        if (pEnt == pLocalPlayer || !pAlive(pEnt) || 0 >= eHealth(pEnt)) then continue end // if the player == you or the player isn't alive, don't draw and check another player

        local iMax = eOBBMaxs(pEnt) // max pos
        local vecTop = vToScreen(eGetPos(pEnt) + Vector(0, 0, iMax.z)) // top pos
        local vecBottom = vToScreen(eGetPos(pEnt)) // bottom pos
        local iMiddle = vecBottom.y - vecTop.y // middle pos
        local iWidth = iMiddle / 4 // width pos

        if (gHook.Settings.Visuals["bName"]) then // check if the name esp var is enabled
            dSimpleText(pNick(pEnt), "Trebuchet18", vecTop.x, vecTop.y - 10, color_white, TEXT_ALIGN_CENTER, TEXT_ALIGN_CENTER) // draw that text
        end

        if (gHook.Settings.Visuals["bBox"]) then // check if the (bounding) box esp var is enabled
            sSetDrawColor((gHook.Settings.Visuals["bTeam"] && tGetColor(pTeam(pEnt))) || gHook.GetCol(pEnt)) // set the draw color
            sDrawOutlinedRect(vecTop.x - iWidth, vecTop.y, iWidth * 2, iMiddle) // draw box
            sSetDrawColor(Color(0, 0, 0)) // set to black draw color
            sDrawOutlinedRect(vecTop.x - iWidth - 1, vecTop.y - 1, iWidth * 2 + 2, iMiddle + 2) // draw outline
            sDrawOutlinedRect(vecTop.x - iWidth + 1, vecTop.y + 1, iWidth * 2 - 2, iMiddle - 2) // draw outline
        end

        if (gHook.Settings.Visuals["bHealth"]) then // check if the health esp var is enabled
            dSimpleText(eHealth(pEnt) .. " HP", "Trebuchet18", vecTop.x, vecBottom.y + 10, Color(0, 255, 0), TEXT_ALIGN_CENTER, TEXT_ALIGN_CENTER) // draw the player's health
        end
    end

    if (gHook.Settings.Visuals["bWatermark"]) then // check if the watermark var is enabled
        dSimpleText("Ground0 Cheats", "Trebuchet18", 50, 12, Color(0, 0, 255), TEXT_ALIGN_CENTER, TEXT_ALIGN_CENTER) // draw the watermark
    end
end

function gHook.Menu() // not listing for this massive menu codes, 2long
    gHook.MenuOpen = true

    local main = vCreate("DFrame")
    main:SetSize(790, 600)
    main:SetTitle("")
    main:Center()
    main:MakePopup()
    main:ShowCloseButton(false)
    main.Paint = function(self)
        draw.RoundedBox(0, 0, 0, self:GetWide(), self:GetTall(), Color(255, 255, 255))
        local colGradient = Color(0, 0, 170)

        for i = 0, 40 do
            surface.SetDrawColor(colGradient)
            colGradient.b = colGradient.b - 1
            surface.DrawLine(0, i, 790, i)
        end

        surface.SetDrawColor(colGradient)

        surface.DrawRect(0, 31, 5, self:GetTall() - 31)
        surface.DrawRect(0, self:GetTall() - 5, self:GetWide(), self:GetTall())
        surface.DrawRect(self:GetWide() - 5, 31, 5, self:GetTall())

        draw.SimpleText("Ground0 Cheats", "Trebuchet24", self:GetWide() / 2, 20, Color(255, 255, 255), TEXT_ALIGN_CENTER, TEXT_ALIGN_CENTER)
    end

    local aimbot = vCreate("DButton", main)
    aimbot:SetSize(196, 40)
    aimbot:SetPos(5, 41)
    aimbot:SetText("")
    aimbot.Paint = function(self)
        draw.RoundedBox(4, 0, 0, self:GetWide(), self:GetTall(), Color(75, 75, 75))
        surface.SetDrawColor(70, 70, 70)
        surface.DrawOutlinedRect(0, 0, self:GetWide(), self:GetTall())
        draw.SimpleText("Aimbot", "Trebuchet18", self:GetWide() / 2 - 22, self:GetTall() / 2 - 7, color_white)
    end

    local visuals = vCreate("DButton", main)
    visuals:SetSize(196, 40)
    visuals:SetPos(201, 41)
    visuals:SetText("")
    visuals.Paint = function(self)
        draw.RoundedBox(4, 0, 0, self:GetWide(), self:GetTall(), Color(75, 75, 75))
        surface.SetDrawColor(70, 70, 70)
        surface.DrawOutlinedRect(0, 0, self:GetWide(), self:GetTall())
        draw.SimpleText("Visuals", "Trebuchet18", self:GetWide() / 2 - 22, self:GetTall() / 2 - 7, color_white)
    end

    local misc = vCreate("DButton", main)
    misc:SetSize(196, 40)
    misc:SetPos(397, 41)
    misc:SetText("")
    misc.Paint = function(self)
        draw.RoundedBox(4, 0, 0, self:GetWide(), self:GetTall(), Color(75, 75, 75))
        surface.SetDrawColor(70, 70, 70)
        surface.DrawOutlinedRect(0, 0, self:GetWide(), self:GetTall())
        draw.SimpleText("Misc", "Trebuchet18", self:GetWide() / 2 - 9, self:GetTall() / 2 - 7, color_white)
    end

    local hvh = vCreate("DButton", main)
    hvh:SetSize(192, 40)
    hvh:SetPos(593, 41)
    hvh:SetText("")
    hvh.Paint = function(self)
        draw.RoundedBox(4, 0, 0, self:GetWide(), self:GetTall(), Color(75, 75, 75))
        surface.SetDrawColor(70, 70, 70)
        surface.DrawOutlinedRect(0, 0, self:GetWide(), self:GetTall())
        draw.SimpleText("HvH", "Trebuchet18", self:GetWide() / 2 - 9, self:GetTall() / 2 - 7, color_white)
    end

    local aim_enable = vCreate("DCheckBoxLabel", main)
    aim_enable:SetPos(7, 85)
    aim_enable:SetText("Enabled")
    aim_enable:SetVisible(false)
    aim_enable:SetValue(gHook.Settings.Aimbot["bEnabled"])
    aim_enable:SizeToContents()
    aim_enable.OnChange = function(self)
        gHook.Settings.Aimbot["bEnabled"] = tobool(self:GetChecked())
    end

    local aim_aaa = vCreate("DCheckBoxLabel", main)
    aim_aaa:SetPos(7, 105)
    aim_aaa:SetText("Anti Anti-Aim")
    aim_aaa:SetVisible(false)
    aim_aaa:SetValue(gHook.Settings.Aimbot["bAntiAntiAim"])
    aim_aaa:SizeToContents()
    aim_aaa.OnChange = function(self)
        gHook.Settings.Aimbot["bAntiAntiAim"] = tobool(self:GetChecked())
    end

    local aim_nospread = vCreate("DCheckBoxLabel", main)
    aim_nospread:SetPos(7, 125)
    aim_nospread:SetText("NoSpread")
    aim_nospread:SetVisible(false)
    aim_nospread:SetValue(gHook.Settings.Aimbot["bNoSpread"])
    aim_nospread:SizeToContents()
    aim_nospread.OnChange = function(self)
        gHook.Settings.Aimbot["bNoSpread"] = tobool(self:GetChecked())
    end

    local aim_team = vCreate("DCheckBoxLabel", main)
    aim_team:SetPos(7, 145)
    aim_team:SetText("Ignore Team")
    aim_team:SetVisible(false)
    aim_team:SetValue(gHook.Settings.Aimbot["bTeam"])
    aim_team:SizeToContents()
    aim_team.OnChange = function(self)
        gHook.Settings.Aimbot["bTeam"] = tobool(self:GetChecked())
    end

    local aim_friends = vCreate("DCheckBoxLabel", main)
    aim_friends:SetPos(7, 165)
    aim_friends:SetText("Ignore Friends")
    aim_friends:SetVisible(false)
    aim_friends:SetValue(gHook.Settings.Aimbot["bFriends"])
    aim_friends:SizeToContents()
    aim_friends.OnChange = function(self)
        gHook.Settings.Aimbot["bFriends"] = tobool(self:GetChecked())
    end

    local aim_silent = vCreate("DCheckBoxLabel", main)
    aim_silent:SetPos(7, 185)
    aim_silent:SetText("Silent Aim")
    aim_silent:SetVisible(false)
    aim_silent:SetValue(gHook.Settings.Aimbot["bSilent"])
    aim_silent:SizeToContents()
    aim_silent.OnChange = function(self)
        gHook.Settings.Aimbot["bSilent"] = tobool(self:GetChecked())
    end

    local aim_auto = vCreate("DCheckBoxLabel", main)
    aim_auto:SetPos(7, 205)
    aim_auto:SetText("AutoShoot")
    aim_auto:SetVisible(false)
    aim_auto:SetValue(gHook.Settings.Aimbot["bAutoShoot"])
    aim_auto:SizeToContents()
    aim_auto.OnChange = function(self)
        gHook.Settings.Aimbot["bAutoShoot"] = tobool(self:GetChecked())
    end

    local aim_legit = vCreate("DCheckBoxLabel", main)
    aim_legit:SetPos(7, 225)
    aim_legit:SetText("Legit Mode")
    aim_legit:SetVisible(false)
    aim_legit:SetValue(gHook.Settings.Aimbot["bLegit"])
    aim_legit:SizeToContents()
    aim_legit.OnChange = function(self)
        gHook.Settings.Aimbot["bLegit"] = tobool(self:GetChecked())
    end

    local vis_enabled = vCreate("DCheckBoxLabel", main)
    vis_enabled:SetPos(7, 85)
    vis_enabled:SetText("Enabled")
    vis_enabled:SetVisible(false)
    vis_enabled:SetValue(gHook.Settings.Visuals["bEnabled"])
    vis_enabled:SizeToContents()
    vis_enabled.OnChange = function(self)
        gHook.Settings.Visuals["bEnabled"] = tobool(self:GetChecked())
    end

    local vis_name = vCreate("DCheckBoxLabel", main)
    vis_name:SetPos(7, 105)
    vis_name:SetText("Name ESP")
    vis_name:SetVisible(false)
    vis_name:SetValue(gHook.Settings.Visuals["bName"])
    vis_name:SizeToContents()
    vis_name.OnChange = function(self)
        gHook.Settings.Visuals["bName"] = tobool(self:GetChecked())
    end

    local vis_box = vCreate("DCheckBoxLabel", main)
    vis_box:SetPos(7, 125)
    vis_box:SetText("2D Box ESP")
    vis_box:SetVisible(false)
    vis_box:SetValue(gHook.Settings.Visuals["bBox"])
    vis_box:SizeToContents()
    vis_box.OnChange = function(self)
        gHook.Settings.Visuals["bBox"] = tobool(self:GetChecked())
    end

    local vis_health = vCreate("DCheckBoxLabel", main)
    vis_health:SetPos(7, 145)
    vis_health:SetText("Health ESP")
    vis_health:SetVisible(false)
    vis_health:SetValue(gHook.Settings.Visuals["bHealth"])
    vis_health:SizeToContents()
    vis_health.OnChange = function(self)
        gHook.Settings.Visuals["bHealth"] = tobool(self:GetChecked())
    end

    local vis_team = vCreate("DCheckBoxLabel", main)
    vis_team:SetPos(7, 165)
    vis_team:SetText("Team Color ESP")
    vis_team:SetVisible(false)
    vis_team:SetValue(gHook.Settings.Visuals["bTeam"])
    vis_team:SizeToContents()
    vis_team.OnChange = function(self)
        gHook.Settings.Visuals["bTeam"] = tobool(self:GetChecked())
    end

    local vis_watermark = vCreate("DCheckBoxLabel", main)
    vis_watermark:SetPos(7, 185)
    vis_watermark:SetText("Watermark")
    vis_watermark:SetVisible(false)
    vis_watermark:SetValue(gHook.Settings.Visuals["bWatermark"])
    vis_watermark:SizeToContents()
    vis_watermark.OnChange = function(self)
        gHook.Settings.Visuals["bWatermark"] = tobool(self:GetChecked())
    end

    local misc_bhop = vCreate("DCheckBoxLabel", main)
    misc_bhop:SetPos(7, 85)
    misc_bhop:SetText("Bunny Hop")
    misc_bhop:SetVisible(false)
    misc_bhop:SetValue(gHook.Settings.Misc["bBunnyHop"])
    misc_bhop:SizeToContents()
    misc_bhop.OnChange = function(self)
        gHook.Settings.Misc["bBunnyHop"] = tobool(self:GetChecked())
    end

    local misc_thirdperson = vCreate("DCheckBoxLabel", main)
    misc_thirdperson:SetPos(7, 105)
    misc_thirdperson:SetText("ThirdPerson")
    misc_thirdperson:SetVisible(false)
    misc_thirdperson:SetValue(gHook.Settings.Misc["bThirdperson"])
    misc_thirdperson:SizeToContents()
    misc_thirdperson.OnChange = function(self)
        gHook.Settings.Misc["bThirdperson"] = tobool(self:GetChecked())
    end

    local hvh_antiaim = vCreate("DCheckBoxLabel", main)
    hvh_antiaim:SetPos(7, 85)
    hvh_antiaim:SetText("Anti-Aim")
    hvh_antiaim:SetVisible(false)
    hvh_antiaim:SetValue(gHook.Settings.HvH["bAntiAim"])
    hvh_antiaim:SizeToContents()
    hvh_antiaim.OnChange = function(self)
        gHook.Settings.HvH["bAntiAim"] = tobool(self:GetChecked())
    end

    local hvh_jitter = vCreate("DCheckBoxLabel", main)
    hvh_jitter:SetPos(7, 105)
    hvh_jitter:SetText("Jitter Anti-Aim")
    hvh_jitter:SetVisible(false)
    hvh_jitter:SetValue(gHook.Settings.HvH["bJitter"])
    hvh_jitter:SizeToContents()
    hvh_jitter.OnChange = function(self)
        gHook.Settings.HvH["bJitter"] = tobool(self:GetChecked())
    end

    local hvh_fakelag = vCreate("DCheckBoxLabel", main)
    hvh_fakelag:SetPos(7, 125)
    hvh_fakelag:SetText("FakeLag")
    hvh_fakelag:SetVisible(false)
    hvh_fakelag:SetValue(gHook.Settings.HvH["bFakeLag"])
    hvh_fakelag:SizeToContents()
    hvh_fakelag.OnChange = function(self)
        gHook.Settings.HvH["bFakeLag"] = tobool(self:GetChecked())
    end

    local function SetVis(strGroup, bVis)
        if (strGroup == "aimbot") then
            aim_enable:SetVisible(bVis)
            aim_aaa:SetVisible(bVis)
            aim_nospread:SetVisible(bVis)
            aim_team:SetVisible(bVis)
            aim_friends:SetVisible(bVis)
            aim_silent:SetVisible(bVis)
            aim_auto:SetVisible(bVis)
            aim_legit:SetVisible(bVis)
        elseif (strGroup == "visuals") then
            vis_enabled:SetVisible(bVis)
            vis_name:SetVisible(bVis)
            vis_box:SetVisible(bVis)
            vis_health:SetVisible(bVis)
            vis_team:SetVisible(bVis)
            vis_watermark:SetVisible(bVis)
        elseif (strGroup == "misc") then
            misc_bhop:SetVisible(bVis)
            misc_thirdperson:SetVisible(bVis)
        elseif (strGroup == "hvh") then
            hvh_antiaim:SetVisible(bVis)
            hvh_jitter:SetVisible(bVis)
            hvh_fakelag:SetVisible(bVis)
        end
    end

    aimbot.DoClick = function()
        SetVis("aimbot", true)
        SetVis("visuals", false)
        SetVis("misc", false)
        SetVis("hvh", false)
    end

    visuals.DoClick = function()
        SetVis("aimbot", false)
        SetVis("visuals", true)
        SetVis("misc", false)
        SetVis("hvh", false)
    end

    misc.DoClick = function()
        SetVis("aimbot", false)
        SetVis("visuals", false)
        SetVis("misc", true)
        SetVis("hvh", false)
    end

    hvh.DoClick = function()
        SetVis("aimbot", false)
        SetVis("visuals", false)
        SetVis("misc", false)
        SetVis("hvh", true)
    end

    main.Think = function()
        if (input.IsKeyDown(KEY_DELETE) && !gHook.Insert2) then
            main:Remove()
            gHook.MenuOpen = false
        end
    end
end

function gHook.CreateMove(cmd)
    gHook.Silent(cmd) // call silent aimbot code
    gHook.Aimbot(cmd) // call aimbot
    gHook.NoSpread(cmd) // call nospread
    gHook.AntiAim(cmd) // call antiaim
    gHook.FakeLag(cmd) // call fakelag
    gHook.Bhop(cmd) // call bhop
end

function gHook.DrawOverlay()
    gHook.Visuals() // do the visuals (ESP and stuff)
end

function gHook.Think()
    gHook.FindTarget() // find aimbot targets
    gHook.OpenMenu() // check if the menu can be opened
end

function gHook.CalcView(ply, pos, angle, fov, nearZ, farZ)
    local view = {} // make a new viewtable

    view.angles = gHook.FakeAngle // set the fake angle so we don't look like we're jittering clientside with silent aim and anti aim
    view.origin = gHook.Settings.Misc["bThirdperson"] && pos - gHook.FakeAngle:Forward() * 100 || pos // set the origin

    return view // return it
end

function gHook.Move()
    if (IsFirstTimePredicted()) then // if it's the first time being predicted
        gHook.CurTime = CurTime() + eTickInterval() // set the proper curtime to regular curtime + the tick interval
    end
end

function gHook.AddHook(strHookType, funcHook)
    gHook.Notify("Hooking " .. strHookType) // notify that this is being hooked

    if (GAMEMODE[strHookType] && __gbackup[strHookType]) then // check if it's a valid hook
        GAMEMODE[strHookType] = function(self, ...) // detour it
            __gbackup[strHookType](self, ...) // call the gamemode function
            local retable = {funcHook(...)} // thank you
            if (retable) then return unpack(retable) end // razor
        end
    end
end

function GetConVarString(cvar)
    if (cvar == "sv_allowcslua" or cvar == "sv_cheats") then // YOU
        return "0" // SIMPLY
    end

    if (cvar == "host_timescale") then // CANNOT
        return "1.0" // TOUCH
    end

    if (cvar == "host_framerate") then // THIS
        return "0" // AMAZING
    end

    return __gcopy["GetConVarString"](cvar) // CHEAT
end

function GetConVarNumber(cvar)
    if (cvar == "sv_allowcslua" or cvar == "sv_cheats") then // check if it's one of these
        return 0 // nope
    end

    if (cvar == "host_timescale") then // host_timescale?
        return 1.0 // NOPE
    end

    if (cvar == "host_framerate") then // HOST_FRAMERATE?!?!?!?
        return 0 // and i'm like "can't touch this"
    end

    return __gcopy["GetConVarNumber"](cvar) // return regular
end

function GetConVar(cvar)
    if (cvar == "sv_allowcslua" or cvar == "sv_cheats" or cvar == "host_framerate") then // check if its one of these
        return __gcopy["GetConVar"]("cl_voicedistance") // crossing my fingers, it should be set to 0
    end

    if (cvar == "host_timescale") then // check if it's host_timescale
        return __gcopy["GetConVar"]("r_drawothermodels") // return r_drawothermodels, it should always be set to 1
    end

    return __gcopy["GetConVar"](cvar) // return regular
end

function file.Open(name, mode, path)
    if (sFind(name, "g0.lua") or sFind(name, "gHook.lua") or sFind(name, "dickwrap")) then // is it one of the cheat's files?
        return nil // can't touch this
    end

    return __gcopy["file"].Open(name, mode, path) // return regular, not one of our names
end

function file.Exists(name, path)
    if (sFind(name, "g0.lua") or sFind(name, "gHook.lua") or sFind(name, "dickwrap")) then // it better not be our cheat names!
        return false // if it is, return false, we don't want them to know we exist
    end

    return __gcopy["file"].Exists(name, path) // return regular, not one of our names
end

function debug.getinfo(func, fields) // detour debug.getinfo
    if func == GetConVarString or func == GetConVarNumber or func == GetConVar or func == file.Open or func == file.Exists or func == debug.getinfo then // check if it's a function we've detoured
        local tbl = __gcopy["debug.getinfo"](__gcopy["debug.getinfo"], fields) // get the dgi table
        tbl.func = func // bypass some more (rare) checks
        return tbl // return it
    end

    return __gcopy["debug"].getinfo(func, fields) // not a detoured func, return regular
end

GAMEMODE["ShouldDrawLocalPlayer"] = function(...)
    return gHook.Settings.Misc["bThirdperson"] // if thirdperson is enabled, show us
end

gHook.AddHook("CreateMove", gHook.CreateMove) // hook createmove
gHook.AddHook("DrawOverlay", gHook.DrawOverlay) // hook drawoverlay
gHook.AddHook("Think", gHook.Think) // hook think
gHook.AddHook("CalcView", gHook.CalcView) // hook calcview
gHook.AddHook("Move", gHook.Move) // hook move
gHook.Notify("Loaded!") // loaded message