local Rayfield = loadstring(game:HttpGet('https://sirius.menu/rayfield'))()

-- =========================
-- WINDOW
-- =========================
local Window = Rayfield:CreateWindow({
    Name = "Vision Hub",
    LoadingTitle = "Vision Script",
    LoadingSubtitle = "by Vision",
    ConfigurationSaving = { Enabled = true },
    Discord = {
        Enabled = true,
        Invite = "1",
        RememberJoins = true
    },
    KeySystem = false,
    KeySettings = {
        Title = "Vision Script Hub | Key",
        Subtitle = "Link In Discord",
        Note = "Key: 1",
        FileName = "VisionKey",
        SaveKey = false,
        GrabKeyFromSite = true,
        Key = {"https://pastebin.com/raw/QZYyHa0H"}
    }
})

-- =========================
-- THROWING TAB
-- =========================
local ThrowingTab = Window:CreateTab("Throwing", nil)
ThrowingTab:CreateSection("QB Aimbot")

-- ==============================
-- QB SETTINGS (GLOBAL)
-- ==============================
local DIME_MOVING_LEAD = 46
local MAG_MOVING_LEAD  = 50
local GLOBAL_THROW_ANGLE = 55

local QB_ENABLED = false
local QB_GUI = nil
local QB_CONNECTIONS = {}

-- ==============================
-- QB SYSTEM TOGGLE (FIRST)
-- ==============================
ThrowingTab:CreateToggle({
    Name = "QB Aimbot",
    CurrentValue = false,
    Callback = function(Value)

        -- ========= TOGGLE OFF =========
        if not Value then
            QB_ENABLED = false

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

            for _,c in pairs(QB_CONNECTIONS) do
                if c then c:Disconnect() end
            end
            QB_CONNECTIONS = {}
            return
        end

        -- ========= TOGGLE ON =========
        QB_ENABLED = true

        task.spawn(function()

            -- SERVICES
            local Players = game:GetService("Players")
            local RunService = game:GetService("RunService")
            local UIS = game:GetService("UserInputService")
            local Camera = workspace.CurrentCamera
            local LocalPlayer = Players.LocalPlayer
            local RS = game:GetService("ReplicatedStorage")

            -- REMOTE
            local ThrowRemote = RS.Packages.Knit.Services.ControlService.RE.Throw

            -- CONFIG
            local GRAVITY = Vector3.new(0, -28, 0)
            local MAX_POWER = 100

            -- STATE
            local currentPass = "Dime"
            local locked = false
            local lockedTarget = nil

            -- GUI
            local gui = Instance.new("ScreenGui")
            gui.Name = "QB_AIM_GUI"
            gui.ResetOnSpawn = false
            gui.Parent = LocalPlayer.PlayerGui
            QB_GUI = gui

            local frame = Instance.new("Frame", gui)
            frame.Size = UDim2.new(0,320,0,160)
            frame.Position = UDim2.new(0.02,0,0.4,0)
            frame.BackgroundColor3 = Color3.fromRGB(18,18,18)
            Instance.new("UICorner", frame).CornerRadius = UDim.new(0,12)

            -- LABELS
            local function label(txt,y)
                local l = Instance.new("TextLabel", frame)
                l.Size = UDim2.new(1,-20,0,20)
                l.Position = UDim2.new(0,10,0,y)
                l.BackgroundTransparency = 1
                l.TextColor3 = Color3.fromRGB(200,255,200)
                l.Font = Enum.Font.GothamBold
                l.TextSize = 14
                l.TextXAlignment = Enum.TextXAlignment.Left
                l.Text = txt
                return l
            end

            local passLabel = label("Pass: Dime",10)
            local targetLabel = label("Target: None",35)
            local powerLabel = label("Power: 0",60)

            -- TARGETING
            local function getClosestTarget()
                local mousePos = UIS:GetMouseLocation()
                local best, dist = nil, math.huge

                for _,p in pairs(Players:GetPlayers()) do
                    if p ~= LocalPlayer and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
                        local pos, onScreen = Camera:WorldToViewportPoint(p.Character.HumanoidRootPart.Position)
                        if onScreen then
                            local d = (Vector2.new(pos.X,pos.Y) - mousePos).Magnitude
                            if d < dist then
                                dist = d
                                best = p.Character
                            end
                        end
                    end
                end
                return best
            end

            -- BALLISTICS
            local function calculateVelocity(startPos, targetPos)
                local angle = GLOBAL_THROW_ANGLE
                local dxz = (Vector3.new(targetPos.X,0,targetPos.Z)
                           - Vector3.new(startPos.X,0,startPos.Z)).Magnitude
                local dy = targetPos.Y - startPos.Y

                local rad = math.rad(angle)
                local cos = math.cos(rad)
                local denom = 2*cos*cos*(dxz*math.tan(rad)-dy)
                if denom <= 0 then return end

                local speed = math.sqrt(GRAVITY.Magnitude * dxz * dxz / denom)
                local dir = (Vector3.new(targetPos.X,startPos.Y,targetPos.Z) - startPos).Unit

                return dir*(speed*cos) + Vector3.new(0,speed*math.sin(rad),0), speed
            end

            local function getPredictedPosition(hrp)
                local vel = hrp.Velocity
                local flat = Vector3.new(vel.X,0,vel.Z)
                local speed = flat.Magnitude
                local dir = speed > 1 and flat.Unit or Vector3.zero

                local predicted = hrp.Position + Vector3.new(0,14,0)

                if currentPass == "Mag" then
                    predicted += dir * MAG_MOVING_LEAD
                elseif currentPass == "Dime" then
                    predicted += dir * DIME_MOVING_LEAD
                end

                return predicted
            end

            -- THROW
            local function throwBall()
                if not QB_ENABLED then return end

                local head = LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("Head")
                if not head then return end

                local target = locked and lockedTarget or getClosestTarget()
                if not target then return end

                local hrp = target:FindFirstChild("HumanoidRootPart")
                if not hrp then return end

                local vel, power = calculateVelocity(head.Position, getPredictedPosition(hrp))
                if not vel then return end

                power = math.clamp(math.floor(power), 1, MAX_POWER)
                powerLabel.Text = "Power: "..power

                local t = 1.5
                ThrowRemote:FireServer(
                    head.Position,
                    head.Position + vel*t + 0.5*GRAVITY*t*t,
                    power
                )
            end

            -- LOOP
            QB_CONNECTIONS.Render = RunService.RenderStepped:Connect(function()
                if not QB_ENABLED then return end
                passLabel.Text = "Pass: "..currentPass
                targetLabel.Text = locked and lockedTarget
                    and ("Target: "..lockedTarget.Name)
                    or "Target: None"
            end)

            -- INPUT (E)
            QB_CONNECTIONS.Input = UIS.InputBegan:Connect(function(i,gp)
                if gp then return end
                if i.KeyCode == Enum.KeyCode.E then
                    throwBall()
                end
            end)

        end)
    end
})

-- ==============================
-- QB SETTINGS (BELOW TOGGLE)
-- ==============================
ThrowingTab:CreateSection("QB Settings")

ThrowingTab:CreateSlider({
    Name = "Dime Moving Lead",
    Range = {0, 80},
    Increment = 1,
    CurrentValue = DIME_MOVING_LEAD,
    Callback = function(Value)
        DIME_MOVING_LEAD = Value
    end
})

ThrowingTab:CreateSlider({
    Name = "Mag Moving Lead",
    Range = {0, 80},
    Increment = 1,
    CurrentValue = MAG_MOVING_LEAD,
    Callback = function(Value)
        MAG_MOVING_LEAD = Value
    end
})

ThrowingTab:CreateSlider({
    Name = "Angle",
    Range = {0, 100},
    Increment = 1,
    Suffix = "°",
    CurrentValue = GLOBAL_THROW_ANGLE,
    Callback = function(Value)
        GLOBAL_THROW_ANGLE = Value
    end
})

-- =============================
-- CATCHING TAB
-- =============================
local CatchingTab = Window:CreateTab("Catching", nil)
CatchingTab:CreateSection("Catching")

--// UI

local ms67 = false
local dist = 120

local magnetToggle = CatchingTab:CreateToggle({
    Name = "Desync Magnet",
    CurrentValue = false,
    Flag = "Magnet_Toggle",
    Callback = function(v)
        ms67 = v
    end,
})

local magnetDistanceSlider = CatchingTab:CreateSlider({
    Name = "Mag Distance",
    Range = {1, 120},
    Increment = 1,
    CurrentValue = 50,
    Flag = "Mag_Distance",
    Callback = function(v)
        dist = v
    end,
})

--// Script

local plr = game.Players.LocalPlayer
local char = plr.Character or plr.CharacterAdded:Wait()
local hrp = char:WaitForChild("HumanoidRootPart")

local og1 = CFrame.new()
local prvnt = false
local theonern = nil
local ifsm1gotfb = false

local function fbpos(fbtingy)
    local b4now = fbtingy:GetAttribute("oldp")
    local rn = fbtingy.Position
    fbtingy:SetAttribute("oldp", rn)
    return rn, b4now or rn
end

local function ifsm1gotit()
    if theonern and theonern.Parent then
        local parent = theonern.Parent
        if parent:IsA("Model") and game.Players:GetPlayerFromCharacter(parent) then
            return true
        end
        for _, player in next, game.Players:GetPlayers() do
            if player.Character and theonern:IsDescendantOf(player.Character) then
                return true
            end
        end
    end
    return false
end

local function udfr(fbtingy)
    theonern = fbtingy
    fbtingy:SetAttribute("oldp", fbtingy.Position)
end

workspace.DescendantAdded:Connect(function(d)
    if d.Name == "Football" and d:IsA("MeshPart") then
        udfr(d)
        ifsm1gotfb = false

        d.AncestryChanged:Connect(function()
            if d.Parent and d.Parent:IsA("Model") and game.Players:GetPlayerFromCharacter(d.Parent) then
                ifsm1gotfb = true
            elseif d.Parent == workspace or d.Parent == nil then
                ifsm1gotfb = false
            end
        end)
    end
end)

workspace.DescendantRemoving:Connect(function(d)
    if d == theonern then
        theonern = nil
        ifsm1gotfb = false
    end
end)

for _, d in next, workspace:GetDescendants() do
    if d.Name == "Football" and d:IsA("MeshPart") then
        udfr(d)
        if d.Parent and d.Parent:IsA("Model") and game.Players:GetPlayerFromCharacter(d.Parent) then
            ifsm1gotfb = true
        end
    end
end

local oind
oind = hookmetamethod(game, "__index", function(self, key)
    if ms67 and not checkcaller() and key == "CFrame" and self == hrp and prvnt then
        return og1
    end
    return oind(self, key)
end)

game:GetService("RunService").Heartbeat:Connect(function()
    if not ms67 or not theonern or not theonern.Parent then
        ifsm1gotfb = false
        return
    end

    ifsm1gotfb = ifsm1gotit()
    if ifsm1gotfb then
        prvnt = false
        return
    end

    local pos, old = fbpos(theonern)
    local d0 = (hrp.Position - pos).Magnitude
    if d0 > dist then return end

    local vel = pos - old
    local int1

    if vel.Magnitude > 0.1 then
        local predicted = pos + vel
        int1 = predicted + (vel.Unit * 13)
    else
        int1 = pos + Vector3.new(13, 0, 13)
    end

    int1 = Vector3.new(int1.X, math.max(int1.Y, pos.Y), int1.Z)

    og1 = hrp.CFrame
    prvnt = true
    hrp.CFrame = CFrame.new(int1)
    game:GetService("RunService").RenderStepped:Wait()
    hrp.CFrame = og1
    prvnt = false
end)

plr.CharacterAdded:Connect(function(c2)
    char = c2
    hrp = c2:WaitForChild("HumanoidRootPart")
    prvnt = false
end)

--// UI TOGGLE

local pullEnabled = false

local pullToggle = CatchingTab:CreateToggle({
    Name = "Pull Vector (Teleport)",
    CurrentValue = false,
    Flag = "Pull_Vector_Toggle",
    Callback = function(v)
        pullEnabled = v
    end,
})

--// PULL VECTOR (TELEPORT MODE)

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local Workspace = game:GetService("Workspace")

local player = Players.LocalPlayer

-- SETTINGS
local PULL_DISTANCE = 20
local SNAP_OFFSET = Vector3.new(0, 2, 0)

local function getClosestFootball()
    local char = player.Character
    if not char or not char:FindFirstChild("HumanoidRootPart") then return end

    local hrp = char.HumanoidRootPart
    local closest, dist = nil, math.huge

    for _, obj in pairs(Workspace:GetChildren()) do
        if obj:IsA("BasePart")
            and obj.Name:lower():find("football")
            and not obj.Anchored then

            local d = (hrp.Position - obj.Position).Magnitude
            if d < dist and d <= PULL_DISTANCE then
                closest = obj
                dist = d
            end
        end
    end

    return closest
end

RunService.Heartbeat:Connect(function()
    if not pullEnabled then return end

    local char = player.Character
    if not char or not char:FindFirstChild("HumanoidRootPart") then return end

    local ball = getClosestFootball()
    if not ball then return end

    local hrp = char.HumanoidRootPart

    -- TELEPORT BALL TO PLAYER
    ball.CFrame = hrp.CFrame + SNAP_OFFSET
end)

--// UI TOGGLE

local highlightEnabled = false
local highlighted = {}

local highlightToggle = CatchingTab:CreateToggle({
    Name = "Highlight Football",
    CurrentValue = false,
    Flag = "Football_Highlight_Toggle",
    Callback = function(v)
        highlightEnabled = v

        if not v then
            -- Remove all highlights when disabled
            for ball, _ in pairs(highlighted) do
                if ball and ball:FindFirstChildOfClass("Highlight") then
                    ball:FindFirstChildOfClass("Highlight"):Destroy()
                end
            end
            table.clear(highlighted)
        else
            scanForFootballs()
        end
    end,
})

--// SCRIPT

repeat task.wait() until game:IsLoaded()

local Workspace = game:GetService("Workspace")

-- Color + transparency settings
local highlightColor = Color3.fromRGB(255, 255, 0)
local fillTransparency = 0.5
local outlineTransparency = 0

local function highlightFootball(ball)
    if not highlightEnabled then return end
    if highlighted[ball] then return end

    local h = Instance.new("Highlight")
    h.FillColor = highlightColor
    h.FillTransparency = fillTransparency
    h.OutlineTransparency = outlineTransparency
    h.Adornee = ball
    h.Parent = ball

    highlighted[ball] = h
end

function scanForFootballs()
    if not highlightEnabled then return end

    for _, obj in ipairs(Workspace:GetDescendants()) do
        if obj:IsA("BasePart") and obj.Name == "Football" then
            highlightFootball(obj)
        end
    end
end

-- Detect new footballs instantly
Workspace.DescendantAdded:Connect(function(obj)
    if highlightEnabled and obj:IsA("BasePart") and obj.Name == "Football" then
        highlightFootball(obj)
    end
end)

local DefenseTab = Window:CreateTab("Defense", nil)
DefenseTab:CreateSection("Defense")

--// UI TOGGLE

local autoRushEnabled = false

local autoRushToggle = DefenseTab:CreateToggle({
    Name = "Auto QB Rush",
    CurrentValue = false,
    Flag = "Auto_Rush_Toggle",
    Callback = function(v)
        autoRushEnabled = v
        
        -- Stop movement instantly when turned off
        if not v and humanoid then
            humanoid:Move(Vector3.zero, false)
        end
    end,
})

--// SCRIPT

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
local hrp = character:WaitForChild("HumanoidRootPart")

local minPredict = 0.15
local maxPredict = 0.65
local maxDistance = 50

-- Only check real input-based movement
local function isPlayerMoving()
    return humanoid.MoveDirection.Magnitude > 0.05
end

local function findBallHolder()
    local football = workspace:FindFirstChild("Football", true)
    if not football then return nil end

    local parent = football.Parent
    if parent then
        if parent:FindFirstChild("Humanoid") then
            return Players:GetPlayerFromCharacter(parent)
        end
        if parent:IsA("Tool") and parent.Parent and parent.Parent:FindFirstChild("Humanoid") then
            return Players:GetPlayerFromCharacter(parent.Parent)
        end
    end

    return nil
end

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

    -- If user is moving manually, don't auto rush
    if isPlayerMoving() then
        return
    end

    local targetPlayer = findBallHolder()
    if not targetPlayer or targetPlayer == player then
        humanoid:Move(Vector3.zero, false)
        return
    end

    local targetChar = targetPlayer.Character
    local targetHRP = targetChar and targetChar:FindFirstChild("HumanoidRootPart")
    if not targetHRP then return end

    local distance = (targetHRP.Position - hrp.Position).Magnitude
    local t = math.clamp(distance / maxDistance, 0, 1)
    local dynamicPredict = minPredict + (maxPredict - minPredict) * t

    local predictedPos = targetHRP.Position + (targetHRP.Velocity * dynamicPredict)
    local direction = (predictedPos - hrp.Position)

    if direction.Magnitude < 1 then
        direction = (targetHRP.Position - hrp.Position)
    end

    humanoid:Move(direction.Unit, false)
end)

-- Handle respawn
player.CharacterAdded:Connect(function(char)
    character = char
    humanoid = char:WaitForChild("Humanoid")
    hrp = char:WaitForChild("HumanoidRootPart")
end)

--// UI TOGGLE

local forceTouchEnabled = false

local forceTouchToggle = DefenseTab:CreateToggle({
    Name = "Auto Tackle",
    CurrentValue = false,
    Flag = "Force_Touch_Toggle",
    Callback = function(v)
        forceTouchEnabled = v
    end,
})

--// SCRIPT

local RunService = game:GetService("RunService")
local Players = game:GetService("Players")
local player = Players.LocalPlayer

local function getBall()
    for _, obj in ipairs(workspace:GetDescendants()) do
        if obj.Name == "Football" and obj:IsA("BasePart") then
            return obj
        end
    end
end

local function getBallHolder(ball)
    local parent = ball.Parent
    if parent and parent:FindFirstChild("Humanoid") then
        return parent
    end
end

local function isMoving(character)
    local hrp = character:FindFirstChild("HumanoidRootPart")
    if not hrp then return false end
    return hrp.Velocity.Magnitude > 2
end

local function forceTouch(char1, char2)
    local hrp1 = char1:FindFirstChild("HumanoidRootPart")
    local hrp2 = char2:FindFirstChild("HumanoidRootPart")
    if not hrp1 or not hrp2 then return end

    -- Teleport slightly inside them to guarantee touch
    hrp1.CFrame = hrp2.CFrame * CFrame.new(0, 0, 1)
end

RunService.Heartbeat:Connect(function()
    if not forceTouchEnabled then return end

    local char = player.Character
    if not char then return end

    local ball = getBall()
    if not ball then return end

    local holder = getBallHolder(ball)
    if not holder then return end
    if holder == char then return end -- don't tackle yourself

    -- If holder is moving, wait 2 seconds before tackling
    if isMoving(holder) then
        task.wait(2)
    end

    -- Teleport and force touch
    forceTouch(char, holder)
end)

--// UI TOGGLE

local giantHeadEnabled = false

local giantHeadToggle = DefenseTab:CreateToggle({
    Name = "Tackle Reach",
    CurrentValue = false,
    Flag = "Giant_Heads_Toggle",
    Callback = function(v)
        giantHeadEnabled = v
    end,
})

--// SCRIPT

local Players = game:GetService("Players")

local function applyHeadSettings(char)
    if not giantHeadEnabled then return end

    local head = char:FindFirstChild("Head")
    if not head then return end

    head.Size = Vector3.new(10, 10, 10)
    head.Transparency = 1
    head.Massless = true

    local mesh = head:FindFirstChildOfClass("SpecialMesh")
    if mesh then
        mesh:Destroy()
    end
end

local function onCharacterAdded(character)
    task.wait(0.1)
    applyHeadSettings(character)
end

local function onPlayerAdded(player)
    player.CharacterAdded:Connect(onCharacterAdded)

    if player.Character then
        onCharacterAdded(player.Character)
    end
end

-- Apply to everyone in server
for _, player in pairs(Players:GetPlayers()) do
    onPlayerAdded(player)
end

Players.PlayerAdded:Connect(onPlayerAdded)

--// UI TOGGLE

local magnetEnabled = false

local magnetToggle = CatchingTab:CreateToggle({
    Name = "Auto Interception",
    CurrentValue = false,
    Flag = "Desync_Magnet_Toggle",
    Callback = function(v)
        magnetEnabled = v
    end,
})

--// SCRIPT

local dist = 120

local plr = game.Players.LocalPlayer
local char = plr.Character or plr.CharacterAdded:Wait()
local hrp = char:WaitForChild("HumanoidRootPart")

local theonern = nil
local ifsm1gotfb = false

local function fbpos(fbtingy)
    local old = fbtingy:GetAttribute("oldp")
    local now = fbtingy.Position
    fbtingy:SetAttribute("oldp", now)
    return now, old or now
end

local function ifsm1gotit()
    if theonern and theonern.Parent then
        local parent = theonern.Parent
        if parent:IsA("Model") and game.Players:GetPlayerFromCharacter(parent) then
            return true
        end
        for _, player in ipairs(game.Players:GetPlayers()) do
            if player.Character and theonern:IsDescendantOf(player.Character) then
                return true
            end
        end
    end
    return false
end

local function udfr(fbtingy)
    theonern = fbtingy
    fbtingy:SetAttribute("oldp", fbtingy.Position)
end

workspace.DescendantAdded:Connect(function(d)
    if d.Name == "Football" and d:IsA("MeshPart") then
        udfr(d)
        ifsm1gotfb = false

        d.AncestryChanged:Connect(function()
            if d.Parent and d.Parent:IsA("Model") and game.Players:GetPlayerFromCharacter(d.Parent) then
                ifsm1gotfb = true
            elseif d.Parent == workspace or d.Parent == nil then
                ifsm1gotfb = false
            end
        end)
    end
end)

workspace.DescendantRemoving:Connect(function(d)
    if d == theonern then
        theonern = nil
        ifsm1gotfb = false
    end
end)

for _, d in ipairs(workspace:GetDescendants()) do
    if d.Name == "Football" and d:IsA("MeshPart") then
        udfr(d)
        if d.Parent and d.Parent:IsA("Model") and game.Players:GetPlayerFromCharacter(d.Parent) then
            ifsm1gotfb = true
        end
    end
end

game:GetService("RunService").Heartbeat:Connect(function()
    if not magnetEnabled or not theonern or not theonern.Parent then
        ifsm1gotfb = false
        return
    end

    ifsm1gotfb = ifsm1gotit()
    if ifsm1gotfb then return end

    local pos, old = fbpos(theonern)
    local d0 = (hrp.Position - pos).Magnitude
    if d0 > dist then return end

    -- BALL VELOCITY
    local vel = pos - old
    local target

    if vel.Magnitude > 0.05 then
        -- TRUE PREDICTION:
        local predicted = pos + vel
        target = predicted + vel.Unit * 13
    else
        target = pos
    end

    -- Keep Y safe
    local safeY = math.max(target.Y, hrp.Position.Y)

    -- FINAL TELEPORT
    hrp.CFrame = CFrame.new(target.X, safeY, target.Z)
end)

plr.CharacterAdded:Connect(function(c2)
    char = c2
    hrp = c2:WaitForChild("HumanoidRootPart")
end)

local PhysicsTab = Window:CreateTab("Physics", nil)
PhysicsTab:CreateSection("Physics")

--// UI

local cframeSpeedEnabled = false
local SPEED = 2.2

local speedToggle = PhysicsTab:CreateToggle({
    Name = "CFrame WalkSpeed",
    CurrentValue = false,
    Flag = "CFrame_Speed_Toggle",
    Callback = function(v)
        cframeSpeedEnabled = v
    end,
})

local speedSlider = PhysicsTab:CreateSlider({
    Name = "CFrame Speed",
    Range = {1, 5},
    Increment = 0.1,
    CurrentValue = 2.2,
    Flag = "CFrame_Speed_Value",
    Callback = function(v)
        SPEED = v
    end,
})

--// SCRIPT

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

local player = Players.LocalPlayer

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

    local char = player.Character
    if not char then return end

    local hrp = char:FindFirstChild("HumanoidRootPart")
    local hum = char:FindFirstChildOfClass("Humanoid")
    if not hrp or not hum then return end

    local moveDir = hum.MoveDirection
    if moveDir.Magnitude > 0 then
        hrp.CFrame = hrp.CFrame + (moveDir * SPEED)
    end
end)

--// UI TOGGLE (Put in Defense or Physics tab)

local armHitboxEnabled = false

local armHitboxToggle = PhysicsTab:CreateToggle({
    Name = "Tall Arm Hitbox",
    CurrentValue = false,
    Flag = "Tall_Arm_Hitbox_Toggle",
    Callback = function(v)
        armHitboxEnabled = v

        local player = game.Players.LocalPlayer
        local character = player.Character
        if not character then return end

        local leftArm = character:FindFirstChild("Left Arm") or character:FindFirstChild("LeftHand")
        local rightArm = character:FindFirstChild("Right Arm") or character:FindFirstChild("RightHand")

        if v then
            -- ENABLE HITBOX
            if leftArm then
                leftArm.Size = Vector3.new(5, 50, 5)
                leftArm.Transparency = 1
                leftArm.Material = Enum.Material.Neon
                leftArm.CanCollide = false
            end

            if rightArm then
                rightArm.Size = Vector3.new(5, 50, 5)
                rightArm.Transparency = 1
                rightArm.Material = Enum.Material.Neon
                rightArm.CanCollide = false
            end
        else
            -- RESTORE NORMAL ARMS
            if leftArm then
                leftArm.Size = Vector3.new(1, 2, 1)
                leftArm.Transparency = 0
                leftArm.Material = Enum.Material.Plastic
            end

            if rightArm then
                rightArm.Size = Vector3.new(1, 2, 1)
                rightArm.Transparency = 0
                rightArm.Material = Enum.Material.Plastic
            end
        end
    end,
})

--// UI TOGGLE (Put in PhysicsTab)

local burstBoostEnabled = false

local burstBoostToggle = PhysicsTab:CreateToggle({
    Name = "Auto Speed Boost",
    CurrentValue = false,
    Flag = "Burst_Boost_Toggle",
    Callback = function(v)
        burstBoostEnabled = v
    end,
})

--// SCRIPT

repeat task.wait() until game:IsLoaded()

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
local hrp = character:WaitForChild("HumanoidRootPart")

player.CharacterAdded:Connect(function(char)
    character = char
    humanoid = char:WaitForChild("Humanoid")
    hrp = char:WaitForChild("HumanoidRootPart")
end)

-- SETTINGS
local boostStrength = 0.5
local boostDuration = 0.15
local boostCooldown = 4

local boosting = false
local lastBoost = 0

RunService.Heartbeat:Connect(function()
    if not burstBoostEnabled then return end
    if not humanoid or not hrp then return end

    local moveDir = humanoid.MoveDirection
    if moveDir.Magnitude == 0 then return end

    if tick() - lastBoost >= boostCooldown and not boosting then
        boosting = true
        lastBoost = tick()

        task.spawn(function()
            local startTime = tick()
            while tick() - startTime < boostDuration and burstBoostEnabled do
                hrp.CFrame = hrp.CFrame + (moveDir * boostStrength)
                RunService.Heartbeat:Wait()
            end
            boosting = false
        end)
    end
end)

--// UI (Physics Tab)

local angleEnhancerEnabled = false
local boostedJumpPower = 65

local angleToggle = PhysicsTab:CreateToggle({
    Name = "Angle Enhancer",
    CurrentValue = false,
    Flag = "Angle_Enhancer_Toggle",
    Callback = function(v)
        angleEnhancerEnabled = v
    end,
})

local jumpSlider = PhysicsTab:CreateSlider({
    Name = "Boosted Jump Power",
    Range = {50, 120},
    Increment = 1,
    CurrentValue = 65,
    Flag = "Angle_Enhancer_Power",
    Callback = function(v)
        boostedJumpPower = v
    end,
})

--// SCRIPT

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

local function setupCharacter(character)
    local humanoid = character:WaitForChild("Humanoid")
    local hrp = character:WaitForChild("HumanoidRootPart")

    humanoid.StateChanged:Connect(function(_, newState)
        if newState == Enum.HumanoidStateType.Jumping and angleEnhancerEnabled then
            task.wait(0.05)

            hrp.AssemblyLinearVelocity = Vector3.new(
                hrp.AssemblyLinearVelocity.X,
                boostedJumpPower,
                hrp.AssemblyLinearVelocity.Z
            )
        end
    end)
end

-- INIT
if player.Character then
    setupCharacter(player.Character)
end

player.CharacterAdded:Connect(setupCharacter)