--// Axiom Player Tools
--// Version: 1.62.10
--// Status: BETA 10
--// Player + ESP + Aimbot + Utilities + Developer
--// Rayfield Gen2
--// Keybind System: Toggle / Hold / Smart
--// Mouse Keys: LMB / RMB
--// Object Picker
--// Shared Target Database
--// 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 LocalPlayer = Players.LocalPlayer

----------------------------------------------------------------
--// RAYFIELD
----------------------------------------------------------------

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

local Window = Rayfield:CreateWindow({
    name = "Axiom",
    subtitle = "Player Tools",

    ConfigurationSaving = {
        Enabled = true,
        FolderName = "Axiom",
        FileName = "AxiomConfig",
    },
})

----------------------------------------------------------------
--// TABS
----------------------------------------------------------------

local PlayerTab = Window:CreateTab({
    name = "Player",
})

local ESPTab = Window:CreateTab({
    name = "ESP",
})

local AimbotTab = Window:CreateTab({
    name = "Aimbot",
})

local UtilitiesTab = Window:CreateTab({
    name = "Utilities",
})

local DeveloperTab = Window:CreateTab({
    name = "Developer",
})

----------------------------------------------------------------
--// KEYBIND SYSTEM
----------------------------------------------------------------

local KeybindSystem = {
    Bindings = {},
    InputState = {},

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

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

local function NormalizeKey(key)
    if not key then
        return nil
    end

    if typeof(key) == "EnumItem" then
        return key
    end

    if type(key) ~= "string" then
        return nil
    end

    local upper = string.upper(key)

    if KeybindSystem.MouseNames[upper] then
        return KeybindSystem.MouseNames[upper]
    end

    local keyCode = Enum.KeyCode[key]

    if keyCode then
        return keyCode
    end

    keyCode = Enum.KeyCode[upper]

    if keyCode then
        return keyCode
    end

    return nil
end

local function IsMouseKey(key)
    return key == Enum.UserInputType.MouseButton1
        or key == Enum.UserInputType.MouseButton2
end

local function IsInputMatch(input, key)
    local normalized = NormalizeKey(key)

    if not normalized then
        return false
    end

    if IsMouseKey(normalized) then
        return input.UserInputType == normalized
    end

    return input.KeyCode == normalized
end

function KeybindSystem:Register(name, config)
    config = config or {}

    local binding = {
        Name = name,

        Key = NormalizeKey(
            config.Key
                or config.DefaultKey
        ),

        Mode = config.Mode or "Toggle",

        SmartType =
            config.SmartType
            or "Toggle",

        Toggled = false,
        Held = false,

        OnChanged =
            config.OnChanged,

        Enabled =
            config.Enabled ~= false,
    }

    KeybindSystem.Bindings[name] = binding

    return binding
end

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

    if not binding then
        return
    end

    binding.Key =
        NormalizeKey(key)

    binding.Held = false
end

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

    if not binding then
        return
    end

    if not table.find(
        KeybindSystem.Modes,
        mode
    ) then
        return
    end

    binding.Mode = mode
    binding.Toggled = false
    binding.Held = false

    if binding.OnChanged then
        binding.OnChanged(
            false,
            binding
        )
    end
end

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

    if not binding then
        return "Toggle"
    end

    return binding.Mode
end

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

    if not binding
        or not binding.Enabled then
        return false
    end

    if binding.Mode == "Toggle" then
        return binding.Toggled
    end

    if binding.Mode == "Hold" then
        return binding.Held
    end

    if binding.SmartType == "Hold" then
        return binding.Held
    end

    return binding.Toggled
end

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

    if not binding
        or not binding.Enabled then
        return
    end

    --// Prevent repeated InputBegan events
    --// from toggling multiple times.
    if binding.Held then
        return
    end

    binding.Held = true

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

    elseif binding.Mode == "Smart" then
        if binding.SmartType == "Toggle" then
            binding.Toggled =
                not binding.Toggled
        end
    end

    if binding.OnChanged then
        binding.OnChanged(
            self:IsActive(name),
            binding
        )
    end
end

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

    if not binding then
        return
    end

    if not binding.Held then
        return
    end

    binding.Held = false

    if binding.OnChanged then
        binding.OnChanged(
            self:IsActive(name),
            binding
        )
    end
end

local function SyncBindingState(name, value)
    local binding =
        KeybindSystem.Bindings[name]

    if not binding then
        return
    end

    binding.Toggled = value
end

----------------------------------------------------------------
--// KEYBIND INPUT HANDLER
----------------------------------------------------------------

UserInputService.InputBegan:Connect(
    function(input, processed)
        for name, binding in pairs(
            KeybindSystem.Bindings
        ) do
            if binding.Key
                and IsInputMatch(
                    input,
                    binding.Key
                ) then

                --// Keyboard input should not fire
                --// while typing into GUI elements.
                if processed
                    and not IsMouseKey(
                        binding.Key
                    ) then
                    continue
                end

                KeybindSystem:TriggerDown(name)
            end
        end
    end
)

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

                KeybindSystem:TriggerUp(name)
            end
        end
    end
)

----------------------------------------------------------------
--// KEYBIND UI HELPER
----------------------------------------------------------------

local function CreateKeybindControls(
    tab,
    bindingName,
    displayName,
    defaultKey,
    defaultMode,
    smartType,
    callback
)
    local binding =
        KeybindSystem:Register(
            bindingName,
            {
                DefaultKey = defaultKey,
                Mode = defaultMode,
                SmartType = smartType,
                OnChanged = callback,
            }
        )

    tab:CreateKeybind({
        name = displayName .. " Key",
        currentKeybind = defaultKey,
        holdToInteract = false,

        callback = function(key)
            KeybindSystem:SetKey(
                bindingName,
                key
            )
        end,
    })

    tab:CreateDropdown({
        name = displayName .. " Mode",

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

        currentOption = defaultMode,

        callback = function(value)
            local mode = value

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

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

    return binding
end

----------------------------------------------------------------
--// PLAYER SETTINGS
----------------------------------------------------------------

local Movement = {
    WalkSpeed = 16,
    JumpPower = 50,

    FlyEnabled = false,
    FlySpeed = 50,

    NoclipEnabled = false,
    InfiniteJump = false,

    Gravity = 196.2,
    AutoSprint = false,
    AntiAFK = false,

    FOV = 70,
    Fullbright = false,
}

----------------------------------------------------------------
--// CHARACTER HELPERS
----------------------------------------------------------------

local function GetCharacter()
    return LocalPlayer.Character
end

local function GetHumanoid()
    local character = GetCharacter()

    if not character then
        return nil
    end

    return character:FindFirstChildOfClass(
        "Humanoid"
    )
end

local function GetRoot()
    local character = GetCharacter()

    if not character then
        return nil
    end

    return character:FindFirstChild(
        "HumanoidRootPart"
    )
end

local function ApplyMovement()
    local humanoid = GetHumanoid()

    if not humanoid then
        return
    end

    humanoid.WalkSpeed =
        Movement.WalkSpeed

    humanoid.UseJumpPower = true

    humanoid.JumpPower =
        Movement.JumpPower
end

----------------------------------------------------------------
--// WALKSPEED
----------------------------------------------------------------

PlayerTab:CreateSlider({
    name = "WalkSpeed",
    range = {16, 250},
    increment = 1,
    suffix = " WS",
    currentValue = 16,
    flag = "WalkSpeed",

    callback = function(value)
        Movement.WalkSpeed = value
        ApplyMovement()
    end,
})

----------------------------------------------------------------
--// JUMPPOWER
----------------------------------------------------------------

PlayerTab:CreateSlider({
    name = "JumpPower",
    range = {50, 250},
    increment = 1,
    suffix = " JP",
    currentValue = 50,
    flag = "JumpPower",

    callback = function(value)
        Movement.JumpPower = value
        ApplyMovement()
    end,
})

----------------------------------------------------------------
--// INFINITE JUMP
----------------------------------------------------------------

PlayerTab:CreateToggle({
    name = "Infinite Jump",
    flag = "InfiniteJump",
    value = false,

    callback = function(value)
        Movement.InfiniteJump = value
        SyncBindingState(
            "InfiniteJump",
            value
        )
    end,
})

CreateKeybindControls(
    PlayerTab,
    "InfiniteJump",
    "Infinite Jump",
    "J",
    "Toggle",
    "Toggle",

    function(active)
        Movement.InfiniteJump = active
    end
)

UserInputService.JumpRequest:Connect(
    function()
        if not Movement.InfiniteJump then
            return
        end

        local humanoid =
            GetHumanoid()

        if humanoid then
            humanoid:ChangeState(
                Enum.HumanoidStateType.Jumping
            )
        end
    end
)

----------------------------------------------------------------
--// GRAVITY
----------------------------------------------------------------

PlayerTab:CreateSlider({
    name = "Gravity",
    range = {0, 300},
    increment = 1,
    suffix = " Gravity",
    currentValue = 196,
    flag = "Gravity",

    callback = function(value)
        Movement.Gravity = value
        Workspace.Gravity = value
    end,
})

----------------------------------------------------------------
--// CAMERA FOV
----------------------------------------------------------------

PlayerTab:CreateSlider({
    name = "Camera FOV",
    range = {40, 120},
    increment = 1,
    suffix = " deg",
    currentValue = 70,
    flag = "CameraFOV",

    callback = function(value)
        Movement.FOV = value

        local camera =
            Workspace.CurrentCamera

        if camera then
            camera.FieldOfView = value
        end
    end,
})

----------------------------------------------------------------
--// FLY
--// W/A/S/D = movement
--// E = up
--// Q = down
----------------------------------------------------------------

local FlyConnection = nil
local FlyVelocity = nil
local FlyGyro = nil

local function CleanupFlyObjects()
    if FlyConnection then
        FlyConnection:Disconnect()
        FlyConnection = nil
    end

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

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

local function StopFly(disableFeature)
    CleanupFlyObjects()

    if disableFeature then
        Movement.FlyEnabled = false
        SyncBindingState(
            "Fly",
            false
        )
    end

    local humanoid =
        GetHumanoid()

    if humanoid then
        humanoid.PlatformStand = false
        humanoid.AutoRotate = true
    end
end

local function StartFly()
    --// Keep FlyEnabled true when rebuilding
    --// after respawn.
    Movement.FlyEnabled = true

    CleanupFlyObjects()

    local character =
        GetCharacter()

    local humanoid =
        GetHumanoid()

    local root =
        GetRoot()

    if not character
        or not humanoid
        or not root then
        return false
    end

    humanoid.PlatformStand = true
    humanoid.AutoRotate = false

    FlyVelocity =
        Instance.new("BodyVelocity")

    FlyVelocity.Name =
        "AxiomFlyVelocity"

    FlyVelocity.MaxForce =
        Vector3.new(
            math.huge,
            math.huge,
            math.huge
        )

    FlyVelocity.P = 9000
    FlyVelocity.Velocity =
        Vector3.zero

    FlyVelocity.Parent = root

    FlyGyro =
        Instance.new("BodyGyro")

    FlyGyro.Name =
        "AxiomFlyGyro"

    FlyGyro.MaxTorque =
        Vector3.new(
            math.huge,
            math.huge,
            math.huge
        )

    FlyGyro.P = 9000
    FlyGyro.D = 500
    FlyGyro.CFrame =
        root.CFrame

    FlyGyro.Parent = root

    local flyCharacter = character
    local flyRoot = root
    local flyVelocity = FlyVelocity
    local flyGyro = FlyGyro

    FlyConnection =
        RunService.RenderStepped:Connect(
            function()
                if not Movement.FlyEnabled then
                    return
                end

                if GetCharacter() ~= flyCharacter
                    or not flyRoot.Parent
                    or not flyVelocity.Parent
                    or not flyGyro.Parent then

                    return
                end

                local camera =
                    Workspace.CurrentCamera

                if not camera then
                    return
                end

                local forward =
                    camera.CFrame.LookVector

                local right =
                    camera.CFrame.RightVector

                local move =
                    Vector3.zero

                if UserInputService:IsKeyDown(
                    Enum.KeyCode.W
                ) then
                    move += forward
                end

                if UserInputService:IsKeyDown(
                    Enum.KeyCode.S
                ) then
                    move -= forward
                end

                if UserInputService:IsKeyDown(
                    Enum.KeyCode.D
                ) then
                    move += right
                end

                if UserInputService:IsKeyDown(
                    Enum.KeyCode.A
                ) then
                    move -= right
                end

                local horizontal =
                    Vector3.new(
                        move.X,
                        0,
                        move.Z
                    )

                if horizontal.Magnitude > 0 then
                    horizontal =
                        horizontal.Unit
                end

                local vertical = 0

                if UserInputService:IsKeyDown(
                    Enum.KeyCode.E
                ) then
                    vertical += 1
                end

                if UserInputService:IsKeyDown(
                    Enum.KeyCode.Q
                ) then
                    vertical -= 1
                end

                local velocity =
                    horizontal
                    * Movement.FlySpeed

                velocity +=
                    Vector3.new(
                        0,
                        vertical
                            * Movement.FlySpeed,
                        0
                    )

                flyVelocity.Velocity =
                    flyVelocity.Velocity:Lerp(
                        velocity,
                        0.35
                    )

                local look =
                    Vector3.new(
                        camera.CFrame.LookVector.X,
                        0,
                        camera.CFrame.LookVector.Z
                    )

                if look.Magnitude > 0 then
                    look = look.Unit

                    flyGyro.CFrame =
                        CFrame.lookAt(
                            flyRoot.Position,
                            flyRoot.Position + look
                        )
                end
            end
        )

    return true
end

PlayerTab:CreateToggle({
    name = "Fly",
    flag = "Fly",
    value = false,

    callback = function(value)
        Movement.FlyEnabled = value
        SyncBindingState(
            "Fly",
            value
        )

        if value then
            StartFly()
        else
            StopFly(true)
        end
    end,
})

CreateKeybindControls(
    PlayerTab,
    "Fly",
    "Fly",
    "F",
    "Toggle",
    "Toggle",

    function(active)
        Movement.FlyEnabled = active

        if active then
            StartFly()
        else
            StopFly(true)
        end
    end
)

PlayerTab:CreateSlider({
    name = "Fly Speed",
    range = {10, 250},
    increment = 1,
    suffix = " Speed",
    currentValue = 50,
    flag = "FlySpeed",

    callback = function(value)
        Movement.FlySpeed = value
    end,
})

----------------------------------------------------------------
--// NOCLIP
----------------------------------------------------------------

local NoclipConnection = nil

local function SetCollision(value)
    local character =
        GetCharacter()

    if not character then
        return
    end

    for _, obj in ipairs(
        character:GetDescendants()
    ) do
        if obj:IsA("BasePart") then
            obj.CanCollide = value
        end
    end
end

local function StopNoclip(disableFeature)
    if NoclipConnection then
        NoclipConnection:Disconnect()
        NoclipConnection = nil
    end

    if disableFeature then
        Movement.NoclipEnabled = false
        SyncBindingState(
            "Noclip",
            false
        )
    end

    SetCollision(true)
end

local function StartNoclip()
    if NoclipConnection then
        NoclipConnection:Disconnect()
    end

    Movement.NoclipEnabled = true

    NoclipConnection =
        RunService.Stepped:Connect(
            function()
                if Movement.NoclipEnabled then
                    SetCollision(false)
                end
            end
        )
end

PlayerTab:CreateToggle({
    name = "Noclip",
    flag = "Noclip",
    value = false,

    callback = function(value)
        Movement.NoclipEnabled = value
        SyncBindingState(
            "Noclip",
            value
        )

        if value then
            StartNoclip()
        else
            StopNoclip(true)
        end
    end,
})

CreateKeybindControls(
    PlayerTab,
    "Noclip",
    "Noclip",
    "N",
    "Toggle",
    "Toggle",

    function(active)
        Movement.NoclipEnabled = active

        if active then
            StartNoclip()
        else
            StopNoclip(true)
        end
    end
)

----------------------------------------------------------------
--// AUTO SPRINT
----------------------------------------------------------------

PlayerTab:CreateToggle({
    name = "Auto Sprint",
    flag = "AutoSprint",
    value = false,

    callback = function(value)
        Movement.AutoSprint = value
        SyncBindingState(
            "AutoSprint",
            value
        )
    end,
})

CreateKeybindControls(
    PlayerTab,
    "AutoSprint",
    "Auto Sprint",
    "LeftShift",
    "Smart",
    "Toggle",

    function(active)
        Movement.AutoSprint = active
    end
)

RunService.RenderStepped:Connect(
    function()
        if not Movement.AutoSprint then
            return
        end

        local humanoid =
            GetHumanoid()

        if humanoid
            and humanoid.MoveDirection.Magnitude > 0 then

            humanoid.WalkSpeed =
                Movement.WalkSpeed
        end
    end
)

----------------------------------------------------------------
--// FULLBRIGHT
----------------------------------------------------------------

local OriginalLighting = {
    Brightness = Lighting.Brightness,
    ClockTime = Lighting.ClockTime,
    FogEnd = Lighting.FogEnd,
    GlobalShadows = Lighting.GlobalShadows,
    Ambient = Lighting.Ambient,
    OutdoorAmbient = Lighting.OutdoorAmbient,
}

local function ApplyFullbright()
    if Movement.Fullbright then
        Lighting.Brightness = 2
        Lighting.ClockTime = 14
        Lighting.FogEnd = 100000
        Lighting.GlobalShadows = false

        Lighting.Ambient =
            Color3.new(1, 1, 1)

        Lighting.OutdoorAmbient =
            Color3.new(1, 1, 1)
    else
        Lighting.Brightness =
            OriginalLighting.Brightness

        Lighting.ClockTime =
            OriginalLighting.ClockTime

        Lighting.FogEnd =
            OriginalLighting.FogEnd

        Lighting.GlobalShadows =
            OriginalLighting.GlobalShadows

        Lighting.Ambient =
            OriginalLighting.Ambient

        Lighting.OutdoorAmbient =
            OriginalLighting.OutdoorAmbient
    end
end

PlayerTab:CreateToggle({
    name = "Fullbright",
    flag = "Fullbright",
    value = false,

    callback = function(value)
        Movement.Fullbright = value

        SyncBindingState(
            "Fullbright",
            value
        )

        ApplyFullbright()
    end,
})

CreateKeybindControls(
    PlayerTab,
    "Fullbright",
    "Fullbright",
    "B",
    "Toggle",
    "Toggle",

    function(active)
        Movement.Fullbright = active
        ApplyFullbright()
    end
)

----------------------------------------------------------------
--// ANTI AFK
----------------------------------------------------------------

PlayerTab:CreateToggle({
    name = "Anti AFK",
    flag = "AntiAFK",
    value = false,

    callback = function(value)
        Movement.AntiAFK = value

        SyncBindingState(
            "AntiAFK",
            value
        )
    end,
})

CreateKeybindControls(
    PlayerTab,
    "AntiAFK",
    "Anti AFK",
    "P",
    "Toggle",
    "Toggle",

    function(active)
        Movement.AntiAFK = active
    end
)

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

        VirtualUser:CaptureController()

        VirtualUser:ClickButton2(
            Vector2.new()
        )
    end
)

----------------------------------------------------------------
--// SHARED TARGET DATABASE
----------------------------------------------------------------
--// One database for both ESP and Aimbot.
--// NPC discovery is event-driven/dirty based instead
--// of doing a complete Workspace scan every render frame.

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

    PlayerSet = {},
    NPCSet = {},

    PlayerConnections = {},
    CharacterConnections = {},

    Dirty = true,
    LastRebuild = 0,

    RebuildDelay = 0.35,
}

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

    local humanoid =
        obj:FindFirstChildOfClass(
            "Humanoid"
        )

    if not humanoid then
        return false
    end

    if Players:GetPlayerFromCharacter(
        obj
    ) then
        return false
    end

    local root =
        obj:FindFirstChild(
            "HumanoidRootPart"
        )

    if not root
        or not root:IsA("BasePart") then
        return false
    end

    return obj.Parent ~= nil
end

local function MarkTargetDatabaseDirty()
    AxiomTargetDatabase.Dirty = true
end

local function AddPlayerToDatabase(player)
    if player == LocalPlayer then
        return
    end

    if not AxiomTargetDatabase.PlayerSet[player] then
        AxiomTargetDatabase.PlayerSet[player] = true

        table.insert(
            AxiomTargetDatabase.Players,
            player
        )
    end
end

local function RemovePlayerFromDatabase(player)
    AxiomTargetDatabase.PlayerSet[player] = nil

    for i = #AxiomTargetDatabase.Players, 1, -1 do
        if AxiomTargetDatabase.Players[i] == player then
            table.remove(
                AxiomTargetDatabase.Players,
                i
            )
        end
    end
end

local function AddNPCToDatabase(model)
    if not IsNPCModel(model) then
        return
    end

    if AxiomTargetDatabase.NPCSet[model] then
        return
    end

    AxiomTargetDatabase.NPCSet[model] = true

    table.insert(
        AxiomTargetDatabase.NPCs,
        model
    )
end

local function RemoveNPCFromDatabase(model)
    AxiomTargetDatabase.NPCSet[model] = nil

    for i = #AxiomTargetDatabase.NPCs, 1, -1 do
        if AxiomTargetDatabase.NPCs[i] == model then
            table.remove(
                AxiomTargetDatabase.NPCs,
                i
            )
        end
    end
end

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

    if not force
        and now - AxiomTargetDatabase.LastRebuild
            < AxiomTargetDatabase.RebuildDelay then
        return
    end

    AxiomTargetDatabase.LastRebuild = now

    table.clear(
        AxiomTargetDatabase.Players
    )

    table.clear(
        AxiomTargetDatabase.NPCs
    )

    table.clear(
        AxiomTargetDatabase.PlayerSet
    )

    table.clear(
        AxiomTargetDatabase.NPCSet
    )

    ------------------------------------------------------------
    --// PLAYERS
    ------------------------------------------------------------

    for _, player in ipairs(
        Players:GetPlayers()
    ) do
        if player ~= LocalPlayer then
            AxiomTargetDatabase.PlayerSet[player] = true

            table.insert(
                AxiomTargetDatabase.Players,
                player
            )
        end
    end

    ------------------------------------------------------------
    --// NPCS
    ------------------------------------------------------------

    local seenNPCs = {}

    for _, obj in ipairs(
        Workspace:GetDescendants()
    ) do
        if obj:IsA("Model")
            and not seenNPCs[obj]
            and IsNPCModel(obj) then

            seenNPCs[obj] = true
            AxiomTargetDatabase.NPCSet[obj] = true

            table.insert(
                AxiomTargetDatabase.NPCs,
                obj
            )
        end
    end

    AxiomTargetDatabase.Dirty = false
end

----------------------------------------------------------------
--// PLAYER DATABASE EVENTS
----------------------------------------------------------------

local function TrackPlayer(player)
    if player == LocalPlayer then
        return
    end

    AddPlayerToDatabase(player)

    if AxiomTargetDatabase.PlayerConnections[player] then
        return
    end

    local connections = {}

    connections.CharacterAdded =
        player.CharacterAdded:Connect(
            function()
                MarkTargetDatabaseDirty()
            end
        )

    connections.CharacterRemoving =
        player.CharacterRemoving:Connect(
            function()
                MarkTargetDatabaseDirty()
            end
        )

    AxiomTargetDatabase.PlayerConnections[player] =
        connections
end

local function UntrackPlayer(player)
    RemovePlayerFromDatabase(player)

    local connections =
        AxiomTargetDatabase.PlayerConnections[player]

    if connections then
        for _, connection in pairs(
            connections
        ) do
            connection:Disconnect()
        end
    end

    AxiomTargetDatabase.PlayerConnections[player] =
        nil

    MarkTargetDatabaseDirty()
end

Players.PlayerAdded:Connect(
    function(player)
        TrackPlayer(player)
        MarkTargetDatabaseDirty()
    end
)

Players.PlayerRemoving:Connect(
    function(player)
        UntrackPlayer(player)
    end
)

for _, player in ipairs(
    Players:GetPlayers()
) do
    TrackPlayer(player)
end

----------------------------------------------------------------
--// NPC DATABASE EVENTS
----------------------------------------------------------------

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

            MarkTargetDatabaseDirty()
        end
    end
)

Workspace.DescendantRemoving:Connect(
    function(obj)
        if AxiomTargetDatabase.NPCSet[obj] then
            RemoveNPCFromDatabase(obj)
        end

        if obj:IsA("Model")
            or obj:IsA("Humanoid")
            or obj:IsA("BasePart") then

            MarkTargetDatabaseDirty()
        end
    end
)

task.spawn(
    function()
        while true do
            task.wait(
                AxiomTargetDatabase.RebuildDelay
            )

            if AxiomTargetDatabase.Dirty then
                RebuildTargetDatabase()
            end
        end
    end
)

RebuildTargetDatabase(true)

----------------------------------------------------------------
--// ESP SETTINGS
----------------------------------------------------------------

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

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

    Outline = true,
    Fill = true,

    FillTransparency = 50,
    OutlineTransparency = 0,

    FillColor =
        Color3.fromRGB(
            255,
            255,
            255
        ),

    OutlineColor =
        Color3.fromRGB(
            255,
            255,
            255
        ),

    MaxDistance = 2000,

    Objects = {},
}

----------------------------------------------------------------
--// ESP CLEANUP
----------------------------------------------------------------

local function RemoveESP(character)
    local object =
        ESP.Objects[character]

    if not object then
        return
    end

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

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

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

    ESP.Objects[character] = nil
end

local function ClearESP()
    for character in pairs(
        ESP.Objects
    ) do
        RemoveESP(character)
    end
end

----------------------------------------------------------------
--// ESP CREATION
----------------------------------------------------------------

local function CreateESP(
    character,
    player
)
    if not character
        or not character.Parent then
        return
    end

    if ESP.Objects[character] then
        return
    end

    local root =
        character:FindFirstChild(
            "HumanoidRootPart"
        )

    local head =
        character:FindFirstChild(
            "Head"
        )

    if not root then
        return
    end

    local highlight =
        Instance.new("Highlight")

    highlight.Name =
        "AxiomESP"

    highlight.Adornee =
        character

    highlight.DepthMode =
        Enum.HighlightDepthMode.AlwaysOnTop

    highlight.FillColor =
        ESP.FillColor

    highlight.OutlineColor =
        ESP.OutlineColor

    highlight.FillTransparency =
        ESP.FillTransparency / 100

    highlight.OutlineTransparency =
        ESP.OutlineTransparency / 100

    highlight.Parent =
        Workspace

    local billboard =
        Instance.new("BillboardGui")

    billboard.Name =
        "AxiomESPInfo"

    billboard.Adornee =
        head or root

    billboard.Size =
        UDim2.fromOffset(
            220,
            70
        )

    billboard.StudsOffset =
        Vector3.new(
            0,
            3,
            0
        )

    billboard.AlwaysOnTop = true
    billboard.Enabled = true

    billboard.Parent =
        head or root

    local label =
        Instance.new("TextLabel")

    label.Name = "Info"
    label.Size =
        UDim2.fromScale(
            1,
            1
        )

    label.BackgroundTransparency = 1

    label.TextColor3 =
        Color3.new(
            1,
            1,
            1
        )

    label.TextStrokeTransparency = 0
    label.TextSize = 14

    label.Font =
        Enum.Font.GothamBold

    label.TextWrapped = true
    label.Parent = billboard

    ESP.Objects[character] = {
        Player = player,
        Highlight = highlight,
        Billboard = billboard,
        Label = label,
        Root = root,
    }
end

----------------------------------------------------------------
--// ESP REFRESH
----------------------------------------------------------------

local function RefreshESP()
    ClearESP()

    if not ESP.Enabled
        and not ESP.NPCEnabled then
        return
    end

    RebuildTargetDatabase(true)

    if ESP.Enabled then
        for _, player in ipairs(
            AxiomTargetDatabase.Players
        ) do
            if player.Character then
                CreateESP(
                    player.Character,
                    player
                )
            end
        end
    end

    if ESP.NPCEnabled then
        for _, npc in ipairs(
            AxiomTargetDatabase.NPCs
        ) do
            if npc.Parent then
                CreateESP(
                    npc,
                    nil
                )
            end
        end
    end
end

----------------------------------------------------------------
--// ESP UI
----------------------------------------------------------------

ESPTab:CreateToggle({
    name = "Player ESP",
    flag = "PlayerESP",
    value = false,

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

ESPTab:CreateToggle({
    name = "NPC ESP",
    flag = "NPCESP",
    value = false,

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

ESPTab:CreateToggle({
    name = "Names",
    flag = "ESPNames",
    value = true,

    callback = function(value)
        ESP.Names = value
    end,
})

ESPTab:CreateToggle({
    name = "Distance",
    flag = "ESPDistance",
    value = true,

    callback = function(value)
        ESP.Distance = value
    end,
})

ESPTab:CreateToggle({
    name = "Health",
    flag = "ESPHealth",
    value = true,

    callback = function(value)
        ESP.Health = value
    end,
})

ESPTab:CreateToggle({
    name = "Tracers",
    flag = "ESPTracers",
    value = false,

    callback = function(value)
        ESP.Tracers = value
    end,
})

ESPTab:CreateToggle({
    name = "Team Colors",
    flag = "ESPTeamColors",
    value = false,

    callback = function(value)
        ESP.TeamColors = value
    end,
})

ESPTab:CreateToggle({
    name = "Rainbow ESP",
    flag = "ESPRainbow",
    value = false,

    callback = function(value)
        ESP.Rainbow = value
    end,
})

ESPTab:CreateToggle({
    name = "ESP Outline",
    flag = "ESPOutline",
    value = true,

    callback = function(value)
        ESP.Outline = value
    end,
})

ESPTab:CreateToggle({
    name = "ESP Fill",
    flag = "ESPFill",
    value = true,

    callback = function(value)
        ESP.Fill = value
    end,
})

ESPTab:CreateSlider({
    name = "ESP Max Distance",
    range = {100, 5000},
    increment = 100,
    suffix = " studs",
    currentValue = 2000,
    flag = "ESPMaxDistance",

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

ESPTab:CreateSlider({
    name = "Fill Transparency",
    range = {0, 100},
    increment = 1,
    suffix = "%",
    currentValue = 50,
    flag = "ESPFillTransparency",

    callback = function(value)
        ESP.FillTransparency = value
    end,
})

ESPTab:CreateSlider({
    name = "Outline Transparency",
    range = {0, 100},
    increment = 1,
    suffix = "%",
    currentValue = 0,
    flag = "ESPOutlineTransparency",

    callback = function(value)
        ESP.OutlineTransparency = value
    end,
})

ESPTab:CreateColorPicker({
    name = "Fill Color",
    color = ESP.FillColor,
    flag = "ESPFillColor",

    callback = function(value)
        ESP.FillColor = value
    end,
})

ESPTab:CreateColorPicker({
    name = "Outline Color",
    color = ESP.OutlineColor,
    flag = "ESPOutlineColor",

    callback = function(value)
        ESP.OutlineColor = value
    end,
})

----------------------------------------------------------------
--// ESP UPDATE
----------------------------------------------------------------

local RainbowHue = 0

RunService.RenderStepped:Connect(
    function(dt)
        RainbowHue =
            (
                RainbowHue
                + dt * 0.25
            ) % 1

        local camera =
            Workspace.CurrentCamera

        if not camera then
            return
        end

        for character, object in pairs(
            ESP.Objects
        ) do
            if not character
                or not character.Parent then

                RemoveESP(character)
                continue
            end

            local humanoid =
                character:FindFirstChildOfClass(
                    "Humanoid"
                )

            local root =
                character:FindFirstChild(
                    "HumanoidRootPart"
                )

            if not humanoid
                or not root then
                continue
            end

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

            local enabled

            if object.Player then
                enabled = ESP.Enabled
            else
                enabled = ESP.NPCEnabled
            end

            local visible =
                enabled
                and distance <= ESP.MaxDistance

            local color =
                ESP.FillColor

            if ESP.Rainbow then
                color =
                    Color3.fromHSV(
                        RainbowHue,
                        1,
                        1
                    )

            elseif ESP.TeamColors
                and object.Player
                and object.Player.TeamColor then

                color =
                    object.Player.TeamColor.Color
            end

            object.Highlight.Enabled =
                visible

            object.Highlight.FillColor =
                color

            object.Highlight.OutlineColor =
                ESP.OutlineColor

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

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

            local lines = {}

            if ESP.Names then
                table.insert(
                    lines,
                    object.Player
                        and object.Player.DisplayName
                        or character.Name
                )
            end

            if ESP.Distance then
                table.insert(
                    lines,
                    string.format(
                        "%.0f studs",
                        distance
                    )
                )
            end

            if ESP.Health then
                table.insert(
                    lines,
                    string.format(
                        "HP: %.0f / %.0f",
                        humanoid.Health,
                        humanoid.MaxHealth
                    )
                )
            end

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

            object.Billboard.Enabled =
                visible
                and #lines > 0
        end
    end
)

----------------------------------------------------------------
--// ESP DATABASE REFRESH
----------------------------------------------------------------

task.spawn(
    function()
        while true do
            task.wait(0.5)

            if ESP.Enabled
                or ESP.NPCEnabled then

                if AxiomTargetDatabase.Dirty then
                    RefreshESP()
                else
                    --// Add newly spawned characters
                    --// without rebuilding unnecessarily.
                    for _, player in ipairs(
                        AxiomTargetDatabase.Players
                    ) do
                        if player.Character
                            and not ESP.Objects[
                                player.Character
                            ]
                            and ESP.Enabled then

                            CreateESP(
                                player.Character,
                                player
                            )
                        end
                    end

                    if ESP.NPCEnabled then
                        for _, npc in ipairs(
                            AxiomTargetDatabase.NPCs
                        ) do
                            if npc.Parent
                                and not ESP.Objects[npc] then

                                CreateESP(
                                    npc,
                                    nil
                                )
                            end
                        end
                    end
                end
            end
        end
    end
)

----------------------------------------------------------------
--// AIMBOT SETTINGS
----------------------------------------------------------------

local Aimbot = {
    Enabled = false,

    UseAimKey = true,
    AimKeyHeld = false,

    AimAtPlayers = true,
    AimAtNPCs = false,

    OnlyVisible = true,

    TargetPart = "Head",
    LockTarget = true,

    TeamCheck = false,
    IgnoreDead = true,

    FOV = 150,
    MaxDistance = 500,

    Smoothness = 15,

    Prediction = false,
    PredictionStrength = 0.1,

    Target = nil,
}

----------------------------------------------------------------
--// AIMBOT HELPERS
----------------------------------------------------------------

local function GetCamera()
    return Workspace.CurrentCamera
end

local function GetTargetCharacter(target)
    if not target then
        return nil
    end

    if target:IsA("Player") then
        return target.Character
    end

    if target:IsA("Model") then
        return target
    end

    return nil
end

local function GetTargetPart(target)
    local character =
        GetTargetCharacter(target)

    if not character then
        return nil
    end

    local preferred =
        character:FindFirstChild(
            Aimbot.TargetPart
        )

    if preferred
        and preferred:IsA("BasePart") then

        return preferred
    end

    for _, name in ipairs({
        "Head",
        "UpperTorso",
        "Torso",
        "HumanoidRootPart",
    }) do
        local part =
            character:FindFirstChild(name)

        if part
            and part:IsA("BasePart") then

            return part
        end
    end

    return nil
end

local function IsAlive(target)
    local character =
        GetTargetCharacter(target)

    if not character then
        return false
    end

    local humanoid =
        character:FindFirstChildOfClass(
            "Humanoid"
        )

    if not humanoid then
        return false
    end

    return not Aimbot.IgnoreDead
        or humanoid.Health > 0
end

local function IsValidTargetType(target)
    if not target then
        return false
    end

    if target:IsA("Player") then
        if target == LocalPlayer
            or not Aimbot.AimAtPlayers then
            return false
        end

        if Aimbot.TeamCheck
            and LocalPlayer.Team
            and target.Team
                == LocalPlayer.Team then

            return false
        end

        return true
    end

    if target:IsA("Model") then
        return Aimbot.AimAtNPCs
            and IsNPCModel(target)
    end

    return false
end

local function IsVisible(
    target,
    part
)
    local camera =
        GetCamera()

    if not camera
        or not part then
        return false
    end

    local character =
        GetTargetCharacter(target)

    if not character then
        return false
    end

    local params =
        RaycastParams.new()

    params.FilterType =
        Enum.RaycastFilterType.Exclude

    params.IgnoreWater = true

    local filter = {}

    if LocalPlayer.Character then
        table.insert(
            filter,
            LocalPlayer.Character
        )
    end

    params.FilterDescendantsInstances =
        filter

    local origin =
        camera.CFrame.Position

    local direction =
        part.Position - origin

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

    if not result then
        return true
    end

    return result.Instance:IsDescendantOf(
        character
    )
end

----------------------------------------------------------------
--// AIMBOT TARGET VALIDATION
----------------------------------------------------------------

local function GetTargetData(target, camera)
    if not IsValidTargetType(target) then
        return nil
    end

    if not IsAlive(target) then
        return nil
    end

    local character =
        GetTargetCharacter(target)

    if not character
        or not character.Parent then
        return nil
    end

    local part =
        GetTargetPart(target)

    if not part
        or not part.Parent then
        return nil
    end

    local distance3D =
        (
            camera.CFrame.Position
            - part.Position
        ).Magnitude

    if distance3D > Aimbot.MaxDistance then
        return nil
    end

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

    if not onScreen
        or screenPosition.Z <= 0 then
        return nil
    end

    local viewport =
        camera.ViewportSize

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

    local screen =
        Vector2.new(
            screenPosition.X,
            screenPosition.Y
        )

    local screenDistance =
        (
            screen - center
        ).Magnitude

    if screenDistance > Aimbot.FOV then
        return nil
    end

    return {
        Target = target,
        Character = character,
        Part = part,
        Distance = distance3D,
        ScreenDistance = screenDistance,
    }
end

----------------------------------------------------------------
--// AIMBOT TARGET SEARCH
----------------------------------------------------------------
--// Cheap tests happen first.
--// Visibility raycasts happen only for candidates
--// that already passed FOV/distance checks.

local function GetClosestTarget()
    local camera =
        GetCamera()

    if not camera then
        return nil
    end

    local candidates = {}

    if Aimbot.AimAtPlayers then
        for _, player in ipairs(
            AxiomTargetDatabase.Players
        ) do
            local data =
                GetTargetData(
                    player,
                    camera
                )

            if data then
                table.insert(
                    candidates,
                    data
                )
            end
        end
    end

    if Aimbot.AimAtNPCs then
        for _, npc in ipairs(
            AxiomTargetDatabase.NPCs
        ) do
            local data =
                GetTargetData(
                    npc,
                    camera
                )

            if data then
                table.insert(
                    candidates,
                    data
                )
            end
        end
    end

    if #candidates == 0 then
        return nil
    end

    table.sort(
        candidates,
        function(a, b)
            return a.ScreenDistance
                < b.ScreenDistance
        end
    )

    if not Aimbot.OnlyVisible then
        return candidates[1].Target
    end

    --// Only raycast candidates in FOV.
    --// Stops immediately once a visible candidate
    --// is found.
    for _, data in ipairs(
        candidates
    ) do
        if IsVisible(
            data.Target,
            data.Part
        ) then
            return data.Target
        end
    end

    return nil
end

----------------------------------------------------------------
--// AIMBOT FOV
----------------------------------------------------------------

local FOVGui =
    Instance.new("ScreenGui")

FOVGui.Name =
    "AxiomAimbotFOV"

FOVGui.ResetOnSpawn = false
FOVGui.IgnoreGuiInset = true

FOVGui.Parent =
    LocalPlayer:WaitForChild(
        "PlayerGui"
    )

local FOVCircle =
    Instance.new("Frame")

FOVCircle.Name =
    "FOVCircle"

FOVCircle.AnchorPoint =
    Vector2.new(
        0.5,
        0.5
    )

FOVCircle.BackgroundTransparency = 1

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

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

FOVStroke.Color =
    Color3.new(
        1,
        1,
        1
    )

FOVStroke.Parent =
    FOVCircle

local function UpdateFOV()
    local camera =
        GetCamera()

    if not camera then
        return
    end

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

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

----------------------------------------------------------------
--// AIMBOT UI
----------------------------------------------------------------

AimbotTab:CreateToggle({
    name = "Aimbot",
    flag = "Aimbot",
    value = false,

    callback = function(value)
        Aimbot.Enabled = value

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

AimbotTab:CreateToggle({
    name = "Use Aim Key",
    flag = "UseAimKey",
    value = true,

    callback = function(value)
        Aimbot.UseAimKey = value

        if not value then
            Aimbot.AimKeyHeld = false
        end
    end,
})

CreateKeybindControls(
    AimbotTab,
    "Aimbot",
    "Aimbot",
    "RMB",
    "Hold",
    "Hold",

    function(active)
        Aimbot.AimKeyHeld = active
    end
)

AimbotTab:CreateToggle({
    name = "Aim At Players",
    flag = "AimAtPlayers",
    value = true,

    callback = function(value)
        Aimbot.AimAtPlayers = value
        MarkTargetDatabaseDirty()

        if not value
            and Aimbot.Target
            and Aimbot.Target:IsA("Player") then

            Aimbot.Target = nil
        end
    end,
})

AimbotTab:CreateToggle({
    name = "Aim At NPCs",
    flag = "AimAtNPCs",
    value = false,

    callback = function(value)
        Aimbot.AimAtNPCs = value
        MarkTargetDatabaseDirty()

        if not value
            and Aimbot.Target
            and Aimbot.Target:IsA("Model") then

            Aimbot.Target = nil
        end
    end,
})

AimbotTab:CreateToggle({
    name = "Only Visible",
    flag = "OnlyVisible",
    value = true,

    callback = function(value)
        Aimbot.OnlyVisible = value
    end,
})

AimbotTab:CreateDropdown({
    name = "Target Part",

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

    currentOption = "Head",
    flag = "TargetPart",

    callback = function(value)
        if type(value) == "table" then
            value = value[1]
        end

        Aimbot.TargetPart =
            value
    end,
})

AimbotTab:CreateToggle({
    name = "Lock Target",
    flag = "LockTarget",
    value = true,

    callback = function(value)
        Aimbot.LockTarget = value

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

AimbotTab:CreateSlider({
    name = "FOV",
    range = {25, 500},
    increment = 5,
    suffix = " px",
    currentValue = 150,
    flag = "AimbotFOV",

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

AimbotTab:CreateToggle({
    name = "Show FOV",
    flag = "ShowFOV",
    value = false,

    callback = function(value)
        FOVCircle.Visible = value
    end,
})

AimbotTab:CreateColorPicker({
    name = "FOV Color",
    color = Color3.new(
        1,
        1,
        1
    ),

    flag = "FOVColor",

    callback = function(value)
        FOVStroke.Color = value
    end,
})

AimbotTab:CreateSlider({
    name = "Max Distance",
    range = {50, 2000},
    increment = 50,
    suffix = " studs",
    currentValue = 500,
    flag = "AimbotMaxDistance",

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

AimbotTab:CreateSlider({
    name = "Smoothness",
    range = {1, 100},
    increment = 1,
    suffix = "%",
    currentValue = 15,
    flag = "Smoothness",

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

AimbotTab:CreateToggle({
    name = "Prediction",
    flag = "Prediction",
    value = false,

    callback = function(value)
        Aimbot.Prediction = value
    end,
})

AimbotTab:CreateSlider({
    name = "Prediction Strength",
    range = {0, 1},
    increment = 0.01,
    suffix = "",
    currentValue = 0.1,
    flag = "PredictionStrength",

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

AimbotTab:CreateToggle({
    name = "Team Check",
    flag = "TeamCheck",
    value = false,

    callback = function(value)
        Aimbot.TeamCheck = value
    end,
})

AimbotTab:CreateToggle({
    name = "Ignore Dead",
    flag = "IgnoreDead",
    value = true,

    callback = function(value)
        Aimbot.IgnoreDead = value
    end,
})

----------------------------------------------------------------
--// AIMBOT LOOP
----------------------------------------------------------------

RunService:BindToRenderStep(
    "AxiomAimbot",
    Enum.RenderPriority.Camera.Value + 1,

    function()
        UpdateFOV()

        if not Aimbot.Enabled then
            Aimbot.Target = nil
            return
        end

        if Aimbot.UseAimKey
            and not Aimbot.AimKeyHeld then

            Aimbot.Target = nil
            return
        end

        local target =
            Aimbot.Target

        if not Aimbot.LockTarget
            or not target then

            target =
                GetClosestTarget()

            Aimbot.Target =
                target
        end

        if target
            and not IsValidTargetType(target) then

            Aimbot.Target = nil
            target = nil
        end

        if target
            and not IsAlive(target) then

            Aimbot.Target = nil
            target = nil
        end

        local camera =
            GetCamera()

        if not camera then
            return
        end

        if not target then
            return
        end

        local part =
            GetTargetPart(target)

        if not part then
            Aimbot.Target = nil
            return
        end

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

        if distance > Aimbot.MaxDistance then
            Aimbot.Target = nil
            return
        end

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

        if not onScreen
            or screenPosition.Z <= 0 then

            Aimbot.Target = nil
            return
        end

        local center =
            Vector2.new(
                camera.ViewportSize.X / 2,
                camera.ViewportSize.Y / 2
            )

        local screenDistance =
            (
                Vector2.new(
                    screenPosition.X,
                    screenPosition.Y
                ) - center
            ).Magnitude

        --// Locked targets are still required to
        --// remain inside the configured FOV.
        if screenDistance > Aimbot.FOV then
            Aimbot.Target = nil
            return
        end

        if Aimbot.OnlyVisible
            and not IsVisible(
                target,
                part
            ) then

            Aimbot.Target = nil
            return
        end

        local targetPosition =
            part.Position

        if Aimbot.Prediction then
            targetPosition +=
                part.AssemblyLinearVelocity
                * Aimbot.PredictionStrength
        end

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

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

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

----------------------------------------------------------------
--// UTILITIES
----------------------------------------------------------------

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

    callback = function()
        TeleportService:
            TeleportToPlaceInstance(
                game.PlaceId,
                game.JobId,
                LocalPlayer
            )
    end,
})

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

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

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

    callback = function()
        local humanoid =
            GetHumanoid()

        if humanoid then
            humanoid.Health = 0
        end
    end,
})

----------------------------------------------------------------
--// CLIPBOARD
----------------------------------------------------------------

local function CopyText(text)
    if not text then
        return false
    end

    return pcall(
        function()
            if setclipboard then
                setclipboard(text)

            elseif toclipboard then
                toclipboard(text)

            elseif syn
                and syn.write_clipboard then

                syn.write_clipboard(text)

            elseif Clipboard
                and Clipboard.set then

                Clipboard.set(text)

            else
                error(
                    "Clipboard unavailable"
                )
            end
        end
    )
end

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

    callback = function()
        CopyText(
            game.JobId
        )
    end,
})

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

    callback = function()
        CopyText(
            tostring(
                game.PlaceId
            )
        )
    end,
})

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

    callback = function()
        CopyText(
            tostring(
                LocalPlayer.UserId
            )
        )
    end,
})

----------------------------------------------------------------
--// SESSION STATS
----------------------------------------------------------------

local StatsLabel =
    UtilitiesTab:CreateLabel(
        "FPS: 0 | Ping: N/A | Players: 0 | Session: 00:00"
    )

local FrameCounter = 0
local FPS = 0
local LastFPSUpdate = os.clock()
local SessionStart = os.clock()

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

        local now =
            os.clock()

        if now - LastFPSUpdate >= 1 then
            FPS = FrameCounter
            FrameCounter = 0
            LastFPSUpdate = now
        end
    end
)

task.spawn(
    function()
        while true do
            task.wait(1)

            local ping = "N/A"

            pcall(
                function()
                    ping =
                        string.format(
                            "%.0f ms",
                            LocalPlayer:
                                GetNetworkPing()
                                * 1000
                        )
                end
            )

            local playerCount =
                #Players:GetPlayers()

            local session =
                math.floor(
                    os.clock()
                    - SessionStart
                )

            local hours =
                math.floor(
                    session / 3600
                )

            local minutes =
                math.floor(
                    (session % 3600) / 60
                )

            local seconds =
                session % 60

            local sessionText =
                string.format(
                    "%02d:%02d:%02d",
                    hours,
                    minutes,
                    seconds
                )

            pcall(
                function()
                    StatsLabel:Set(
                        string.format(
                            "FPS: %d | Ping: %s | Players: %d | Session: %s",
                            FPS,
                            ping,
                            playerCount,
                            sessionText
                        )
                    )
                end
            )
        end
    end
)

----------------------------------------------------------------
--// DEVELOPER
----------------------------------------------------------------

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

    callback = function()
        local root =
            GetRoot()

        if root then
            CopyText(
                string.format(
                    "%.2f, %.2f, %.2f",
                    root.Position.X,
                    root.Position.Y,
                    root.Position.Z
                )
            )
        end
    end,
})

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

    callback = function()
        local root =
            GetRoot()

        if not root then
            return
        end

        local velocity =
            root.AssemblyLinearVelocity

        CopyText(
            string.format(
                "%.2f, %.2f, %.2f",
                velocity.X,
                velocity.Y,
                velocity.Z
            )
        )
    end,
})

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

    callback = function()
        CopyText(
            string.format(
                "Name: %s\nDisplay: %s\nUserId: %d",
                LocalPlayer.Name,
                LocalPlayer.DisplayName,
                LocalPlayer.UserId
            )
        )
    end,
})

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

    callback = function()
        local character =
            GetCharacter()

        if not character then
            return
        end

        local output = {
            "=== AXIOM CHARACTER INSPECTOR ==="
        }

        for _, obj in ipairs(
            character:GetDescendants()
        ) do
            table.insert(
                output,
                obj:GetFullName()
            )
        end

        CopyText(
            table.concat(
                output,
                "\n"
            )
        )
    end,
})

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

    callback = function()
        local humanoid =
            GetHumanoid()

        if not humanoid then
            return
        end

        local output = {
            "=== AXIOM HUMANOID INSPECTOR ===",

            "Health: "
                .. humanoid.Health,

            "MaxHealth: "
                .. humanoid.MaxHealth,

            "WalkSpeed: "
                .. humanoid.WalkSpeed,

            "JumpPower: "
                .. humanoid.JumpPower,

            "HipHeight: "
                .. humanoid.HipHeight,

            "State: "
                .. tostring(
                    humanoid:GetState()
                ),
        }

        CopyText(
            table.concat(
                output,
                "\n"
            )
        )
    end,
})

----------------------------------------------------------------
--// OBJECT PICKER
----------------------------------------------------------------

local ObjectPicker = {
    Active = false,
    Hovered = nil,
    Selected = nil,

    Highlight = nil,

    RenderConnection = nil,
    InputConnection = nil,
}

local ObjectPickerLabel

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

    return object:GetFullName()
end

local function ClearObjectHighlight()
    if ObjectPicker.Highlight then
        ObjectPicker.Highlight:Destroy()
        ObjectPicker.Highlight = nil
    end

    ObjectPicker.Hovered = nil
end

local function HighlightObject(object)
    if ObjectPicker.Hovered == object then
        return
    end

    ClearObjectHighlight()

    if not object then
        return
    end

    local adornee = nil

    if object:IsA("BasePart")
        or object:IsA("Model") then

        adornee = object
    else
        adornee =
            object:FindFirstAncestorOfClass(
                "Model"
            )
    end

    if not adornee then
        return
    end

    local highlight =
        Instance.new("Highlight")

    highlight.Name =
        "AxiomObjectPickerHighlight"

    highlight.Adornee =
        adornee

    highlight.DepthMode =
        Enum.HighlightDepthMode.AlwaysOnTop

    highlight.FillColor =
        Color3.fromRGB(
            255,
            170,
            0
        )

    highlight.OutlineColor =
        Color3.fromRGB(
            255,
            255,
            255
        )

    highlight.FillTransparency =
        0.65

    highlight.OutlineTransparency =
        0

    highlight.Parent =
        Workspace

    ObjectPicker.Highlight =
        highlight

    ObjectPicker.Hovered =
        object
end

local function ShouldIgnorePickerObject(
    object
)
    if not object then
        return true
    end

    local character =
        LocalPlayer.Character

    if character
        and object:IsDescendantOf(
            character
        ) then

        return true
    end

    return false
end

local function GetMouseObject()
    local camera =
        Workspace.CurrentCamera

    if not camera then
        return nil
    end

    local mousePosition =
        UserInputService:GetMouseLocation()

    --// Fix GUI inset offset.
    local inset =
        GuiService:GetGuiInset()

    local x =
        mousePosition.X
        - inset.X

    local y =
        mousePosition.Y
        - inset.Y

    local ray =
        camera:ViewportPointToRay(
            x,
            y
        )

    local params =
        RaycastParams.new()

    params.FilterType =
        Enum.RaycastFilterType.Exclude

    params.IgnoreWater = true

    if LocalPlayer.Character then
        params.FilterDescendantsInstances = {
            LocalPlayer.Character
        }
    end

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

    if not result then
        return nil
    end

    local object =
        result.Instance

    if ShouldIgnorePickerObject(
        object
    ) then
        return nil
    end

    return object
end

local function UpdateObjectPickerLabel(
    object
)
    if not ObjectPickerLabel then
        return
    end

    local text

    if object then
        text =
            "Selected: "
            .. GetObjectPath(object)
    else
        text =
            "Selected: None"
    end

    pcall(
        function()
            ObjectPickerLabel:Set(
                text
            )
        end
    )
end

local function StopObjectPicker()
    ObjectPicker.Active = false

    ClearObjectHighlight()

    if ObjectPicker.RenderConnection then
        ObjectPicker.RenderConnection:Disconnect()
        ObjectPicker.RenderConnection = nil
    end

    if ObjectPicker.InputConnection then
        ObjectPicker.InputConnection:Disconnect()
        ObjectPicker.InputConnection = nil
    end
end

local function StartObjectPicker()
    if ObjectPicker.Active then
        StopObjectPicker()
        return
    end

    ObjectPicker.Active = true

    ObjectPicker.RenderConnection =
        RunService.RenderStepped:Connect(
            function()
                if not ObjectPicker.Active then
                    return
                end

                local object =
                    GetMouseObject()

                HighlightObject(
                    object
                )
            end
        )

    ObjectPicker.InputConnection =
        UserInputService.InputBegan:Connect(
            function(
                input,
                processed
            )
                if not ObjectPicker.Active then
                    return
                end

                if input.KeyCode ==
                    Enum.KeyCode.Escape then

                    StopObjectPicker()
                    return
                end

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

                    local object =
                        GetMouseObject()

                    if object then
                        ObjectPicker.Selected =
                            object

                        UpdateObjectPickerLabel(
                            object
                        )

                        CopyText(
                            GetObjectPath(
                                object
                            )
                        )

                        StopObjectPicker()
                    end
                end
            end
        )
end

DeveloperTab:CreateSection(
    "Object Picker"
)

ObjectPickerLabel =
    DeveloperTab:CreateLabel(
        "Selected: None"
    )

DeveloperTab:CreateButton({
    name = "Pick Object",

    callback = function()
        StartObjectPicker()
    end,
})

----------------------------------------------------------------
--// OBJECT PICKER KEYBIND
--// Default: F
--// Default mode: Toggle
----------------------------------------------------------------

CreateKeybindControls(
    DeveloperTab,
    "ObjectPicker",
    "Object Picker",
    "F",
    "Toggle",
    "Toggle",

    function(active)
        if active then
            StartObjectPicker()
        else
            StopObjectPicker()
        end
    end
)

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

    callback = function()
        local object =
            ObjectPicker.Selected

        if not object then
            return
        end

        CopyText(
            GetObjectPath(
                object
            )
        )
    end,
})

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

    callback = function()
        local object =
            ObjectPicker.Selected

        if not object then
            return
        end

        CopyText(
            object.Name
        )
    end,
})

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

    callback = function()
        local object =
            ObjectPicker.Selected

        if not object then
            return
        end

        CopyText(
            object.ClassName
        )
    end,
})

DeveloperTab:CreateButton({
    name = "Copy Mouse Target",

    callback = function()
        local object =
            GetMouseObject()

        if not object then
            return
        end

        ObjectPicker.Selected =
            object

        UpdateObjectPickerLabel(
            object
        )

        CopyText(
            GetObjectPath(
                object
            )
        )
    end,
})

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

    callback = function()
        ObjectPicker.Selected =
            nil

        UpdateObjectPickerLabel(
            nil
        )
    end,
})

----------------------------------------------------------------
--// OBJECT INSPECTOR
----------------------------------------------------------------

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

    callback = function()
        local object =
            ObjectPicker.Selected

        if not object then
            return
        end

        local output = {
            "=== AXIOM OBJECT INSPECTOR ===",
            "",

            "Name: "
                .. object.Name,

            "Class: "
                .. object.ClassName,

            "Path: "
                .. GetObjectPath(
                    object
                ),

            "Parent: "
                .. (
                    object.Parent
                    and object.Parent:GetFullName()
                    or "nil"
                ),

            "Archivable: "
                .. tostring(
                    object.Archivable
                ),
        }

        local attributes =
            object:GetAttributes()

        if next(attributes) then
            table.insert(
                output,
                ""
            )

            table.insert(
                output,
                "=== ATTRIBUTES ==="
            )

            for name, value in pairs(
                attributes
            ) do
                table.insert(
                    output,
                    tostring(name)
                        .. " = "
                        .. tostring(value)
                )
            end
        end

        local result =
            table.concat(
                output,
                "\n"
            )

        print(result)

        CopyText(result)
    end,
})

----------------------------------------------------------------
--// OBJECT PICKER CLEANUP
----------------------------------------------------------------

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

----------------------------------------------------------------
--// CHARACTER HANDLING
----------------------------------------------------------------

LocalPlayer.CharacterRemoving:Connect(
    function()
        --// Destroy old fly objects, but DO NOT
        --// disable the Fly feature itself.
        if Movement.FlyEnabled then
            CleanupFlyObjects()
        else
            StopFly(false)
        end

        if Movement.NoclipEnabled then
            if NoclipConnection then
                NoclipConnection:Disconnect()
                NoclipConnection = nil
            end
        end

        Aimbot.Target = nil
    end
)

LocalPlayer.CharacterAdded:Connect(
    function(character)
        character:WaitForChild(
            "Humanoid",
            10
        )

        character:WaitForChild(
            "HumanoidRootPart",
            10
        )

        task.wait(0.15)

        ApplyMovement()

        local camera =
            Workspace.CurrentCamera

        if camera then
            camera.FieldOfView =
                Movement.FOV
        end

        --------------------------------------------------------
        --// NOCLIP
        --------------------------------------------------------

        if Movement.NoclipEnabled then
            StartNoclip()
        end

        --------------------------------------------------------
        --// FLY
        --// Rebuild automatically if it was enabled
        --// before the reset.
        --------------------------------------------------------

        if Movement.FlyEnabled then
            StartFly()
        end

        --------------------------------------------------------
        --// DATABASE / ESP
        --------------------------------------------------------

        MarkTargetDatabaseDirty()

        if ESP.Enabled
            or ESP.NPCEnabled then

            task.delay(
                0.2,
                function()
                    if ESP.Enabled
                        or ESP.NPCEnabled then
                        RefreshESP()
                    end
                end
            )
        end

        Aimbot.Target = nil
    end
)

----------------------------------------------------------------
--// INITIALIZATION
----------------------------------------------------------------

Workspace.Gravity =
    Movement.Gravity

ApplyMovement()

UpdateFOV()

local camera =
    Workspace.CurrentCamera

if camera then
    camera.FieldOfView =
        Movement.FOV
end

RebuildTargetDatabase(true)

----------------------------------------------------------------
--// AXIOM v1.62.10
--// BETA 10
----------------------------------------------------------------