Anti-Aimbot v4.1.1 Phasor 2.0+

----------------------------------------------------------------------------
----------------- Anti-Aimbot Script v4.1.1 for Phasor 2.0 -----------------
------ Thanks to Wizard for helping add aiming though wall detection -------
----- and optimizing the script so that it can run faster. Also thanks -----
-------- to all the other people who helped make & test this script --------
--------------------- Creator(s): Skylace & Wizard -------------------------
----------------------------------------------------------------------------

-- At what aimbot score should we take an action on the player?
-- I recommend anywhere from 1500 to 5000.
local max_score = 2000

-- What action to take when a player has been detected as a bot?
local action = "ban"

-- Time to ban a player (in minutes.)
local ban_time = "1440"

-- Minimum stop angle to be considered a snap.
local snap_stop_angle = 10

-- Rate in which to reduce a players aimbot score (in seconds.)
local aimbot_score_depletion_rate = 1.5

-- Score removed when aimbot_score_depletion_rate is called.
local aimbot_score_depletion = 3

-- Message that is sent to admins when an action has been called on a player.
local notify_admins = false

 -- Should the script create a Antibot.log file?
local logging_enabled = true

----------------------------------------------------------------------------
-- DO NOT TOUCH ANYTHING BELOW THIS POINT UNLESS YOU KNOW WHAT YOUR DOING --
----------------------------------------------------------------------------

local player_score = {}
local spawning = {}
local loc = {}
local camera_table = {}

local bipd_id
local bipd_tag
local bipd_data
local standing_height
local crouch_height

function GetRequiredVersion()
    return 200
end

function OnPlayerJoin(playerId)
    camera_table[playerId] = nil
    player_score[playerId] = 0
end

function OnPlayerLeave(playerId)
    camera_table[playerId] = nil
    player_score[playerId] = 0
end

function OnScriptLoad(process, game, persistent)
    for i = 0,15 do
        loc[i] = {}
        camera_table[i] = nil
        player_score[i] = 0
    end
    registertimer(aimbot_score_depletion_rate * 1000, "score_depletion")
end

function OnServerCommand(playerId, command, password)
    local response = nil
    t = tokenizecmdstring(command)
    count = #t
        if t[1] == "sv_getscore" then
            response = 0
            if tonumber(t[2]) ~= nil then
                sendconsoletext(playerId, math.floor(tonumber(player_score[rresolveplayer(t[2])])))
            else
                sendconsoletext(playerId, "Invalid Player!")
            end
        elseif t[1] == "sv_getscores" or t[1] == "sv_aimbot_scores" then
            response = 0
            sendconsoletext(playerId, "Name  |  Score")
            for i = 0,15 do
                if getplayer(i) then
                    sendconsoletext(playerId, getname(i) .. "  |  " .. math.floor(tonumber(player_score[i])))
                end
            end
        elseif t[1] == "sv_aimbot_ban" then
            response = 0
            if t[2] ~= nil then
                if tonumber(t[1]) ~= nil then
                    maxt_score = tonumber(t[1])
                else
                    sendconsoletext(playerId, "Invalid Score! Use a number.")
                end
                if tostring(t[2]) == "ban" or tostring(t[3]) == "kick" or tostring(t[3]) == "none" then
                    action = tostring(t[2])
                else
                    sendconsoletext(playerId, "Invalid action! Use ban, kick, or none.")
                end
                if tonumber(t[3]) ~= nil then
                    ban_time = tonumber(t[3])
                else
                    sendconsoletext(playerId, "Invalid time! Ban time is in minutes")
                end
            else
                sendconsoletext(playerId, "Invalid Syntax! sv_aimbot_ban [type] {score} {time}")
            end
        end
    return response
end

function score_depletion(id, count)
    for i = 0,15 do
        if getplayer(i) ~= nil then
            if tonumber(player_score[i]) > 0 then
                player_score[i] = tonumber(player_score[i]) - aimbot_score_depletion
            elseif tonumber(player_score[i]) < 0 then
                player_score[i] = 0
            end
        end
    end
    return true
end

function OnPlayerKill(killer, victim, mode)
    camera_table[victim] = nil
end

function OnPlayerSpawn(playerId)
    if not bipd_id then
        bipd_id = readdword(getobject(getplayerobjectid(playerId)))
        bipd_tag = gettagaddress(bipd_id)
        bipd_data = readdword(bipd_tag + 0x14)
        standing_height = readfloat(bipd_data + 0x400)
        crouch_height = readfloat(bipd_data + 0x404)
    end
    camera_table[playerId] = nil
    spawning[playerId] = true
    registertimer(1500, "removegrace", playerId)
end

function removegrace(id, count, playerId)
    spawning[playerId] = false
end

local function WriteLog(filename, value)
    if logging_enabled then
        local file = io.open(filename, "a")
        if file then
            file:write( string.format("%s\t%s\n", os.date("!%m/%d/%Y %H:%M:%S"), tostring(value) ) )
            file:close()
        end
    end
end

local function getping(playerId)
    return readword(getplayer(playerId) + 0xDC)
end

local function takeaction(playerId)

    local log_file = getprofilepath() .. "\\logs\\Antibot.log"
    local line = "(Name: %s) (Hash: %s) (IP: %s) (Ping: %s) (Score: %s) (Action: %s)"
    local Line = string.format(line, getname(playerId), gethash(playerId), getip(playerId), getping(playerId), math.floor(tonumber(player_score[playerId])), action)
    WriteLog(log_file, Line)

    if notify_admins then
        for i=0,15 do
            if isadmin(i) then
                privatesay(i, "Name: " .. getname(playerId) .. " - Action taken: " .. action .. " - Aimbot Score:" .. math.floor(tonumber(player_score[playerId])))
            end
        end
    end
    local player_id = resolveplayer(playerId)
    if action == "ban" then
        if ban_time then
            svcmd("sv_ban " .. player_id .. " " .. ban_time .. "m")
        else
            svcmd("sv_ban " .. player_id)
        end
        say(getname(playerId) .. " has been banned from the server for aimbotting!")
        player_score[playerId] = 0
    elseif action == "kick" then
        svcmd("sv_kick " .. player_id)
        player_score[playerId] = 0
        say(getname(playerId) .. " has been kicked from the server for aimbotting!")
    elseif action == "none" or action == "warn" then
        say(getname(playerId) .. " may very possibly be aimbotting! Id: " .. player_id)
    end
end

local function OnPlayerTeleport(playerId)
    spawning[playerId] = true
    registertimer(500, "removegrace", playerId)
end

local function checkforteleport(playerId)

    local m_objectId = getplayerobjectid(playerId)
        local x,y,z = getobjectcoords(m_objectId)

    if x ~= loc[playerId][1] or y ~= loc[playerId][2] or z ~= loc[playerId][3] then
        if loc[playerId][1] == nil then
            loc[playerId][1] = x
            loc[playerId][2] = y
            loc[playerId][3] = z
        elseif m_object then
            distance = math.sqrt((loc[playerId][1] - x)^2 + (loc[playerId][2] - y)^2 + (loc[playerId][3] - z)^2)
            local result = true
            if distance >= 10 then result = OnPlayerTeleport(playerId) end
            if result == 0 or result == false then
                --movobjectcoords(m_objectId, loc[playerId][1], loc[playerId][2], loc[playerId][3])
                loc[playerId][1] = x
                loc[playerId][2] = y
                loc[playerId][3] = z
            else
                loc[playerId][1] = x
                loc[playerId][2] = y
                loc[playerId][3] = z
            end
        end
    end
end

local function getstopangle(playerId, x_aim, y_aim, z_aim)
    local m_objectId = getplayerobjectid(playerId)
    local m_object = getobject(m_objectId)

    if camera_table[playerId] == nil then
        camera_table[playerId] = {x_aim, y_aim, z_aim}
        return
    end

    local last_camera_x = camera_table[playerId][1]
    local last_camera_y = camera_table[playerId][2]
    local last_camera_z = camera_table[playerId][3]

    camera_table[playerId] = {x_aim, y_aim, z_aim}

    if  last_camera_x == 0 and
        last_camera_y == 0 and
        last_camera_z == 0 then
        return
    end

    local movement = math.sqrt(
        (x_aim - last_camera_x) ^ 2 +
        (y_aim - last_camera_y) ^ 2 +
        (z_aim - last_camera_z) ^ 2)

    local angle = math.acos((2 - movement ^ 2) / 2)
    stop_angle = angle * 180 / math.pi

    return stop_angle
end

local function Intersect(playerId, vx, vy, vz)

    local playerObjId = getplayerobjectid(playerId)
    local m_object = getobject(playerObjId)
    if not m_object then
        return
    end

    local crouch_state = readfloat(m_object + 0x50C)
    local px, py, pz = getobjectcoords(playerObjId)
    if (crouch_state == 0) then
        pz = pz + standing_height
    else
        pz = pz + (crouch_height * crouch_state)
    end

    local hit,x,y,z,objectId = halointersect(1000, px, py, pz, vx, vy, vz, playerObjId)
    local walls = 1
    while hit == true and walls < 20 do
        local playerId2 = objectId and objectidtoplayer(objectId)
        if not playerId2 then
            walls = walls + 1
            hit,x,y,z,objectId = halointersect(1000, x, y, z, vx, vy, vz, objectId)
        else
            --say(getname(playerId) .. " is aiming at " .. getname(playerId2))
            return true, getteam(playerId) == getteam(playerId2), math.sqrt((x - px) ^ 2 + (y - py) ^ 2 + (z - pz) ^ 2), walls
        end
    end
end

function OnClientUpdate(playerId)
    if not bipd_id then
        return
    end

    checkforteleport(playerId)

    if spawning[playerId] then
        return
    end

    local m_objectId = getplayerobjectid(playerId)
    local m_object = getobject(m_objectId)

    local x_aim,y_aim,z_aim = readfloat(m_object + 0x230),readfloat(m_object + 0x234),readfloat(m_object + 0x238)
    local stop_angle = getstopangle(playerId, x_aim, y_aim, z_aim)

    if stop_angle ~= nil then else stop_angle = 1 end

    if stop_angle <= snap_stop_angle then
        return
    end

    local hitting, at_teammate, distance, walls = Intersect(playerId, x_aim, y_aim, z_aim)
    if distance ~= nil then else distance = 1 end
    if hitting and not at_teammate then
        if walls < 2 then score_multiplier = 0.125 else score_multiplier = 0.175 end
        if tonumber(player_score[playerId]) then
            player_score[playerId] = tonumber(player_score[playerId]) + (stop_angle * score_multiplier  * distance)
            if tonumber(player_score[playerId]) > max_score then
                takeaction(playerId)
            end
        else
            player_score[playerId] = (stop_angle * score_multiplier * distance)
        end
    end
end