--// Axiom Player Tools
--// Version: 1.62.12
--// Status: BETA 12
--// Player + ESP + Aimbot + Utilities + Developer
--// Rayfield Gen2
--// Keybind System: Toggle / Hold / Smart
--// Mouse Keys: LMB / RMB
--// Object Selector
--// Shared Target Database
--// No Silent Aim
--// No exthus.digital runtime requests

--========================================================--
-- SERVICES
--========================================================--

local Players = game:GetService("Players")
local Workspace = game:GetService("Workspace")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local TeleportService = game:GetService("TeleportService")
local Lighting = game:GetService("Lighting")
local VirtualUser = game:GetService("VirtualUser")
local GuiService = game:GetService("GuiService")
local HttpService = game:GetService("HttpService")

local LocalPlayer = Players.LocalPlayer
local CoreGui = game:GetService("CoreGui")

--========================================================--
-- RAYFIELD
--========================================================--

local Rayfield = loadstring(game:HttpGet(
    "https://sirius.menu/gen2"
))()

local Window = Rayfield:CreateWindow({
    Name = "Axiom Player Tools",
    LoadingTitle = "Axiom Player Tools",
    LoadingSubtitle = "BETA 12",

    ConfigurationSaving = {
        Enabled = false
    },

    Discord = {
        Enabled = false
    },

    KeySystem = false
})

--========================================================--
-- STATE
--========================================================--

local Player = {
    WalkSpeed = 16,
    JumpPower = 50,
    InfiniteJump = false,
    Gravity = 196.2,
    CameraFOV = 70,

    FlyEnabled = false,
    FlySpeed = 75,

    Noclip = false,
    AutoSprint = false,
    Fullbright = false,
    AntiAFK = false,
}

local ESP = {
    Enabled = false,
    NPCEnabled = false,

    Names = true,
    Distance = true,
    Health = true,
    Tracers = false,

    TeamColors = true,
    Rainbow = false,

    Outline = true,
    Fill = false,

    OutlineTransparency = 0,
    FillTransparency = 0.7,

    MaxDistance = 1000,

    PlayerColor = Color3.fromRGB(255, 255, 255),
    NPCColor = Color3.fromRGB(255, 170, 0),
}

local Aimbot = {
    Enabled = false,
    UseAimKey = true,

    AimAtPlayers = true,
    AimAtNPCs = false,

    OnlyVisible = true,
    TargetPart = "Head",
    LockTarget = false,

    TeamCheck = false,
    IgnoreDead = true,

    FOV = 150,
    MaxDistance = 500,
    Smoothness = 15,

    Prediction = false,
    PredictionStrength = 0.1,

    ShowFOV = false,
    FOVColor = Color3.fromRGB(255, 255, 255),

    Target = nil,
}

--========================================================--
-- CONTROL REGISTRY
--========================================================--

local Controls = {}

local function RegisterControl(name, control)
    Controls[name] = control
    return control
end

local function SetControlValue(control, value)
    if not control then
        return
    end

    pcall(function()
        if typeof(control.Set) == "function" then
            control:Set(value)
            return
        end

        if typeof(control.SetValue) == "function" then
            control:SetValue(value)
            return
        end

        if typeof(control.SetCurrentValue) == "function" then
            control:SetCurrentValue(value)
            return
        end
    end)
end

--========================================================--
-- KEYBIND SYSTEM
--========================================================--

local KeybindSystem = {
    Bindings = {},

    MouseNames = {
        [Enum.UserInputType.MouseButton1] = "LMB",
        [Enum.UserInputType.MouseButton2] = "RMB",
    },
}

local function NormalizeKey(key)
    if typeof(key) == "EnumItem" then
        return key
    end

    if typeof(key) ~= "string" then
        return Enum.KeyCode.Unknown
    end

    if key == "LMB" then
        return Enum.UserInputType.MouseButton1
    end

    if key == "RMB" then
        return Enum.UserInputType.MouseButton2
    end

    for _, item in ipairs(Enum.KeyCode:GetEnumItems()) do
        if item.Name:lower() == key:lower() then
            return item
        end
    end

    return Enum.KeyCode.Unknown
end

local function KeyToString(key)
    if not key then
        return "Unknown"
    end

    if typeof(key) == "EnumItem" then
        if key.EnumType == Enum.UserInputType then
            return KeybindSystem.MouseNames[key] or key.Name
        end

        return key.Name
    end

    return tostring(key)
end

local function IsInputMatch(key, input)
    if not key or not input then
        return false
    end

    return key == input.KeyCode
        or key == input.UserInputType
end

function KeybindSystem:Register(name, defaultKey, defaultMode)
    self.Bindings[name] = {
        Key = NormalizeKey(defaultKey),
        Mode = defaultMode or "Toggle",
        Active = false,
        Held = false,
    }

    return self.Bindings[name]
end

function KeybindSystem:SetKey(name, key)
    local binding = self.Bindings[name]

    if binding then
        binding.Key = NormalizeKey(key)
    end
end

function KeybindSystem:SetMode(name, mode)
    local binding = self.Bindings[name]

    if not binding then
        return
    end

    if mode ~= "Toggle"
        and mode ~= "Hold"
        and mode ~= "Smart" then
        mode = "Toggle"
    end

    binding.Mode = mode
    binding.Active = false
    binding.Held = false
end

function KeybindSystem:IsActive(name)
    local binding = self.Bindings[name]

    return binding
        and binding.Active
        or false
end

function KeybindSystem:TriggerDown(name)
    local binding = self.Bindings[name]

    if not binding then
        return
    end

    if binding.Held then
        return
    end

    binding.Held = true

    if binding.Mode == "Toggle" then
        binding.Active = not binding.Active

    elseif binding.Mode == "Hold" then
        binding.Active = true

    elseif binding.Mode == "Smart" then
        binding.Active = true
    end
end

function KeybindSystem:TriggerUp(name)
    local binding = self.Bindings[name]

    if not binding then
        return
    end

    binding.Held = false

    if binding.Mode == "Hold"
        or binding.Mode == "Smart" then
        binding.Active = false
    end
end

KeybindSystem:Register(
    "Fly",
    Enum.KeyCode.F,
    "Toggle"
)

KeybindSystem:Register(
    "Noclip",
    Enum.KeyCode.N,
    "Toggle"
)

KeybindSystem:Register(
    "InfiniteJump",
    Enum.KeyCode.J,
    "Toggle"
)

KeybindSystem:Register(
    "Fullbright",
    Enum.KeyCode.B,
    "Toggle"
)

KeybindSystem:Register(
    "AntiAFK",
    Enum.KeyCode.P,
    "Toggle"
)

KeybindSystem:Register(
    "AutoSprint",
    Enum.KeyCode.LeftShift,
    "Smart"
)

KeybindSystem:Register(
    "Aimbot",
    Enum.UserInputType.MouseButton2,
    "Hold"
)

UserInputService.InputBegan:Connect(function(input, processed)
    if processed then
        return
    end

    for name, binding in pairs(KeybindSystem.Bindings) do
        if IsInputMatch(binding.Key, input) then
            KeybindSystem:TriggerDown(name)
        end
    end
end)

UserInputService.InputEnded:Connect(function(input)
    for name, binding in pairs(KeybindSystem.Bindings) do
        if IsInputMatch(binding.Key, input) then
            KeybindSystem:TriggerUp(name)
        end
    end
end)

--========================================================--
-- CHARACTER
--========================================================--

local Character
local Humanoid
local RootPart

local function UpdateCharacterReferences(char)
    Character = char

    if char then
        Humanoid = char:FindFirstChildOfClass("Humanoid")
        RootPart = char:FindFirstChild("HumanoidRootPart")
    else
        Humanoid = nil
        RootPart = nil
    end
end

UpdateCharacterReferences(LocalPlayer.Character)

local function GetCamera()
    return Workspace.CurrentCamera
end

local function GetHumanoid(model)
    if not model then
        return nil
    end

    return model:FindFirstChildOfClass("Humanoid")
end

local function GetRoot(model)
    if not model then
        return nil
    end

    return model:FindFirstChild("HumanoidRootPart")
        or model:FindFirstChild("UpperTorso")
        or model:FindFirstChild("Torso")
end

local function GetTargetPart(model, partName)
    if not model then
        return nil
    end

    return model:FindFirstChild(partName)
        or model:FindFirstChild("Head")
        or GetRoot(model)
end

--========================================================--
-- FLY
--========================================================--

local FlyBV
local FlyBG

local function CleanupFlyObjects()
    if FlyBV then
        FlyBV:Destroy()
        FlyBV = nil
    end

    if FlyBG then
        FlyBG:Destroy()
        FlyBG = nil
    end
end

local function StopFly(disableFeature)
    CleanupFlyObjects()

    if disableFeature then
        Player.FlyEnabled = false
    end
end

local function StartFly()
    if not Player.FlyEnabled then
        return
    end

    if not Character or not RootPart then
        return
    end

    CleanupFlyObjects()

    FlyBV = Instance.new("BodyVelocity")
    FlyBV.Name = "AxiomFlyVelocity"
    FlyBV.MaxForce = Vector3.new(
        math.huge,
        math.huge,
        math.huge
    )
    FlyBV.Velocity = Vector3.zero
    FlyBV.Parent = RootPart

    FlyBG = Instance.new("BodyGyro")
    FlyBG.Name = "AxiomFlyGyro"
    FlyBG.MaxTorque = Vector3.new(
        math.huge,
        math.huge,
        math.huge
    )
    FlyBG.P = 90000
    FlyBG.CFrame = RootPart.CFrame
    FlyBG.Parent = RootPart
end

local function UpdateFly()
    if not Player.FlyEnabled then
        return
    end

    if not Character
        or not RootPart
        or not Humanoid then
        return
    end

    if not FlyBV or not FlyBG then
        StartFly()
        return
    end

    local camera = GetCamera()

    if not camera then
        return
    end

    local move = Vector3.zero

    if UserInputService:IsKeyDown(Enum.KeyCode.W) then
        move += camera.CFrame.LookVector
    end

    if UserInputService:IsKeyDown(Enum.KeyCode.S) then
        move -= camera.CFrame.LookVector
    end

    if UserInputService:IsKeyDown(Enum.KeyCode.A) then
        move -= camera.CFrame.RightVector
    end

    if UserInputService:IsKeyDown(Enum.KeyCode.D) then
        move += camera.CFrame.RightVector
    end

    if UserInputService:IsKeyDown(Enum.KeyCode.E) then
        move += Vector3.yAxis
    end

    if UserInputService:IsKeyDown(Enum.KeyCode.Q) then
        move -= Vector3.yAxis
    end

    if move.Magnitude > 0 then
        move = move.Unit * Player.FlySpeed
    end

    FlyBV.Velocity = move
    FlyBG.CFrame = camera.CFrame
end

--========================================================--
-- MOVEMENT
--========================================================--

local function ApplyMovement()
    if not Humanoid then
        return
    end

    Humanoid.WalkSpeed = Player.WalkSpeed
    Humanoid.UseJumpPower = true
    Humanoid.JumpPower = Player.JumpPower
end

local function ApplyGravity()
    Workspace.Gravity = Player.Gravity
end

local function ApplyCameraFOV()
    local camera = GetCamera()

    if camera then
        camera.FieldOfView = Player.CameraFOV
    end
end

local function ApplyFullbright()
    if Player.Fullbright then
        Lighting.Brightness = 2
        Lighting.ClockTime = 14
        Lighting.FogEnd = 100000
        Lighting.GlobalShadows = false
        Lighting.OutdoorAmbient =
            Color3.fromRGB(128, 128, 128)
    end
end

local function UpdateNoclip()
    if not Character then
        return
    end

    for _, object in ipairs(
        Character:GetDescendants()
    ) do
        if object:IsA("BasePart") then
            object.CanCollide = not Player.Noclip
        end
    end
end

UserInputService.JumpRequest:Connect(function()
    if Player.InfiniteJump and Humanoid then
        Humanoid:ChangeState(
            Enum.HumanoidStateType.Jumping
        )
    end
end)

--========================================================--
-- CHARACTER EVENTS
--========================================================--

LocalPlayer.CharacterRemoving:Connect(function()
    CleanupFlyObjects()
end)

LocalPlayer.CharacterAdded:Connect(function(char)
    task.wait(0.25)

    UpdateCharacterReferences(char)

    ApplyMovement()
    ApplyGravity()
    ApplyCameraFOV()
    ApplyFullbright()

    if Player.Noclip then
        UpdateNoclip()
    end

    if Player.FlyEnabled then
        task.wait(0.1)
        StartFly()
    end
end)

--========================================================--
-- TARGET DATABASE
--========================================================--

local AxiomTargetDatabase = {
    Players = {},
    NPCs = {},

    PlayerSet = {},
    NPCSet = {},

    Dirty = true,
    LastRebuild = 0,
    RebuildDelay = 0.35,
}

local function IsNPCModel(object)
    if not object:IsA("Model") then
        return false
    end

    local humanoid =
        object:FindFirstChildOfClass("Humanoid")

    local root =
        object:FindFirstChild("HumanoidRootPart")

    if not humanoid or not root then
        return false
    end

    for _, player in ipairs(
        Players:GetPlayers()
    ) do
        if player.Character == object then
            return false
        end
    end

    return true
end

local function MarkTargetDatabaseDirty()
    AxiomTargetDatabase.Dirty = true
end

local function RebuildTargetDatabase(force)
    local now = os.clock()

    if not force then
        if not AxiomTargetDatabase.Dirty then
            return
        end

        if now - AxiomTargetDatabase.LastRebuild
            < AxiomTargetDatabase.RebuildDelay then
            return
        end
    end

    AxiomTargetDatabase.LastRebuild = now
    AxiomTargetDatabase.Dirty = false

    table.clear(AxiomTargetDatabase.Players)
    table.clear(AxiomTargetDatabase.NPCs)
    table.clear(AxiomTargetDatabase.PlayerSet)
    table.clear(AxiomTargetDatabase.NPCSet)

    for _, player in ipairs(
        Players:GetPlayers()
    ) do
        if player ~= LocalPlayer
            and player.Character then

            local model = player.Character

            if GetHumanoid(model)
                and GetRoot(model) then

                table.insert(
                    AxiomTargetDatabase.Players,
                    {
                        Player = player,
                        Model = model,
                    }
                )

                AxiomTargetDatabase.PlayerSet[model] = true
            end
        end
    end

    for _, object in ipairs(
        Workspace:GetDescendants()
    ) do
        if IsNPCModel(object) then
            table.insert(
                AxiomTargetDatabase.NPCs,
                {
                    Model = object,
                }
            )

            AxiomTargetDatabase.NPCSet[object] = true
        end
    end
end

Players.PlayerAdded:Connect(function(player)
    player.CharacterAdded:Connect(
        MarkTargetDatabaseDirty
    )

    player.CharacterRemoving:Connect(
        MarkTargetDatabaseDirty
    )

    MarkTargetDatabaseDirty()
end)

Players.PlayerRemoving:Connect(
    MarkTargetDatabaseDirty
)

for _, player in ipairs(
    Players:GetPlayers()
) do
    player.CharacterAdded:Connect(
        MarkTargetDatabaseDirty
    )

    player.CharacterRemoving:Connect(
        MarkTargetDatabaseDirty
    )
end

Workspace.DescendantAdded:Connect(function(object)
    if object:IsA("Model")
        or object:IsA("Humanoid")
        or object:IsA("BasePart") then

        MarkTargetDatabaseDirty()
    end
end)

Workspace.DescendantRemoving:Connect(
    MarkTargetDatabaseDirty
)

RebuildTargetDatabase(true)

--========================================================--
-- TARGET VALIDATION
--========================================================--

local function IsAlive(model)
    local humanoid = GetHumanoid(model)

    if not humanoid then
        return false
    end

    return humanoid.Health > 0
end

local function IsSameTeam(player)
    if not player or not LocalPlayer then
        return false
    end

    if LocalPlayer.Team and player.Team then
        return LocalPlayer.Team == player.Team
    end

    return false
end

local function IsVisible(targetPart, targetModel)
    local camera = GetCamera()

    if not camera or not targetPart then
        return false
    end

    local origin = camera.CFrame.Position
    local direction =
        targetPart.Position - origin

    local params = RaycastParams.new()

    params.FilterType =
        Enum.RaycastFilterType.Exclude

    params.FilterDescendantsInstances = {
        Character,
        targetModel,
    }

    params.IgnoreWater = true

    local result =
        Workspace:Raycast(
            origin,
            direction,
            params
        )

    return result == nil
end

local function IsValidAimbotPlayer(entry)
    if not entry
        or not entry.Player
        or not entry.Model then
        return false
    end

    local model = entry.Model

    if not model.Parent then
        return false
    end

    if Aimbot.IgnoreDead
        and not IsAlive(model) then
        return false
    end

    if Aimbot.TeamCheck
        and IsSameTeam(entry.Player) then
        return false
    end

    return true
end

local function IsValidAimbotNPC(entry)
    if not entry
        or not entry.Model then
        return false
    end

    local model = entry.Model

    if not model.Parent then
        return false
    end

    if Aimbot.IgnoreDead
        and not IsAlive(model) then
        return false
    end

    return true
end

--========================================================--
-- AIMBOT FOV
--========================================================--

local FOVGui = Instance.new("ScreenGui")
FOVGui.Name = "AxiomAimbotFOV"
FOVGui.ResetOnSpawn = false
FOVGui.IgnoreGuiInset = true
FOVGui.DisplayOrder = 999999
FOVGui.Parent = CoreGui

local FOVCircle = Instance.new("Frame")
FOVCircle.Name = "FOVCircle"
FOVCircle.AnchorPoint =
    Vector2.new(0.5, 0.5)
FOVCircle.BackgroundTransparency = 1
FOVCircle.Visible = false
FOVCircle.Parent = FOVGui

local FOVCorner = Instance.new("UICorner")
FOVCorner.CornerRadius = UDim.new(1, 0)
FOVCorner.Parent = FOVCircle

local FOVStroke = Instance.new("UIStroke")
FOVStroke.Thickness = 1.5
FOVStroke.Color = Aimbot.FOVColor
FOVStroke.Parent = FOVCircle

local function UpdateFOV()
    local camera = GetCamera()

    if not camera then
        return
    end

    local viewport = camera.ViewportSize

    FOVCircle.Position = UDim2.fromOffset(
        viewport.X / 2,
        viewport.Y / 2
    )

    FOVCircle.Size = UDim2.fromOffset(
        Aimbot.FOV * 2,
        Aimbot.FOV * 2
    )

    FOVStroke.Color = Aimbot.FOVColor

    FOVCircle.Visible = Aimbot.ShowFOV
end

--========================================================--
-- AIMBOT
--========================================================--

local function GetTargetScreenPosition(part)
    local camera = GetCamera()

    if not camera or not part then
        return nil, false
    end

    local position, onScreen =
        camera:WorldToViewportPoint(
            part.Position
        )

    return Vector2.new(
        position.X,
        position.Y
    ), onScreen
end

local function GetBestAimbotTarget()
    local camera = GetCamera()

    if not camera then
        return nil
    end

    local viewport = camera.ViewportSize

    local screenCenter = Vector2.new(
        viewport.X / 2,
        viewport.Y / 2
    )

    local bestTarget
    local bestDistance = math.huge

    if Aimbot.AimAtPlayers then
        for _, entry in ipairs(
            AxiomTargetDatabase.Players
        ) do
            if IsValidAimbotPlayer(entry) then
                local model = entry.Model

                local root = GetRoot(model)
                local part = GetTargetPart(
                    model,
                    Aimbot.TargetPart
                )

                if root and part then
                    local distance =
                        (
                            camera.CFrame.Position
                            - root.Position
                        ).Magnitude

                    if distance <= Aimbot.MaxDistance then
                        local screenPosition, onScreen =
                            GetTargetScreenPosition(part)

                        if screenPosition and onScreen then
                            local fovDistance =
                                (
                                    screenPosition
                                    - screenCenter
                                ).Magnitude

                            if fovDistance <= Aimbot.FOV
                                and fovDistance < bestDistance then

                                local visible = true

                                if Aimbot.OnlyVisible then
                                    visible =
                                        IsVisible(
                                            part,
                                            model
                                        )
                                end

                                if visible then
                                    bestDistance =
                                        fovDistance

                                    bestTarget = {
                                        Model = model,
                                        Player = entry.Player,
                                        Part = part,
                                    }
                                end
                            end
                        end
                    end
                end
            end
        end
    end

    if Aimbot.AimAtNPCs then
        for _, entry in ipairs(
            AxiomTargetDatabase.NPCs
        ) do
            if IsValidAimbotNPC(entry) then
                local model = entry.Model

                local root = GetRoot(model)
                local part = GetTargetPart(
                    model,
                    Aimbot.TargetPart
                )

                if root and part then
                    local distance =
                        (
                            camera.CFrame.Position
                            - root.Position
                        ).Magnitude

                    if distance <= Aimbot.MaxDistance then
                        local screenPosition, onScreen =
                            GetTargetScreenPosition(part)

                        if screenPosition and onScreen then
                            local fovDistance =
                                (
                                    screenPosition
                                    - screenCenter
                                ).Magnitude

                            if fovDistance <= Aimbot.FOV
                                and fovDistance < bestDistance then

                                local visible = true

                                if Aimbot.OnlyVisible then
                                    visible =
                                        IsVisible(
                                            part,
                                            model
                                        )
                                end

                                if visible then
                                    bestDistance =
                                        fovDistance

                                    bestTarget = {
                                        Model = model,
                                        Player = nil,
                                        Part = part,
                                    }
                                end
                            end
                        end
                    end
                end
            end
        end
    end

    return bestTarget
end

local function AimAtTarget(target)
    local camera = GetCamera()

    if not camera
        or not target
        or not target.Part then
        return
    end

    local part = target.Part

    if not part.Parent then
        return
    end

    local position = part.Position

    if Aimbot.Prediction then
        local velocity = Vector3.zero

        pcall(function()
            velocity =
                part.AssemblyLinearVelocity
        end)

        position +=
            velocity
            * Aimbot.PredictionStrength
    end

    local desired =
        CFrame.lookAt(
            camera.CFrame.Position,
            position
        )

    if Aimbot.Smoothness <= 1 then
        camera.CFrame = desired
        return
    end

    local alpha = math.clamp(
        1 / Aimbot.Smoothness,
        0.01,
        1
    )

    camera.CFrame =
        camera.CFrame:Lerp(
            desired,
            alpha
        )
end

--========================================================--
-- ESP
--========================================================--

local ESPGui = Instance.new("ScreenGui")
ESPGui.Name = "AxiomESP"
ESPGui.ResetOnSpawn = false
ESPGui.IgnoreGuiInset = true
ESPGui.DisplayOrder = 999998
ESPGui.Parent = CoreGui

local ESPObjects = {}

local TracerGui = Instance.new("ScreenGui")
TracerGui.Name = "AxiomTracers"
TracerGui.ResetOnSpawn = false
TracerGui.IgnoreGuiInset = true
TracerGui.DisplayOrder = 999997
TracerGui.Parent = CoreGui

local TracerObjects = {}

-- Destroy ESP highlight BEFORE applying a new one.
local function DestroyESPHighlight(object)
    if object and object.Highlight then
        object.Highlight:Destroy()
        object.Highlight = nil
    end
end

local function DestroyESPObject(model)
    local object = ESPObjects[model]

    if object then
        if object.Gui then
            object.Gui:Destroy()
        end

        DestroyESPHighlight(object)

        ESPObjects[model] = nil
    end

    local tracer = TracerObjects[model]

    if tracer then
        tracer:Destroy()
        TracerObjects[model] = nil
    end
end

local function ApplyESPHighlight(object)
    if not object or not object.Model then
        return
    end

    -- Always destroy the previous highlight first.
    DestroyESPHighlight(object)

    if not ESP.Outline and not ESP.Fill then
        return
    end

    local highlight = Instance.new("Highlight")

    highlight.Name = "AxiomHighlight"
    highlight.DepthMode =
        Enum.HighlightDepthMode.AlwaysOnTop

    highlight.Adornee = object.Model

    highlight.OutlineTransparency =
        ESP.Outline
        and ESP.OutlineTransparency
        or 1

    highlight.FillTransparency =
        ESP.Fill
        and ESP.FillTransparency
        or 1

    highlight.OutlineColor =
        GetESPColor(object)

    highlight.FillColor =
        GetESPColor(object)

    highlight.Parent = Workspace

    object.Highlight = highlight
end

local function CreateESPObject(model, isNPC, player)
    if ESPObjects[model] then
        return ESPObjects[model]
    end

    local billboard = Instance.new("BillboardGui")

    billboard.Name = "AxiomESP"
    billboard.AlwaysOnTop = true
    billboard.Size = UDim2.fromOffset(
        180,
        70
    )
    billboard.StudsOffset =
        Vector3.new(0, 3, 0)
    billboard.ResetOnSpawn = false
    billboard.Adornee = model
    billboard.Parent = ESPGui

    local label = Instance.new("TextLabel")

    label.BackgroundTransparency = 1
    label.Size = UDim2.fromScale(1, 1)
    label.Font = Enum.Font.GothamBold
    label.TextSize = 13
    label.TextStrokeTransparency = 0.35
    label.TextWrapped = true
    label.Parent = billboard

    local object = {
        Model = model,
        IsNPC = isNPC,
        Player = player,

        Gui = billboard,
        Label = label,

        Highlight = nil,
    }

    ESPObjects[model] = object

    -- Apply a completely fresh highlight.
    ApplyESPHighlight(object)

    return object
end

local function GetESPColor(object)
    if ESP.Rainbow then
        local hue =
            (os.clock() % 5) / 5

        return Color3.fromHSV(
            hue,
            1,
            1
        )
    end

    if object
        and object.Player
        and ESP.TeamColors then

        local team =
            object.Player.Team

        if team then
            return team.TeamColor.Color
        end
    end

    if object and object.IsNPC then
        return ESP.NPCColor
    end

    return ESP.PlayerColor
end

local function CreateTracer(model)
    if TracerObjects[model] then
        return TracerObjects[model]
    end

    local frame = Instance.new("Frame")

    frame.Name = "AxiomTracer"
    frame.AnchorPoint =
        Vector2.new(0, 0.5)
    frame.BorderSizePixel = 0
    frame.BackgroundTransparency = 0.15
    frame.Visible = false
    frame.Parent = TracerGui

    TracerObjects[model] = frame

    return frame
end

local function UpdateTracer(model, object)
    local tracer = TracerObjects[model]

    if not tracer then
        tracer = CreateTracer(model)
    end

    if not ESP.Tracers then
        tracer.Visible = false
        return
    end

    if not object then
        tracer.Visible = false
        return
    end

    local root = GetRoot(model)
    local camera = GetCamera()

    if not root or not camera then
        tracer.Visible = false
        return
    end

    local distance =
        (
            camera.CFrame.Position
            - root.Position
        ).Magnitude

    if distance > ESP.MaxDistance then
        tracer.Visible = false
        return
    end

    if not IsAlive(model) then
        tracer.Visible = false
        return
    end

    local position, onScreen =
        camera:WorldToViewportPoint(
            root.Position
        )

    if not onScreen or position.Z <= 0 then
        tracer.Visible = false
        return
    end

    local viewport = camera.ViewportSize

    local startPosition = Vector2.new(
        viewport.X / 2,
        viewport.Y
    )

    local endPosition = Vector2.new(
        position.X,
        position.Y
    )

    local delta =
        endPosition - startPosition

    local length = delta.Magnitude

    if length < 2 then
        tracer.Visible = false
        return
    end

    tracer.Position = UDim2.fromOffset(
        startPosition.X,
        startPosition.Y
    )

    tracer.Size = UDim2.fromOffset(
        length,
        2
    )

    tracer.Rotation = math.deg(
        math.atan2(
            delta.Y,
            delta.X
        )
    )

    tracer.BackgroundColor3 =
        GetESPColor(object)

    tracer.Visible = true
end

local function RefreshESP()
    local keep = {}

    if ESP.Enabled then
        for _, entry in ipairs(
            AxiomTargetDatabase.Players
        ) do
            if entry.Model
                and entry.Model.Parent then

                keep[entry.Model] = true

                CreateESPObject(
                    entry.Model,
                    false,
                    entry.Player
                )
            end
        end
    end

    if ESP.NPCEnabled then
        for _, entry in ipairs(
            AxiomTargetDatabase.NPCs
        ) do
            if entry.Model
                and entry.Model.Parent then

                keep[entry.Model] = true

                CreateESPObject(
                    entry.Model,
                    true,
                    nil
                )
            end
        end
    end

    for model in pairs(ESPObjects) do
        if not keep[model] then
            DestroyESPObject(model)
        end
    end

    -- Re-apply ESP highlights from scratch.
    for model, object in pairs(ESPObjects) do
        DestroyESPHighlight(object)
        ApplyESPHighlight(object)
    end
end

local function UpdateESP()
    for model, object in pairs(ESPObjects) do
        if not model.Parent then
            DestroyESPObject(model)
            continue
        end

        local root = GetRoot(model)
        local humanoid = GetHumanoid(model)
        local camera = GetCamera()

        if not root
            or not humanoid
            or not camera then

            object.Gui.Enabled = false

            if object.Highlight then
                object.Highlight.Enabled = false
            end

            UpdateTracer(model, nil)

            continue
        end

        local distance =
            (
                camera.CFrame.Position
                - root.Position
            ).Magnitude

        if distance > ESP.MaxDistance
            or humanoid.Health <= 0 then

            object.Gui.Enabled = false

            if object.Highlight then
                object.Highlight.Enabled = false
            end

            UpdateTracer(model, nil)

            continue
        end

        object.Gui.Enabled = true

        local text = {}

        if ESP.Names then
            if object.Player then
                table.insert(
                    text,
                    object.Player.DisplayName
                )
            else
                table.insert(
                    text,
                    model.Name
                )
            end
        end

        if ESP.Distance then
            table.insert(
                text,
                string.format(
                    "[%d studs]",
                    math.floor(distance)
                )
            )
        end

        if ESP.Health then
            table.insert(
                text,
                string.format(
                    "HP: %d/%d",
                    math.floor(
                        humanoid.Health
                    ),
                    math.floor(
                        humanoid.MaxHealth
                    )
                )
            )
        end

        object.Label.Text =
            table.concat(
                text,
                "\n"
            )

        object.Label.TextColor3 =
            GetESPColor(object)

        if object.Highlight then
            object.Highlight.Enabled =
                ESP.Outline or ESP.Fill

            object.Highlight.OutlineTransparency =
                ESP.Outline
                and ESP.OutlineTransparency
                or 1

            object.Highlight.FillTransparency =
                ESP.Fill
                and ESP.FillTransparency
                or 1

            object.Highlight.OutlineColor =
                GetESPColor(object)

            object.Highlight.FillColor =
                GetESPColor(object)
        end

        UpdateTracer(
            model,
            object
        )
    end
end

--========================================================--
-- KEYBIND UI
--========================================================--

local KeybindControls = {}

local function CreateKeybindControls(
    tab,
    name,
    title,
    defaultKey,
    defaultMode
)
    local binding =
        KeybindSystem.Bindings[name]

    local keyControl = tab:CreateKeybind({
        Name = title .. " Key",

        CurrentKeybind =
            KeyToString(binding.Key),

        HoldToInteract = false,

        Flag =
            "Axiom_"
            .. name
            .. "_Key",

        Callback = function(key)
            KeybindSystem:SetKey(
                name,
                key
            )
        end,
    })

    local modeControl =
        tab:CreateDropdown({
            Name = title .. " Mode",

            Options = {
                "Toggle",
                "Hold",
                "Smart",
            },

            CurrentOption = {
                binding.Mode
            },

            Flag =
                "Axiom_"
                .. name
                .. "_Mode",

            Callback = function(option)
                local mode = option

                if type(option) == "table" then
                    mode = option[1]
                end

                KeybindSystem:SetMode(
                    name,
                    mode
                )
            end,
        })

    KeybindControls[name] = {
        Key = keyControl,
        Mode = modeControl,
    }

    return KeybindControls[name]
end

--========================================================--
-- PLAYER TAB
--========================================================--

local PlayerTab = Window:CreateTab("Player")

PlayerTab:CreateSection("Movement")

RegisterControl(
    "WalkSpeed",
    PlayerTab:CreateSlider({
        Name = "WalkSpeed",
        Range = {16, 250},
        Increment = 1,
        CurrentValue = Player.WalkSpeed,
        Flag = "Axiom_WalkSpeed",

        Callback = function(value)
            Player.WalkSpeed = value
            ApplyMovement()
        end,
    })
)

RegisterControl(
    "JumpPower",
    PlayerTab:CreateSlider({
        Name = "JumpPower",
        Range = {50, 250},
        Increment = 1,
        CurrentValue = Player.JumpPower,
        Flag = "Axiom_JumpPower",

        Callback = function(value)
            Player.JumpPower = value
            ApplyMovement()
        end,
    })
)

RegisterControl(
    "Gravity",
    PlayerTab:CreateSlider({
        Name = "Gravity",
        Range = {0, 300},
        Increment = 1,
        CurrentValue = Player.Gravity,
        Flag = "Axiom_Gravity",

        Callback = function(value)
            Player.Gravity = value
            ApplyGravity()
        end,
    })
)

RegisterControl(
    "CameraFOV",
    PlayerTab:CreateSlider({
        Name = "Camera FOV",
        Range = {40, 120},
        Increment = 1,
        CurrentValue = Player.CameraFOV,
        Flag = "Axiom_CameraFOV",

        Callback = function(value)
            Player.CameraFOV = value
            ApplyCameraFOV()
        end,
    })
)

RegisterControl(
    "InfiniteJump",
    PlayerTab:CreateToggle({
        Name = "Infinite Jump",
        CurrentValue = Player.InfiniteJump,
        Flag = "Axiom_InfiniteJump",

        Callback = function(value)
            Player.InfiniteJump = value == true
        end,
    })
)

RegisterControl(
    "Noclip",
    PlayerTab:CreateToggle({
        Name = "Noclip",
        CurrentValue = Player.Noclip,
        Flag = "Axiom_Noclip",

        Callback = function(value)
            Player.Noclip = value == true
            UpdateNoclip()
        end,
    })
)

PlayerTab:CreateSection("Fly")

RegisterControl(
    "Fly",
    PlayerTab:CreateToggle({
        Name = "Fly",
        CurrentValue = Player.FlyEnabled,
        Flag = "Axiom_Fly",

        Callback = function(value)
            Player.FlyEnabled = value == true

            if Player.FlyEnabled then
                StartFly()
            else
                StopFly(false)
            end
        end,
    })
)

RegisterControl(
    "FlySpeed",
    PlayerTab:CreateSlider({
        Name = "Fly Speed",
        Range = {10, 250},
        Increment = 1,
        CurrentValue = Player.FlySpeed,
        Flag = "Axiom_FlySpeed",

        Callback = function(value)
            Player.FlySpeed = value
        end,
    })
)

PlayerTab:CreateSection("Utilities")

RegisterControl(
    "AutoSprint",
    PlayerTab:CreateToggle({
        Name = "Auto Sprint",
        CurrentValue = Player.AutoSprint,
        Flag = "Axiom_AutoSprint",

        Callback = function(value)
            Player.AutoSprint = value == true
        end,
    })
)

RegisterControl(
    "Fullbright",
    PlayerTab:CreateToggle({
        Name = "Fullbright",
        CurrentValue = Player.Fullbright,
        Flag = "Axiom_Fullbright",

        Callback = function(value)
            Player.Fullbright = value == true

            if Player.Fullbright then
                ApplyFullbright()
            end
        end,
    })
)

RegisterControl(
    "AntiAFK",
    PlayerTab:CreateToggle({
        Name = "Anti AFK",
        CurrentValue = Player.AntiAFK,
        Flag = "Axiom_AntiAFK",

        Callback = function(value)
            Player.AntiAFK = value == true
        end,
    })
)

CreateKeybindControls(
    PlayerTab,
    "Fly",
    "Fly",
    Enum.KeyCode.F,
    "Toggle"
)

CreateKeybindControls(
    PlayerTab,
    "Noclip",
    "Noclip",
    Enum.KeyCode.N,
    "Toggle"
)

CreateKeybindControls(
    PlayerTab,
    "InfiniteJump",
    "Infinite Jump",
    Enum.KeyCode.J,
    "Toggle"
)

CreateKeybindControls(
    PlayerTab,
    "Fullbright",
    "Fullbright",
    Enum.KeyCode.B,
    "Toggle"
)

CreateKeybindControls(
    PlayerTab,
    "AntiAFK",
    "Anti AFK",
    Enum.KeyCode.P,
    "Toggle"
)

CreateKeybindControls(
    PlayerTab,
    "AutoSprint",
    "Auto Sprint",
    Enum.KeyCode.LeftShift,
    "Smart"
)

--========================================================--
-- ESP TAB
--========================================================--

local ESPTab = Window:CreateTab("ESP")

ESPTab:CreateSection("ESP")

RegisterControl(
    "ESPEnabled",
    ESPTab:CreateToggle({
        Name = "Player ESP",
        CurrentValue = ESP.Enabled,
        Flag = "Axiom_ESPEnabled",

        Callback = function(value)
            ESP.Enabled = value == true
            RefreshESP()
        end,
    })
)

RegisterControl(
    "NPCESP",
    ESPTab:CreateToggle({
        Name = "NPC ESP",
        CurrentValue = ESP.NPCEnabled,
        Flag = "Axiom_NPCESP",

        Callback = function(value)
            ESP.NPCEnabled = value == true
            RefreshESP()
        end,
    })
)

RegisterControl(
    "ESPNamed",
    ESPTab:CreateToggle({
        Name = "Names",
        CurrentValue = ESP.Names,
        Flag = "Axiom_ESPNamed",

        Callback = function(value)
            ESP.Names = value == true
        end,
    })
)

RegisterControl(
    "ESPDistance",
    ESPTab:CreateToggle({
        Name = "Distance",
        CurrentValue = ESP.Distance,
        Flag = "Axiom_ESPDistance",

        Callback = function(value)
            ESP.Distance = value == true
        end,
    })
)

RegisterControl(
    "ESPHealth",
    ESPTab:CreateToggle({
        Name = "Health",
        CurrentValue = ESP.Health,
        Flag = "Axiom_ESPHealth",

        Callback = function(value)
            ESP.Health = value == true
        end,
    })
)

RegisterControl(
    "ESPTracers",
    ESPTab:CreateToggle({
        Name = "Tracers",
        CurrentValue = ESP.Tracers,
        Flag = "Axiom_ESPTracers",

        Callback = function(value)
            ESP.Tracers = value == true
        end,
    })
)

ESPTab:CreateSection("Colors")

RegisterControl(
    "TeamColors",
    ESPTab:CreateToggle({
        Name = "Team Colors",
        CurrentValue = ESP.TeamColors,
        Flag = "Axiom_TeamColors",

        Callback = function(value)
            ESP.TeamColors = value == true
        end,
    })
)

RegisterControl(
    "Rainbow",
    ESPTab:CreateToggle({
        Name = "Rainbow",
        CurrentValue = ESP.Rainbow,
        Flag = "Axiom_Rainbow",

        Callback = function(value)
            ESP.Rainbow = value == true
        end,
    })
)

RegisterControl(
    "ESPPlayerColor",
    ESPTab:CreateColorPicker({
        Name = "Player Color",
        Color = ESP.PlayerColor,
        Flag = "Axiom_PlayerColor",

        Callback = function(value)
            ESP.PlayerColor = value
        end,
    })
)

RegisterControl(
    "ESPNPCColor",
    ESPTab:CreateColorPicker({
        Name = "NPC Color",
        Color = ESP.NPCColor,
        Flag = "Axiom_NPCColor",

        Callback = function(value)
            ESP.NPCColor = value
        end,
    })
)

ESPTab:CreateSection("Display")

RegisterControl(
    "ESPOutline",
    ESPTab:CreateToggle({
        Name = "Outline",
        CurrentValue = ESP.Outline,
        Flag = "Axiom_ESPOutline",

        Callback = function(value)
            ESP.Outline = value == true
            RefreshESP()
        end,
    })
)

RegisterControl(
    "ESPFill",
    ESPTab:CreateToggle({
        Name = "Fill",
        CurrentValue = ESP.Fill,
        Flag = "Axiom_ESPFill",

        Callback = function(value)
            ESP.Fill = value == true
            RefreshESP()
        end,
    })
)

RegisterControl(
    "ESPMaxDistance",
    ESPTab:CreateSlider({
        Name = "Max Distance",
        Range = {50, 5000},
        Increment = 50,
        CurrentValue = ESP.MaxDistance,
        Flag = "Axiom_ESPMaxDistance",

        Callback = function(value)
            ESP.MaxDistance = value
        end,
    })
)

--========================================================--
-- AIMBOT TAB
--========================================================--

local AimbotTab = Window:CreateTab("Aimbot")

AimbotTab:CreateSection("Aimbot")

RegisterControl(
    "AimbotEnabled",
    AimbotTab:CreateToggle({
        Name = "Enable",
        CurrentValue = Aimbot.Enabled,
        Flag = "Axiom_AimbotEnabled",

        Callback = function(value)
            Aimbot.Enabled = value == true

            if not Aimbot.Enabled then
                Aimbot.Target = nil
            end
        end,
    })
)

RegisterControl(
    "AimbotPlayers",
    AimbotTab:CreateToggle({
        Name = "Aim at Players",
        CurrentValue = Aimbot.AimAtPlayers,
        Flag = "Axiom_AimbotPlayers",

        Callback = function(value)
            Aimbot.AimAtPlayers = value == true
        end,
    })
)

RegisterControl(
    "AimbotNPCs",
    AimbotTab:CreateToggle({
        Name = "Aim at NPCs",
        CurrentValue = Aimbot.AimAtNPCs,
        Flag = "Axiom_AimbotNPCs",

        Callback = function(value)
            Aimbot.AimAtNPCs = value == true
        end,
    })
)

RegisterControl(
    "AimbotVisible",
    AimbotTab:CreateToggle({
        Name = "Only Visible",
        CurrentValue = Aimbot.OnlyVisible,
        Flag = "Axiom_AimbotVisible",

        Callback = function(value)
            Aimbot.OnlyVisible = value == true
        end,
    })
)

RegisterControl(
    "AimbotLock",
    AimbotTab:CreateToggle({
        Name = "Lock Target",
        CurrentValue = Aimbot.LockTarget,
        Flag = "Axiom_AimbotLock",

        Callback = function(value)
            Aimbot.LockTarget = value == true
        end,
    })
)

RegisterControl(
    "AimbotTeamCheck",
    AimbotTab:CreateToggle({
        Name = "Team Check",
        CurrentValue = Aimbot.TeamCheck,
        Flag = "Axiom_AimbotTeamCheck",

        Callback = function(value)
            Aimbot.TeamCheck = value == true
        end,
    })
)

RegisterControl(
    "AimbotIgnoreDead",
    AimbotTab:CreateToggle({
        Name = "Ignore Dead",
        CurrentValue = Aimbot.IgnoreDead,
        Flag = "Axiom_AimbotIgnoreDead",

        Callback = function(value)
            Aimbot.IgnoreDead = value == true
        end,
    })
)

RegisterControl(
    "AimbotFOV",
    AimbotTab:CreateSlider({
        Name = "FOV",
        Range = {10, 500},
        Increment = 5,
        CurrentValue = Aimbot.FOV,
        Flag = "Axiom_AimbotFOV",

        Callback = function(value)
            Aimbot.FOV = value
            UpdateFOV()
        end,
    })
)

RegisterControl(
    "AimbotMaxDistance",
    AimbotTab:CreateSlider({
        Name = "Max Distance",
        Range = {50, 5000},
        Increment = 50,
        CurrentValue = Aimbot.MaxDistance,
        Flag = "Axiom_AimbotMaxDistance",

        Callback = function(value)
            Aimbot.MaxDistance = value
        end,
    })
)

RegisterControl(
    "AimbotSmoothness",
    AimbotTab:CreateSlider({
        Name = "Smoothness",
        Range = {1, 50},
        Increment = 1,
        CurrentValue = Aimbot.Smoothness,
        Flag = "Axiom_AimbotSmoothness",

        Callback = function(value)
            Aimbot.Smoothness = value
        end,
    })
)

RegisterControl(
    "AimbotTargetPart",
    AimbotTab:CreateDropdown({
        Name = "Target Part",

        Options = {
            "Head",
            "HumanoidRootPart",
            "UpperTorso",
            "Torso",
        },

        CurrentOption = {
            Aimbot.TargetPart
        },

        Flag = "Axiom_AimbotTargetPart",

        Callback = function(option)
            if type(option) == "table" then
                option = option[1]
            end

            Aimbot.TargetPart = option
        end,
    })
)

AimbotTab:CreateSection("Prediction")

RegisterControl(
    "AimbotPrediction",
    AimbotTab:CreateToggle({
        Name = "Prediction",
        CurrentValue = Aimbot.Prediction,
        Flag = "Axiom_AimbotPrediction",

        Callback = function(value)
            Aimbot.Prediction = value == true
        end,
    })
)

RegisterControl(
    "AimbotPredictionStrength",
    AimbotTab:CreateSlider({
        Name = "Prediction Strength",
        Range = {0, 1},
        Increment = 0.01,
        CurrentValue =
            Aimbot.PredictionStrength,
        Flag =
            "Axiom_AimbotPredictionStrength",

        Callback = function(value)
            Aimbot.PredictionStrength = value
        end,
    })
)

AimbotTab:CreateSection("FOV")

RegisterControl(
    "AimbotShowFOV",
    AimbotTab:CreateToggle({
        Name = "Show FOV",
        CurrentValue = Aimbot.ShowFOV,
        Flag = "Axiom_AimbotShowFOV",

        Callback = function(value)
            Aimbot.ShowFOV = value == true
            UpdateFOV()
        end,
    })
)

RegisterControl(
    "AimbotFOVColor",
    AimbotTab:CreateColorPicker({
        Name = "FOV Color",
        Color = Aimbot.FOVColor,
        Flag = "Axiom_AimbotFOVColor",

        Callback = function(value)
            Aimbot.FOVColor = value
            UpdateFOV()
        end,
    })
)

CreateKeybindControls(
    AimbotTab,
    "Aimbot",
    "Aimbot",
    Enum.UserInputType.MouseButton2,
    "Hold"
)

--========================================================--
-- UTILITIES TAB
--========================================================--

local UtilitiesTab =
    Window:CreateTab("Utilities")

UtilitiesTab:CreateSection("Server")

UtilitiesTab:CreateButton({
    Name = "Rejoin Server",

    Callback = function()
        TeleportService:Teleport(
            game.PlaceId,
            LocalPlayer
        )
    end,
})

UtilitiesTab:CreateButton({
    Name = "Server Hop",

    Callback = function()
        TeleportService:Teleport(
            game.PlaceId,
            LocalPlayer
        )
    end,
})

UtilitiesTab:CreateButton({
    Name = "Reset Character",

    Callback = function()
        if Humanoid then
            Humanoid.Health = 0
        end
    end,
})

UtilitiesTab:CreateSection("Copy")

UtilitiesTab:CreateButton({
    Name = "Copy Job ID",

    Callback = function()
        if setclipboard then
            setclipboard(game.JobId)
        end
    end,
})

UtilitiesTab:CreateButton({
    Name = "Copy Place ID",

    Callback = function()
        if setclipboard then
            setclipboard(
                tostring(game.PlaceId)
            )
        end
    end,
})

UtilitiesTab:CreateButton({
    Name = "Copy User ID",

    Callback = function()
        if setclipboard then
            setclipboard(
                tostring(LocalPlayer.UserId)
            )
        end
    end,
})

--========================================================--
-- DEVELOPER TAB
--========================================================--

local DeveloperTab =
    Window:CreateTab("Developer")

DeveloperTab:CreateSection("Player Debug")

DeveloperTab:CreateButton({
    Name = "Copy Position",

    Callback = function()
        if setclipboard and RootPart then
            setclipboard(
                tostring(
                    RootPart.Position
                )
            )
        end
    end,
})

DeveloperTab:CreateButton({
    Name = "Copy Velocity",

    Callback = function()
        if setclipboard and RootPart then
            setclipboard(
                tostring(
                    RootPart.AssemblyLinearVelocity
                )
            )
        end
    end,
})

DeveloperTab:CreateButton({
    Name = "Copy User Info",

    Callback = function()
        if not setclipboard then
            return
        end

        setclipboard(
            string.format(
                "Username: %s\nDisplayName: %s\nUserId: %d",
                LocalPlayer.Name,
                LocalPlayer.DisplayName,
                LocalPlayer.UserId
            )
        )
    end,
})

DeveloperTab:CreateButton({
    Name = "Inspect Character",

    Callback = function()
        if not Character then
            return
        end

        for _, object in ipairs(
            Character:GetDescendants()
        ) do
            print(
                object:GetFullName(),
                object.ClassName
            )
        end
    end,
})

DeveloperTab:CreateButton({
    Name = "Inspect Humanoid",

    Callback = function()
        if not Humanoid then
            return
        end

        print(
            "Health:",
            Humanoid.Health
        )

        print(
            "MaxHealth:",
            Humanoid.MaxHealth
        )

        print(
            "WalkSpeed:",
            Humanoid.WalkSpeed
        )

        print(
            "JumpPower:",
            Humanoid.JumpPower
        )

        print(
            "HipHeight:",
            Humanoid.HipHeight
        )

        print(
            "State:",
            Humanoid:GetState().Name
        )
    end,
})

--========================================================--
-- OBJECT SELECTOR
--========================================================--

DeveloperTab:CreateSection(
    "Object Selector"
)

local ObjectSelectorEnabled = false
local ObjectHoverHighlight = nil
local ObjectHoverTarget = nil
local SelectedObject = nil
local ObjectPathInput = nil

local function DestroyObjectHoverHighlight()
    if ObjectHoverHighlight then
        ObjectHoverHighlight:Destroy()
        ObjectHoverHighlight = nil
    end

    ObjectHoverTarget = nil
end

local function GetObjectPath(object)
    if not object then
        return ""
    end

    return object:GetFullName()
end

local function HighlightObject(object)
    if not object then
        DestroyObjectHoverHighlight()
        return
    end

    if ObjectHoverTarget == object
        and ObjectHoverHighlight then
        return
    end

    DestroyObjectHoverHighlight()

    ObjectHoverTarget = object

    ObjectHoverHighlight =
        Instance.new("Highlight")

    ObjectHoverHighlight.Name =
        "AxiomObjectHover"

    ObjectHoverHighlight.DepthMode =
        Enum.HighlightDepthMode.AlwaysOnTop

    if object:IsA("Model") then
        ObjectHoverHighlight.Adornee = object

    elseif object:IsA("BasePart") then
        ObjectHoverHighlight.Adornee = object

    else
        -- For objects that cannot be directly
        -- highlighted, highlight their nearest
        -- model/basepart parent.
        local model =
            object:FindFirstAncestorOfClass(
                "Model"
            )

        local part

        if model then
            ObjectHoverHighlight.Adornee =
                model
        elseif object:IsA("BasePart") then
            ObjectHoverHighlight.Adornee =
                object
        else
            part =
                object:FindFirstAncestorWhichIsA(
                    "BasePart"
                )

            if part then
                ObjectHoverHighlight.Adornee =
                    part
            else
                DestroyObjectHoverHighlight()
                return
            end
        end
    end

    ObjectHoverHighlight.Parent = Workspace
end

local function SetSelectedObject(object)
    if not object then
        return
    end

    SelectedObject = object

    local path =
        GetObjectPath(object)

    if ObjectPathInput then
        SetControlValue(
            ObjectPathInput,
            path
        )
    end

    DestroyObjectHoverHighlight()

    ObjectSelectorEnabled = false
end

local function GetObjectUnderMouse()
    local camera = GetCamera()

    if not camera then
        return nil
    end

    local mousePosition =
        UserInputService:GetMouseLocation()

    local inset =
        GuiService:GetGuiInset()

    local viewportPosition =
        Vector2.new(
            mousePosition.X - inset.X,
            mousePosition.Y - inset.Y
        )

    local ray =
        camera:ViewportPointToRay(
            viewportPosition.X,
            viewportPosition.Y
        )

    local params =
        RaycastParams.new()

    params.FilterType =
        Enum.RaycastFilterType.Exclude

    params.FilterDescendantsInstances = {
        Character
    }

    params.IgnoreWater = true

    local result =
        Workspace:Raycast(
            ray.Origin,
            ray.Direction * 10000,
            params
        )

    if not result then
        return nil
    end

    return result.Instance
end

ObjectPathInput =
    DeveloperTab:CreateInput({
        Name = "Object Path",
        PlaceholderText =
            "Selected object path...",
        RemoveTextAfterFocusLost = false,
        Flag = "Axiom_ObjectPath",

        Callback = function(value)
            -- Input intentionally allows manual
            -- path editing.
        end,
    })

DeveloperTab:CreateButton({
    Name = "Select Object",

    Callback = function()
        ObjectSelectorEnabled =
            not ObjectSelectorEnabled

        if not ObjectSelectorEnabled then
            DestroyObjectHoverHighlight()
        end
    end,
})

DeveloperTab:CreateButton({
    Name = "Clear Selected Object",

    Callback = function()
        SelectedObject = nil

        if ObjectPathInput then
            SetControlValue(
                ObjectPathInput,
                ""
            )
        end

        DestroyObjectHoverHighlight()
    end,
})

DeveloperTab:CreateButton({
    Name = "Copy Object Path",

    Callback = function()
        if setclipboard
            and SelectedObject then

            setclipboard(
                GetObjectPath(
                    SelectedObject
                )
            )
        end
    end,
})

DeveloperTab:CreateButton({
    Name = "Copy Object Name",

    Callback = function()
        if setclipboard
            and SelectedObject then

            setclipboard(
                SelectedObject.Name
            )
        end
    end,
})

DeveloperTab:CreateButton({
    Name = "Copy Object Class",

    Callback = function()
        if setclipboard
            and SelectedObject then

            setclipboard(
                SelectedObject.ClassName
            )
        end
    end,
})

DeveloperTab:CreateButton({
    Name = "Inspect Selected Object",

    Callback = function()
        if not SelectedObject then
            return
        end

        print(
            "Name:",
            SelectedObject.Name
        )

        print(
            "Class:",
            SelectedObject.ClassName
        )

        print(
            "Path:",
            SelectedObject:GetFullName()
        )

        print(
            "Parent:",
            SelectedObject.Parent
        )
    end,
})

-- Hover / click selector.
RunService.RenderStepped:Connect(function()
    if not ObjectSelectorEnabled then
        if ObjectHoverHighlight then
            DestroyObjectHoverHighlight()
        end

        return
    end

    local target =
        GetObjectUnderMouse()

    HighlightObject(target)
end)

UserInputService.InputBegan:Connect(function(
    input,
    processed
)
    if processed then
        return
    end

    if not ObjectSelectorEnabled then
        return
    end

    if input.UserInputType ==
        Enum.UserInputType.MouseButton1 then

        local target =
            GetObjectUnderMouse()

        if target then
            SetSelectedObject(target)
        end

    elseif input.KeyCode ==
        Enum.KeyCode.Escape then

        ObjectSelectorEnabled = false

        DestroyObjectHoverHighlight()
    end
end)

--========================================================--
-- CONFIG SYSTEM
--========================================================--

local CONFIG_FOLDER = "Axiom"
local CONFIG_FILE =
    CONFIG_FOLDER .. "/AxiomConfig.json"

local function CanUseFileSystem()
    return type(isfolder) == "function"
        and type(makefolder) == "function"
        and type(isfile) == "function"
        and type(readfile) == "function"
        and type(writefile) == "function"
end

local function ColorToTable(color)
    return {
        R = color.R,
        G = color.G,
        B = color.B,
    }
end

local function TableToColor(
    value,
    fallback
)
    if type(value) ~= "table" then
        return fallback
    end

    local r = tonumber(value.R)
    local g = tonumber(value.G)
    local b = tonumber(value.B)

    if not r or not g or not b then
        return fallback
    end

    return Color3.new(r, g, b)
end

local function BuildConfig()
    local bindings = {}

    for name, binding in pairs(
        KeybindSystem.Bindings
    ) do
        bindings[name] = {
            Key = KeyToString(binding.Key),
            Mode = binding.Mode,
        }
    end

    return {
        Version = "1.62.12",

        Player = {
            WalkSpeed = Player.WalkSpeed,
            JumpPower = Player.JumpPower,
            InfiniteJump =
                Player.InfiniteJump,
            Gravity = Player.Gravity,
            CameraFOV =
                Player.CameraFOV,

            FlyEnabled =
                Player.FlyEnabled,

            FlySpeed =
                Player.FlySpeed,

            Noclip =
                Player.Noclip,

            AutoSprint =
                Player.AutoSprint,

            Fullbright =
                Player.Fullbright,

            AntiAFK =
                Player.AntiAFK,
        },

        ESP = {
            Enabled = ESP.Enabled,
            NPCEnabled =
                ESP.NPCEnabled,

            Names = ESP.Names,
            Distance =
                ESP.Distance,

            Health = ESP.Health,
            Tracers =
                ESP.Tracers,

            TeamColors =
                ESP.TeamColors,

            Rainbow =
                ESP.Rainbow,

            Outline =
                ESP.Outline,

            Fill =
                ESP.Fill,

            OutlineTransparency =
                ESP.OutlineTransparency,

            FillTransparency =
                ESP.FillTransparency,

            MaxDistance =
                ESP.MaxDistance,

            PlayerColor =
                ColorToTable(
                    ESP.PlayerColor
                ),

            NPCColor =
                ColorToTable(
                    ESP.NPCColor
                ),
        },

        Aimbot = {
            Enabled =
                Aimbot.Enabled,

            UseAimKey =
                Aimbot.UseAimKey,

            AimAtPlayers =
                Aimbot.AimAtPlayers,

            AimAtNPCs =
                Aimbot.AimAtNPCs,

            OnlyVisible =
                Aimbot.OnlyVisible,

            TargetPart =
                Aimbot.TargetPart,

            LockTarget =
                Aimbot.LockTarget,

            TeamCheck =
                Aimbot.TeamCheck,

            IgnoreDead =
                Aimbot.IgnoreDead,

            FOV =
                Aimbot.FOV,

            MaxDistance =
                Aimbot.MaxDistance,

            Smoothness =
                Aimbot.Smoothness,

            Prediction =
                Aimbot.Prediction,

            PredictionStrength =
                Aimbot.PredictionStrength,

            ShowFOV =
                Aimbot.ShowFOV,

            FOVColor =
                ColorToTable(
                    Aimbot.FOVColor
                ),
        },

        Keybinds = bindings,
    }
end

local function EncodeConfig(config)
    return HttpService:JSONEncode(
        config
    )
end

local function DecodeConfig(text)
    local success, result =
        pcall(
            HttpService.JSONDecode,
            HttpService,
            text
        )

    if success
        and type(result) == "table" then

        return result
    end

    return nil
end

local function ApplyConfig(config)
    if type(config) ~= "table" then
        return false
    end

    local p = config.Player

    if type(p) == "table" then
        if p.WalkSpeed ~= nil then
            Player.WalkSpeed =
                tonumber(p.WalkSpeed)
                or Player.WalkSpeed
        end

        if p.JumpPower ~= nil then
            Player.JumpPower =
                tonumber(p.JumpPower)
                or Player.JumpPower
        end

        if p.InfiniteJump ~= nil then
            Player.InfiniteJump =
                p.InfiniteJump == true
        end

        if p.Gravity ~= nil then
            Player.Gravity =
                tonumber(p.Gravity)
                or Player.Gravity
        end

        if p.CameraFOV ~= nil then
            Player.CameraFOV =
                tonumber(p.CameraFOV)
                or Player.CameraFOV
        end

        if p.FlyEnabled ~= nil then
            Player.FlyEnabled =
                p.FlyEnabled == true
        end

        if p.FlySpeed ~= nil then
            Player.FlySpeed =
                tonumber(p.FlySpeed)
                or Player.FlySpeed
        end

        if p.Noclip ~= nil then
            Player.Noclip =
                p.Noclip == true
        end

        if p.AutoSprint ~= nil then
            Player.AutoSprint =
                p.AutoSprint == true
        end

        if p.Fullbright ~= nil then
            Player.Fullbright =
                p.Fullbright == true
        end

        if p.AntiAFK ~= nil then
            Player.AntiAFK =
                p.AntiAFK == true
        end
    end

    local e = config.ESP

    if type(e) == "table" then
        ESP.Enabled =
            e.Enabled == true

        ESP.NPCEnabled =
            e.NPCEnabled == true

        ESP.Names =
            e.Names ~= false

        ESP.Distance =
            e.Distance ~= false

        ESP.Health =
            e.Health ~= false

        ESP.Tracers =
            e.Tracers == true

        ESP.TeamColors =
            e.TeamColors ~= false

        ESP.Rainbow =
            e.Rainbow == true

        ESP.Outline =
            e.Outline ~= false

        ESP.Fill =
            e.Fill == true

        ESP.OutlineTransparency =
            tonumber(
                e.OutlineTransparency
            )
            or ESP.OutlineTransparency

        ESP.FillTransparency =
            tonumber(
                e.FillTransparency
            )
            or ESP.FillTransparency

        ESP.MaxDistance =
            tonumber(
                e.MaxDistance
            )
            or ESP.MaxDistance

        ESP.PlayerColor =
            TableToColor(
                e.PlayerColor,
                ESP.PlayerColor
            )

        ESP.NPCColor =
            TableToColor(
                e.NPCColor,
                ESP.NPCColor
            )
    end

    local a = config.Aimbot

    if type(a) == "table" then
        Aimbot.Enabled =
            a.Enabled == true

        Aimbot.UseAimKey =
            a.UseAimKey ~= false

        Aimbot.AimAtPlayers =
            a.AimAtPlayers ~= false

        Aimbot.AimAtNPCs =
            a.AimAtNPCs == true

        Aimbot.OnlyVisible =
            a.OnlyVisible ~= false

        if type(a.TargetPart) ==
            "string" then

            Aimbot.TargetPart =
                a.TargetPart
        end

        Aimbot.LockTarget =
            a.LockTarget == true

        Aimbot.TeamCheck =
            a.TeamCheck == true

        Aimbot.IgnoreDead =
            a.IgnoreDead ~= false

        Aimbot.FOV =
            tonumber(a.FOV)
            or Aimbot.FOV

        Aimbot.MaxDistance =
            tonumber(a.MaxDistance)
            or Aimbot.MaxDistance

        Aimbot.Smoothness =
            tonumber(a.Smoothness)
            or Aimbot.Smoothness

        Aimbot.Prediction =
            a.Prediction == true

        Aimbot.PredictionStrength =
            tonumber(
                a.PredictionStrength
            )
            or Aimbot.PredictionStrength

        Aimbot.ShowFOV =
            a.ShowFOV == true

        Aimbot.FOVColor =
            TableToColor(
                a.FOVColor,
                Aimbot.FOVColor
            )
    end

    local bindings = config.Keybinds

    if type(bindings) == "table" then
        for name, data in pairs(
            bindings
        ) do
            if KeybindSystem.Bindings[name]
                and type(data) == "table" then

                if data.Key ~= nil then
                    KeybindSystem:SetKey(
                        name,
                        data.Key
                    )
                end

                if data.Mode ~= nil then
                    KeybindSystem:SetMode(
                        name,
                        data.Mode
                    )
                end
            end
        end
    end

    ApplyMovement()
    ApplyGravity()
    ApplyCameraFOV()
    ApplyFullbright()

    if Player.Noclip then
        UpdateNoclip()
    end

    if Player.FlyEnabled then
        StartFly()
    else
        StopFly(false)
    end

    SetControlValue(
        Controls.WalkSpeed,
        Player.WalkSpeed
    )

    SetControlValue(
        Controls.JumpPower,
        Player.JumpPower
    )

    SetControlValue(
        Controls.Gravity,
        Player.Gravity
    )

    SetControlValue(
        Controls.CameraFOV,
        Player.CameraFOV
    )

    SetControlValue(
        Controls.InfiniteJump,
        Player.InfiniteJump
    )

    SetControlValue(
        Controls.Noclip,
        Player.Noclip
    )

    SetControlValue(
        Controls.Fly,
        Player.FlyEnabled
    )

    SetControlValue(
        Controls.FlySpeed,
        Player.FlySpeed
    )

    SetControlValue(
        Controls.AutoSprint,
        Player.AutoSprint
    )

    SetControlValue(
        Controls.Fullbright,
        Player.Fullbright
    )

    SetControlValue(
        Controls.AntiAFK,
        Player.AntiAFK
    )

    SetControlValue(
        Controls.ESPEnabled,
        ESP.Enabled
    )

    SetControlValue(
        Controls.NPCESP,
        ESP.NPCEnabled
    )

    SetControlValue(
        Controls.ESPNamed,
        ESP.Names
    )

    SetControlValue(
        Controls.ESPDistance,
        ESP.Distance
    )

    SetControlValue(
        Controls.ESPHealth,
        ESP.Health
    )

    SetControlValue(
        Controls.ESPTracers,
        ESP.Tracers
    )

    SetControlValue(
        Controls.TeamColors,
        ESP.TeamColors
    )

    SetControlValue(
        Controls.Rainbow,
        ESP.Rainbow
    )

    SetControlValue(
        Controls.ESPOutline,
        ESP.Outline
    )

    SetControlValue(
        Controls.ESPFill,
        ESP.Fill
    )

    SetControlValue(
        Controls.ESPMaxDistance,
        ESP.MaxDistance
    )

    SetControlValue(
        Controls.AimbotEnabled,
        Aimbot.Enabled
    )

    SetControlValue(
        Controls.AimbotPlayers,
        Aimbot.AimAtPlayers
    )

    SetControlValue(
        Controls.AimbotNPCs,
        Aimbot.AimAtNPCs
    )

    SetControlValue(
        Controls.AimbotVisible,
        Aimbot.OnlyVisible
    )

    SetControlValue(
        Controls.AimbotLock,
        Aimbot.LockTarget
    )

    SetControlValue(
        Controls.AimbotTeamCheck,
        Aimbot.TeamCheck
    )

    SetControlValue(
        Controls.AimbotIgnoreDead,
        Aimbot.IgnoreDead
    )

    SetControlValue(
        Controls.AimbotFOV,
        Aimbot.FOV
    )

    SetControlValue(
        Controls.AimbotMaxDistance,
        Aimbot.MaxDistance
    )

    SetControlValue(
        Controls.AimbotSmoothness,
        Aimbot.Smoothness
    )

    SetControlValue(
        Controls.AimbotPrediction,
        Aimbot.Prediction
    )

    SetControlValue(
        Controls.AimbotPredictionStrength,
        Aimbot.PredictionStrength
    )

    SetControlValue(
        Controls.AimbotShowFOV,
        Aimbot.ShowFOV
    )

    UpdateFOV()

    RefreshESP()

    return true
end

local function SaveConfig()
    if not CanUseFileSystem() then
        return false
    end

    pcall(function()
        if not isfolder(
            CONFIG_FOLDER
        ) then
            makefolder(
                CONFIG_FOLDER
            )
        end
    end)

    return pcall(function()
        writefile(
            CONFIG_FILE,
            EncodeConfig(
                BuildConfig()
            )
        )
    end)
end

local function LoadConfig()
    if not CanUseFileSystem() then
        return false
    end

    if not isfile(CONFIG_FILE) then
        return false
    end

    local success, text =
        pcall(readfile, CONFIG_FILE)

    if not success
        or type(text) ~= "string" then
        return false
    end

    local config =
        DecodeConfig(text)

    if not config then
        return false
    end

    return ApplyConfig(config)
end

local function ResetConfig()
    local defaults = {
        Player = {
            WalkSpeed = 16,
            JumpPower = 50,
            InfiniteJump = false,
            Gravity = 196.2,
            CameraFOV = 70,
            FlyEnabled = false,
            FlySpeed = 75,
            Noclip = false,
            AutoSprint = false,
            Fullbright = false,
            AntiAFK = false,
        },

        ESP = {
            Enabled = false,
            NPCEnabled = false,
            Names = true,
            Distance = true,
            Health = true,
            Tracers = false,
            TeamColors = true,
            Rainbow = false,
            Outline = true,
            Fill = false,
            MaxDistance = 1000,

            PlayerColor =
                ColorToTable(
                    Color3.fromRGB(
                        255,
                        255,
                        255
                    )
                ),

            NPCColor =
                ColorToTable(
                    Color3.fromRGB(
                        255,
                        170,
                        0
                    )
                ),
        },

        Aimbot = {
            Enabled = false,
            UseAimKey = true,
            AimAtPlayers = true,
            AimAtNPCs = false,
            OnlyVisible = true,
            TargetPart = "Head",
            LockTarget = false,
            TeamCheck = false,
            IgnoreDead = true,
            FOV = 150,
            MaxDistance = 500,
            Smoothness = 15,
            Prediction = false,
            PredictionStrength = 0.1,
            ShowFOV = false,

            FOVColor =
                ColorToTable(
                    Color3.fromRGB(
                        255,
                        255,
                        255
                    )
                ),
        },

        Keybinds = {
            Fly = {
                Key = "F",
                Mode = "Toggle",
            },

            Noclip = {
                Key = "N",
                Mode = "Toggle",
            },

            InfiniteJump = {
                Key = "J",
                Mode = "Toggle",
            },

            Fullbright = {
                Key = "B",
                Mode = "Toggle",
            },

            AntiAFK = {
                Key = "P",
                Mode = "Toggle",
            },

            AutoSprint = {
                Key = "LeftShift",
                Mode = "Smart",
            },

            Aimbot = {
                Key = "RMB",
                Mode = "Hold",
            },
        },
    }

    return ApplyConfig(defaults)
end

DeveloperTab:CreateSection(
    "Configuration"
)

DeveloperTab:CreateButton({
    Name = "Copy Current Config",

    Callback = function()
        if setclipboard then
            setclipboard(
                EncodeConfig(
                    BuildConfig()
                )
            )
        end
    end,
})

DeveloperTab:CreateButton({
    Name = "Save Current Config",

    Callback = function()
        SaveConfig()
    end,
})

DeveloperTab:CreateButton({
    Name = "Load Saved Config",

    Callback = function()
        LoadConfig()
    end,
})

local ConfigInput =
    DeveloperTab:CreateInput({
        Name = "Paste Config",

        PlaceholderText =
            "Paste JSON config here...",

        RemoveTextAfterFocusLost =
            false,

        Flag =
            "Axiom_PasteConfig",

        Callback = function(value)
        end,
    })

DeveloperTab:CreateButton({
    Name = "Load Pasted Config",

    Callback = function()
        local text

        pcall(function()
            if ConfigInput.CurrentValue then
                text =
                    ConfigInput.CurrentValue
            end
        end)

        if type(text) ~= "string"
            or text == "" then
            return
        end

        local config =
            DecodeConfig(text)

        if config then
            ApplyConfig(config)
        end
    end,
})

DeveloperTab:CreateButton({
    Name = "Copy Config Template",

    Callback = function()
        if setclipboard then
            setclipboard(
                EncodeConfig(
                    BuildConfig()
                )
            )
        end
    end,
})

DeveloperTab:CreateButton({
    Name = "Reset Config",

    Callback = function()
        ResetConfig()
    end,
})

--========================================================--
-- STATS
--========================================================--

local StatsLabel

pcall(function()
    StatsLabel =
        UtilitiesTab:CreateLabel(
            "FPS: -- | Ping: -- | Players: --"
        )
end)

local FPS = 0
local FPSFrames = 0
local FPSTime = os.clock()

--========================================================--
-- ANTI AFK
--========================================================--

LocalPlayer.Idled:Connect(function()
    if not Player.AntiAFK then
        return
    end

    pcall(function()
        local camera = GetCamera()

        if not camera then
            return
        end

        VirtualUser:Button2Down(
            Vector2.new(0, 0),
            camera.CFrame
        )

        task.wait(0.1)

        VirtualUser:Button2Up(
            Vector2.new(0, 0),
            camera.CFrame
        )
    end)
end)

--========================================================--
-- MAIN LOOP
--========================================================--

RunService.RenderStepped:Connect(function()
    FPSFrames += 1

    local now = os.clock()

    if now - FPSTime >= 1 then
        FPS = FPSFrames
        FPSFrames = 0
        FPSTime = now
    end

    local flyBinding =
        KeybindSystem.Bindings.Fly

    if flyBinding then
        if flyBinding.Active
            ~= Player.FlyEnabled then

            Player.FlyEnabled =
                flyBinding.Active

            if Player.FlyEnabled then
                StartFly()
            else
                StopFly(false)
            end
        end
    end

    local noclipBinding =
        KeybindSystem.Bindings.Noclip

    if noclipBinding then
        Player.Noclip =
            noclipBinding.Active
    end

    local jumpBinding =
        KeybindSystem.Bindings.InfiniteJump

    if jumpBinding then
        Player.InfiniteJump =
            jumpBinding.Active
    end

    local brightBinding =
        KeybindSystem.Bindings.Fullbright

    if brightBinding then
        Player.Fullbright =
            brightBinding.Active
    end

    local afkBinding =
        KeybindSystem.Bindings.AntiAFK

    if afkBinding then
        Player.AntiAFK =
            afkBinding.Active
    end

    if Player.AutoSprint and Humanoid then
        Humanoid.WalkSpeed =
            Player.WalkSpeed

        if KeybindSystem:IsActive(
            "AutoSprint"
        ) then

            pcall(function()
                Humanoid.WalkSpeed =
                    math.max(
                        Player.WalkSpeed,
                        16
                    )
            end)
        end
    end

    ApplyCameraFOV()

    if Player.Fullbright then
        ApplyFullbright()
    end

    if Player.Noclip then
        UpdateNoclip()
    end

    UpdateFly()

    RebuildTargetDatabase()

    UpdateFOV()

    if Aimbot.Enabled then
        local active = true

        if Aimbot.UseAimKey then
            active =
                KeybindSystem:IsActive(
                    "Aimbot"
                )
        end

        if active then
            if Aimbot.LockTarget
                and Aimbot.Target then

                local target =
                    Aimbot.Target

                if target.Model
                    and target.Model.Parent
                    and target.Part
                    and target.Part.Parent then

                    AimAtTarget(target)
                else
                    Aimbot.Target = nil
                end
            end

            if not Aimbot.Target then
                Aimbot.Target =
                    GetBestAimbotTarget()
            end

            if Aimbot.Target then
                AimAtTarget(
                    Aimbot.Target
                )
            end
        else
            if not Aimbot.LockTarget then
                Aimbot.Target = nil
            end
        end
    else
        Aimbot.Target = nil
    end

    RefreshESP()
    UpdateESP()

    if StatsLabel then
        local ping = "--"

        pcall(function()
            ping = math.floor(
                LocalPlayer:GetNetworkPing()
                * 1000
            )
        end)

        pcall(function()
            StatsLabel:Set(
                string.format(
                    "FPS: %d | Ping: %sms | Players: %d",
                    FPS,
                    tostring(ping),
                    #Players:GetPlayers()
                )
            )
        end)
    end
end)

--========================================================--
-- INITIALIZATION
--========================================================--

ApplyMovement()
ApplyGravity()
ApplyCameraFOV()
UpdateFOV()
RefreshESP()

task.delay(1, function()
    LoadConfig()

    task.wait(0.2)

    ApplyMovement()
    ApplyGravity()
    ApplyCameraFOV()
    UpdateFOV()
    RefreshESP()
end)

print(
    "[Axiom Player Tools] v1.62.12 BETA 12 loaded."
)

print(
    "[Axiom] Silent Aim removed."
)

print(
    "[Axiom] Object Selector ready."
)