--[[
	Flag Football Combined Hub (Receiver + QB Aimbot)
	Theme: Ocean | Includes Mobile Support
]]
local Rayfield = loadstring(game:HttpGet('https://sirius.menu/rayfield'))()

-- Services
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local VirtualInputManager = game:GetService("VirtualInputManager")
local StarterGui = game:GetService("StarterGui")
local CoreGui = game:GetService("CoreGui")

local LocalPlayer = Players.LocalPlayer
local Camera = workspace.CurrentCamera
local Gravity = workspace.Gravity

-------------------------------------------------------------------------
-- RECEIVER / MAGS VARIABLES
-------------------------------------------------------------------------
local REACH_DISTANCE = 15 
local THICKNESS_MULTIPLIER = 20 
local Y_OFFSET = 2
local isEnabledMags = false
local showRadiusBubble = false
local bubbleRadius = 15
local fakeArms = {}

-------------------------------------------------------------------------
-- QB AIMBOT VARIABLES
-------------------------------------------------------------------------
local DevSettings = {
    TargetingEnabled = true,
    TeammateOnly = true,
    CameraLockEnabled = false,
    TargetRange = 250,
    ThrowPower = 85,
    LeadMultiplier = 1.0,
    AssistMode = "Precision", 
    ShowTrajectory = true,
    ShowDebug = true,
    TrajectoryColor = Color3.fromRGB(0, 255, 128)
}

local currentTarget = nil
local manuallyLockedTarget = nil
local isThrowing = false

-------------------------------------------------------------------------
-- UI & VISUALS SETUP
-------------------------------------------------------------------------
local function notify(title, text)
    StarterGui:SetCore("SendNotification", { Title = title, Text = text, Duration = 2 })
end

-- Radius Bubble
local visualBubble = Instance.new("Part")
visualBubble.Name = "BallRadiusBubble"
visualBubble.Shape = Enum.PartType.Ball
visualBubble.Material = Enum.Material.ForceField
visualBubble.Color = Color3.fromRGB(255, 50, 50)
visualBubble.Anchored = true
visualBubble.CanCollide = false
visualBubble.Massless = true
visualBubble.CastShadow = false

-- Debug UI
local DebugScreenGui = Instance.new("ScreenGui")
DebugScreenGui.Name = "QBDebugUI"
local success = pcall(function() DebugScreenGui.Parent = CoreGui end)
if not success then DebugScreenGui.Parent = LocalPlayer:WaitForChild("PlayerGui") end

local DebugText = Instance.new("TextLabel", DebugScreenGui)
DebugText.Size = UDim2.new(0, 320, 0, 180)
DebugText.Position = UDim2.new(0, 10, 0.5, 0)
DebugText.BackgroundTransparency = 0.5
DebugText.BackgroundColor3 = Color3.new(0, 0, 0)
DebugText.TextColor3 = Color3.new(1, 1, 1)
DebugText.TextXAlignment = Enum.TextXAlignment.Left
DebugText.TextYAlignment = Enum.TextYAlignment.Top
DebugText.Font = Enum.Font.Code
DebugText.TextSize = 14
DebugText.Visible = DevSettings.ShowDebug

-- Trajectory System
local TrajectoryFolder = Instance.new("Folder", workspace)
TrajectoryFolder.Name = "QB_Trajectory"
local trajectoryLines = {}
local maxSegments = 40 

for i = 1, maxSegments do
    local line = Instance.new("Part")
    line.Anchored = true
    line.CanCollide = false
    line.Material = Enum.Material.Neon
    line.Color = DevSettings.TrajectoryColor
    line.Transparency = 1 
    line.Parent = TrajectoryFolder
    table.insert(trajectoryLines, line)
end

local CatchMarker = Instance.new("Part")
CatchMarker.Shape = Enum.PartType.Ball
CatchMarker.Size = Vector3.new(1.2, 1.2, 1.2)
CatchMarker.Material = Enum.Material.Neon
CatchMarker.Color = Color3.fromRGB(255, 50, 50)
CatchMarker.Anchored = true
CatchMarker.CanCollide = false
CatchMarker.Transparency = 1
CatchMarker.Parent = TrajectoryFolder

-------------------------------------------------------------------------
-- MOBILE SUPPORT HUD
-------------------------------------------------------------------------
local MobileGui = Instance.new("ScreenGui")
MobileGui.Name = "MobileSupportHUD"
MobileGui.Parent = success and CoreGui or LocalPlayer:WaitForChild("PlayerGui")
MobileGui.ResetOnSpawn = false

local ButtonContainer = Instance.new("Frame", MobileGui)
ButtonContainer.Size = UDim2.new(0, 60, 0, 200)
ButtonContainer.Position = UDim2.new(1, -70, 0.5, -100) -- Right side of screen
ButtonContainer.BackgroundTransparency = 1

local UIListLayout = Instance.new("UIListLayout", ButtonContainer)
UIListLayout.Padding = UDim.new(0, 10)
UIListLayout.SortOrder = Enum.SortOrder.LayoutOrder

local function createMobileButton(name, text, layoutOrder)
    local btn = Instance.new("TextButton", ButtonContainer)
    btn.Name = name
    btn.Size = UDim2.new(1, 0, 0, 55)
    btn.BackgroundColor3 = Color3.fromRGB(25, 100, 150)
    btn.BackgroundTransparency = 0.2
    btn.Font = Enum.Font.SourceSansBold
    btn.Text = text
    btn.TextColor3 = Color3.new(1, 1, 1)
    btn.TextSize = 14
    btn.TextWrapped = true
    btn.LayoutOrder = layoutOrder
    
    local corner = Instance.new("UICorner", btn)
    corner.CornerRadius = UDim.new(0, 8)
    
    return btn
end

local btnToggleUI = createMobileButton("ToggleUI", "Menu\n(Show/Hide)", 1)
local btnTarget = createMobileButton("CycleTarget", "Target\n(T)", 2)
local btnThrow = createMobileButton("AutoThrow", "Throw\n(G)", 3)

btnToggleUI.MouseButton1Click:Connect(function()
    VirtualInputManager:SendKeyEvent(true, Enum.KeyCode.RightControl, false, game)
    task.wait(0.05)
    VirtualInputManager:SendKeyEvent(false, Enum.KeyCode.RightControl, false, game)
end)

-------------------------------------------------------------------------
-- RECEIVER LOGIC
-------------------------------------------------------------------------
local function createFakeArms()
    local character = LocalPlayer.Character
    if not character then return end
    
    local rightSource = character:FindFirstChild("Right Arm") or character:FindFirstChild("RightHand")
    local leftSource = character:FindFirstChild("Left Arm") or character:FindFirstChild("LeftHand")
    if not rightSource or not leftSource then return end

    local rClone = Instance.new("Part")
    rClone.Name = "VisualRightArm"
    rClone.Size = Vector3.new(rightSource.Size.X * THICKNESS_MULTIPLIER, REACH_DISTANCE, rightSource.Size.Z * THICKNESS_MULTIPLIER)
    rClone.Transparency = 1 
    rClone.CanCollide = false
    rClone.Massless = true
    rClone.Anchored = true
    rClone.Parent = character

    local lClone = Instance.new("Part")
    lClone.Name = "VisualLeftArm"
    lClone.Size = Vector3.new(leftSource.Size.X * THICKNESS_MULTIPLIER, REACH_DISTANCE, leftSource.Size.Z * THICKNESS_MULTIPLIER)
    lClone.Transparency = 1 
    lClone.CanCollide = false
    lClone.Massless = true
    lClone.Anchored = true
    lClone.Parent = character

    fakeArms = {Right = rClone, Left = lClone}
end

local function removeFakeArms()
    if fakeArms.Right then fakeArms.Right:Destroy() end
    if fakeArms.Left then fakeArms.Left:Destroy() end
    fakeArms = {}
end

local function refreshArms()
    removeFakeArms()
    if isEnabledMags then createFakeArms() end
end

-------------------------------------------------------------------------
-- QB LOGIC
-------------------------------------------------------------------------
local function CalculateFlightTime(startPos, targetPos, throwPower)
    local distance = (Vector3.new(targetPos.X, 0, targetPos.Z) - Vector3.new(startPos.X, 0, startPos.Z)).Magnitude
    return distance / throwPower
end

local function PredictInterception(qbPos, receiverPos, receiverVel, throwPower, leadMult)
    local estimatedTime = CalculateFlightTime(qbPos, receiverPos, throwPower)
    local predictedPos = receiverPos + (receiverVel * estimatedTime * leadMult)
    return predictedPos, estimatedTime
end

local function CalculateThrowVelocity(startPos, targetPos, timeToTarget)
    local displacement = targetPos - startPos
    local velocityXZ = Vector3.new(displacement.X, 0, displacement.Z) / timeToTarget
    local velocityY = (displacement.Y + 0.5 * Gravity * (timeToTarget ^ 2)) / timeToTarget
    return velocityXZ + Vector3.new(0, velocityY, 0)
end

local function GetValidTargets()
    if not DevSettings.TargetingEnabled then return {} end
    
    local validTargets = {}
    local screenCenter = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y / 2)
    local localChar = LocalPlayer.Character
    if not localChar or not localChar:FindFirstChild("HumanoidRootPart") then return {} end
    local qbPos = localChar.HumanoidRootPart.Position
    
    for _, player in pairs(Players:GetPlayers()) do
        if player == LocalPlayer then continue end
        if DevSettings.TeammateOnly and player.Team ~= LocalPlayer.Team then continue end
        
        local char = player.Character
        if char and char:FindFirstChild("HumanoidRootPart") and char.Humanoid.Health > 0 then
            local root = char.HumanoidRootPart
            local distFromQB = (root.Position - qbPos).Magnitude
            
            if distFromQB <= DevSettings.TargetRange then
                local screenPos, onScreen = Camera:WorldToViewportPoint(root.Position)
                if onScreen then
                    local distFromCenter = (Vector2.new(screenPos.X, screenPos.Y) - screenCenter).Magnitude
                    table.insert(validTargets, {Player = player, Dist = distFromCenter})
                end
            end
        end
    end
    
    table.sort(validTargets, function(a, b) return a.Dist < b.Dist end)
    local sortedPlayers = {}
    for _, data in ipairs(validTargets) do
        table.insert(sortedPlayers, data.Player)
    end
    
    return sortedPlayers
end

local function DrawTrajectory(startPos, velocity, flightTime, predictedPos)
    if not DevSettings.ShowTrajectory then
        for _, p in ipairs(trajectoryLines) do p.Transparency = 1 end
        CatchMarker.Transparency = 1
        return
    end

    local numSegments = math.clamp(math.floor(flightTime * 25), 8, maxSegments)
    local timeStep = flightTime / numSegments
    local lastPos = startPos
    
    for i = 1, maxSegments do
        local part = trajectoryLines[i]
        if i <= numSegments then
            local t = i * timeStep
            local nextPos = startPos + (velocity * t) + (Vector3.new(0, -0.5 * Gravity * t^2, 0))
            
            local distance = (nextPos - lastPos).Magnitude
            part.Size = Vector3.new(0.12, 0.12, distance)
            part.CFrame = CFrame.lookAt(lastPos, nextPos) * CFrame.new(0, 0, -distance / 2)
            part.Transparency = 0.1 + (0.5 * (i / numSegments))
            
            lastPos = nextPos
        else
            part.Transparency = 1
        end
    end

    CatchMarker.Position = predictedPos
    CatchMarker.Transparency = 0.3
end

local function ClearTrajectory()
    for _, p in ipairs(trajectoryLines) do p.Transparency = 1 end
    CatchMarker.Transparency = 1
end

local function GetAssistVelocity(qbRoot, recRoot)
    if not recRoot or DevSettings.AssistMode == "Off" then return nil end
    
    local targetPos = recRoot.Position
    local recVel = recRoot.AssemblyLinearVelocity
    local leadMult = DevSettings.LeadMultiplier
    
    if DevSettings.AssistMode == "Direction" then leadMult = 0 end
    
    local predictedPos, flightTime = PredictInterception(qbRoot.Position, targetPos, recVel, DevSettings.ThrowPower, leadMult)
    return CalculateThrowVelocity(qbRoot.Position, predictedPos, flightTime), flightTime, predictedPos
end

local function CycleTargetFunction()
    local validTargets = GetValidTargets()
    if #validTargets > 1 then
        local currentIndex = 1
        for i, target in ipairs(validTargets) do
            if target == manuallyLockedTarget then
                currentIndex = i
                break
            end
        end
        local nextIndex = currentIndex + 1
        if nextIndex > #validTargets then nextIndex = 1 end
        manuallyLockedTarget = validTargets[nextIndex]
    end
end
btnTarget.MouseButton1Click:Connect(CycleTargetFunction)

local function ExecuteThrow(isAutoThrow)
    if isThrowing then return end
    
    local char = LocalPlayer.Character
    if not char or not char:FindFirstChild("HumanoidRootPart") then return end
    local qbRoot = char.HumanoidRootPart
    
    local tool = char:FindFirstChildOfClass("Tool")
    if not tool then
        local backpack = LocalPlayer:FindFirstChild("Backpack")
        if backpack then
            local bpTool = backpack:FindFirstChildOfClass("Tool")
            if bpTool then char.Humanoid:EquipTool(bpTool) end
        end
    end
    
    local finalVelocity = nil
    local predictedPos = nil
    if currentTarget and currentTarget.Character then
        local recRoot = currentTarget.Character.HumanoidRootPart
        finalVelocity, _, predictedPos = GetAssistVelocity(qbRoot, recRoot)
    end

    if not finalVelocity or not predictedPos then return end

    isThrowing = true

    -- NEW: Snap Character rotation to face target
    local rootPos = qbRoot.Position
    local lookAtCFrame = CFrame.lookAt(rootPos, Vector3.new(predictedPos.X, rootPos.Y, predictedPos.Z))
    qbRoot.CFrame = lookAtCFrame

    local originalCFrame = Camera.CFrame
    local viewportSize = Camera.ViewportSize
    local centerX = viewportSize.X / 2
    local centerY = viewportSize.Y / 2

    if isAutoThrow then
        local timeToApex = finalVelocity.Y / Gravity
        if timeToApex < 0.1 then timeToApex = 0.1 end
        
        local apexPos = qbRoot.Position + (finalVelocity * timeToApex) - Vector3.new(0, 0.5 * Gravity * timeToApex^2, 0)
        
        Camera.CFrame = CFrame.lookAt(Camera.CFrame.Position, apexPos)
        task.wait(0.02)
        
        VirtualInputManager:SendMouseButtonEvent(centerX, centerY, 0, true, game, 1)
        task.wait(0.22) 
        VirtualInputManager:SendMouseButtonEvent(centerX, centerY, 0, false, game, 1)
    end

    task.spawn(function()
        local ballPart = nil
        for i = 1, 30 do
            task.wait(0.03) 
            for _, obj in ipairs(workspace:GetDescendants()) do
                if obj:IsA("BasePart") then
                    if not obj:IsDescendantOf(char) then
                        local nameLower = string.lower(obj.Name)
                        if (string.match(nameLower, "ball") or string.match(nameLower, "football") or string.match(nameLower, "pigskin")) and not obj.Anchored then
                            local dist = (obj.Position - qbRoot.Position).Magnitude
                            if dist < 30 then
                                ballPart = obj
                                break
                            end
                        end
                    end
                end
            end
            if ballPart then break end
        end

        if isAutoThrow then
            Camera.CFrame = originalCFrame
        end

        if ballPart then
            for _, v in pairs(ballPart:GetChildren()) do
                if v:IsA("BodyVelocity") or v:IsA("LinearVelocity") or v:IsA("VectorForce") or v:IsA("BodyForce") or v:IsA("BodyPosition") then
                    v:Destroy()
                end
            end

            local startTime = tick()
            local forceConnection
            forceConnection = RunService.Heartbeat:Connect(function()
                if tick() - startTime > 0.4 or not ballPart or not ballPart.Parent then
                    forceConnection:Disconnect()
                    isThrowing = false
                    return
                end
                ballPart.AssemblyLinearVelocity = finalVelocity
            end)
        else
            isThrowing = false
        end
    end)
end
btnThrow.MouseButton1Click:Connect(function() ExecuteThrow(true) end)

-------------------------------------------------------------------------
-- RUNSERVICE & INPUT LOOP
-------------------------------------------------------------------------
local updateThrottle = 0
RunService.RenderStepped:Connect(function(dt)
    -- RECEIVER MAGS 
    if isEnabledMags then
        local character = LocalPlayer.Character
        if character then
            local rightSource = character:FindFirstChild("Right Arm") or character:FindFirstChild("RightHand")
            local leftSource = character:FindFirstChild("Left Arm") or character:FindFirstChild("LeftHand")
            
            if rightSource and leftSource and fakeArms.Right and fakeArms.Left then
                fakeArms.Right.CFrame = rightSource.CFrame * CFrame.new(0, (-REACH_DISTANCE / 2) + Y_OFFSET, 0)
                fakeArms.Left.CFrame = leftSource.CFrame * CFrame.new(0, (-REACH_DISTANCE / 2) + Y_OFFSET, 0)
            end
        end
    end

    -- RECEIVER RADIUS BUBBLE
    if showRadiusBubble then
        local targetBall = nil
        for _, obj in ipairs(workspace:GetChildren()) do
            if obj:IsA("BasePart") and obj.Name == "Ball" then
                targetBall = obj
                break
            end
        end
        if targetBall then
            visualBubble.Size = Vector3.new(bubbleRadius * 2, bubbleRadius * 2, bubbleRadius * 2)
            visualBubble.CFrame = targetBall.CFrame
            if visualBubble.Parent ~= workspace then visualBubble.Parent = workspace end
        else
            if visualBubble.Parent then visualBubble.Parent = nil end
        end
    else
        if visualBubble.Parent then visualBubble.Parent = nil end
    end

    -- QB AIMBOT UPDATE
    updateThrottle = updateThrottle + dt
    if updateThrottle >= 0.04 then
        updateThrottle = 0
        local char = LocalPlayer.Character
        if not char or not char:FindFirstChild("HumanoidRootPart") then return end
        local qbRoot = char.HumanoidRootPart

        local validTargets = GetValidTargets()
        
        local isTargetStillValid = false
        if manuallyLockedTarget then
            for _, target in ipairs(validTargets) do
                if target == manuallyLockedTarget then
                    isTargetStillValid = true
                    break
                end
            end
        end
        
        if not isTargetStillValid then manuallyLockedTarget = validTargets[1] end
        currentTarget = manuallyLockedTarget
        
        if currentTarget and currentTarget.Character and DevSettings.AssistMode ~= "Off" then
            local recRoot = currentTarget.Character.HumanoidRootPart
            local requiredVelocity, flightTime, predictedPos = GetAssistVelocity(qbRoot, recRoot)
            
            if requiredVelocity then
                DrawTrajectory(qbRoot.Position, requiredVelocity, flightTime, predictedPos)
                
                if DevSettings.CameraLockEnabled and not isThrowing then
                    Camera.CFrame = CFrame.lookAt(Camera.CFrame.Position, recRoot.Position)
                end
                
                if DevSettings.ShowDebug then
                    DebugText.Text = string.format(
                        "[T] Target: %s\n[UI] Mode: %s\nDistance: %.1f\n[G] Auto-Throw\n[Click] Manual",
                        currentTarget.Name, DevSettings.AssistMode, (recRoot.Position - qbRoot.Position).Magnitude
                    )
                end
            end
        else
            ClearTrajectory()
            if DevSettings.ShowDebug then
                DebugText.Text = string.format("[T] Target: None\n[UI] Mode: %s\nWaiting for receiver...", DevSettings.AssistMode)
            end
        end
    end
end)

UserInputService.InputBegan:Connect(function(input, gameProcessed)
    if gameProcessed then return end
    
    -- Mags Input
    if isEnabledMags and (input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch) then
        local character = LocalPlayer.Character
        if not character then return end
        local rightSource = character:FindFirstChild("Right Arm") or character:FindFirstChild("RightHand")

        for _, obj in ipairs(workspace:GetChildren()) do
            if obj:IsA("BasePart") and obj.Name == "Ball" then
                if rightSource and (rightSource.Position - obj.Position).Magnitude <= REACH_DISTANCE + (THICKNESS_MULTIPLIER * 2) then
                    if firetouchinterest then
                        firetouchinterest(rightSource, obj, 0)
                        firetouchinterest(rightSource, obj, 1)
                    else
                        obj.CFrame = rightSource.CFrame
                    end
                end
            end
        end
    end

    -- QB Inputs
    if input.KeyCode == Enum.KeyCode.T then CycleTargetFunction() end
    if input.KeyCode == Enum.KeyCode.G then ExecuteThrow(true) end
end)

UserInputService.InputEnded:Connect(function(input, gameProcessed)
    if gameProcessed then return end
    if input.UserInputType == Enum.UserInputType.MouseButton1 then
        if not isThrowing then ExecuteThrow(false) end
    end
end)

-------------------------------------------------------------------------
-- RAYFIELD UI CONFIGURATION
-------------------------------------------------------------------------
local Window = Rayfield:CreateWindow({
   Name = "Flag Football Complete Hub",
   LoadingTitle = "Loading Scripts...",
   LoadingSubtitle = "by You",
   Theme = "Ocean",
   DisableRayfieldPrompts = false,
   ConfigurationSaving = { Enabled = false },
   KeySystem = false
})

-- RECEIVER TAB
local ReceiverTab = Window:CreateTab("Receiver", 4483362458)
ReceiverTab:CreateSection("Mags Settings")
ReceiverTab:CreateToggle({
   Name = "Enable Mags",
   CurrentValue = false,
   Flag = "MagsToggle",
   Callback = function(Value)
       isEnabledMags = Value
       refreshArms()
       notify("Flag Football", Value and "Mags ON" or "Mags OFF")
   end,
})
ReceiverTab:CreateSlider({
   Name = "Reach Distance",
   Range = {5, 50},
   Increment = 1,
   Suffix = "Studs",
   CurrentValue = 15,
   Flag = "ReachSlider",
   Callback = function(Value)
       REACH_DISTANCE = Value
       refreshArms()
   end,
})
ReceiverTab:CreateSlider({
   Name = "Thickness Multiplier",
   Range = {1, 50},
   Increment = 1,
   Suffix = "x",
   CurrentValue = 20,
   Flag = "ThickSlider",
   Callback = function(Value)
       THICKNESS_MULTIPLIER = Value
       refreshArms()
   end,
})

-- QUARTERBACK TAB
local QBTab = Window:CreateTab("Quarterback", 4483362458)
QBTab:CreateSection("Targeting")
QBTab:CreateToggle({
   Name = "Enable Targeting",
   CurrentValue = DevSettings.TargetingEnabled,
   Flag = "ToggleTargeting",
   Callback = function(Value) DevSettings.TargetingEnabled = Value end,
})
QBTab:CreateToggle({
   Name = "Teammates Only",
   CurrentValue = DevSettings.TeammateOnly,
   Flag = "ToggleTeam",
   Callback = function(Value) DevSettings.TeammateOnly = Value end,
})
QBTab:CreateToggle({
   Name = "Camera Lock on Target",
   CurrentValue = DevSettings.CameraLockEnabled,
   Flag = "ToggleCameraLock",
   Callback = function(Value) DevSettings.CameraLockEnabled = Value end,
})
QBTab:CreateSlider({
   Name = "Target Range",
   Range = {50, 500},
   Increment = 10,
   Suffix = "Studs",
   CurrentValue = DevSettings.TargetRange,
   Flag = "SliderRange",
   Callback = function(Value) DevSettings.TargetRange = Value end,
})
QBTab:CreateSection("Throw Settings")
QBTab:CreateDropdown({
   Name = "Assist Mode",
   Options = {"Precision", "Lead", "Direction", "Off"},
   CurrentOption = {"Precision"},
   MultipleOptions = false,
   Flag = "DropdownAssist",
   Callback = function(Options) DevSettings.AssistMode = Options[1] end,
})
QBTab:CreateSlider({
   Name = "Throw Power",
   Range = {40, 150},
   Increment = 1,
   Suffix = "Power",
   CurrentValue = DevSettings.ThrowPower,
   Flag = "SliderPower",
   Callback = function(Value) DevSettings.ThrowPower = Value end,
})
QBTab:CreateSlider({
   Name = "Lead Multiplier",
   Range = {0, 3},
   Increment = 0.1,
   Suffix = "x",
   CurrentValue = DevSettings.LeadMultiplier,
   Flag = "SliderLead",
   Callback = function(Value) DevSettings.LeadMultiplier = Value end,
})

-- VISUALS TAB
local VisualsTab = Window:CreateTab("Visuals", 4483362458)
VisualsTab:CreateSection("Ball Rendering")
VisualsTab:CreateToggle({
   Name = "Show Ball Radius Bubble",
   CurrentValue = false,
   Flag = "BubbleToggle",
   Callback = function(Value) showRadiusBubble = Value end,
})
VisualsTab:CreateSlider({
   Name = "Bubble Size (Radius)",
   Range = {1, 50},
   Increment = 1,
   Suffix = "Studs",
   CurrentValue = 15,
   Flag = "BubbleSlider",
   Callback = function(Value) bubbleRadius = Value end,
})
VisualsTab:CreateSection("QB Visuals")
VisualsTab:CreateToggle({
   Name = "Show Trajectory Arc",
   CurrentValue = DevSettings.ShowTrajectory,
   Flag = "ToggleArc",
   Callback = function(Value)
        DevSettings.ShowTrajectory = Value
        if not Value then ClearTrajectory() end
   end,
})
VisualsTab:CreateColorPicker({
    Name = "Arc Color",
    Color = DevSettings.TrajectoryColor,
    Flag = "ColorArc",
    Callback = function(Value)
        DevSettings.TrajectoryColor = Value
        for _, part in ipairs(trajectoryLines) do part.Color = Value end
    end
})
VisualsTab:CreateToggle({
   Name = "Show Debug Stats",
   CurrentValue = DevSettings.ShowDebug,
   Flag = "ToggleDebug",
   Callback = function(Value)
        DevSettings.ShowDebug = Value
        DebugText.Visible = Value
   end,
})

Rayfield:LoadConfiguration()