Viper.gg State of Anarchy 3.0

-- Load OrionLib
local OrionLib = loadstring(game:HttpGet("https://raw.githubusercontent.com/shlexware/Orion/main/source"))()

-- Create the GUI Window
local Window = OrionLib:MakeWindow({
    Name = "Viper.gg SOA",
    HidePremium = false,
    SaveConfig = true,
    ConfigFolder = "OrionTest"
})

-- Create Tabs
local MainTab = Window:MakeTab({Name = "Main", Icon = "rbxassetid://4483345998", PremiumOnly = false})
local VisualsTab = Window:MakeTab({Name = "Visuals", Icon = "rbxassetid://4483345998", PremiumOnly = false})
local PlayerTab = Window:MakeTab({Name = "Player", Icon = "rbxassetid://4483345998", PremiumOnly = false})
local SettingsTab = Window:MakeTab({Name = "Settings", Icon = "rbxassetid://4483345998", PremiumOnly = false})

-- Add Sections
local ESPSection = VisualsTab:AddSection({Name = "ESP"})
local HitboxSection = VisualsTab:AddSection({Name = "Hitbox Expander"})

-- Variables
local ESPEnabled = false
local ESPObjects = {}

-- Function to Create ESP for a Player
local function createESP(player)
    -- Make sure the player has a character
    local function setupCharacter(character)
        if not character:FindFirstChild("HumanoidRootPart") or not character:FindFirstChild("Humanoid") then
            -- Wait for essential parts to load
            character:WaitForChild("HumanoidRootPart")
            character:WaitForChild("Humanoid")
        end

        -- ESP Object
        local ESP = {}

        -- Box Outline
        ESP.Box = Drawing.new("Square")
        ESP.Box.Color = Color3.fromRGB(255, 0, 0) -- Red for enemies
        ESP.Box.Thickness = 2
        ESP.Box.Transparency = 1
        ESP.Box.Filled = false

        -- Player Name
        ESP.Name = Drawing.new("Text")
        ESP.Name.Text = player.Name
        ESP.Name.Color = Color3.fromRGB(255, 255, 255)
        ESP.Name.Size = 14
        ESP.Name.Outline = true

        -- Health Text
        ESP.Health = Drawing.new("Text")
        ESP.Health.Color = Color3.fromRGB(0, 255, 0) -- Green
        ESP.Health.Size = 12
        ESP.Health.Outline = true

        -- Distance Text
        ESP.Distance = Drawing.new("Text")
        ESP.Distance.Color = Color3.fromRGB(255, 255, 0) -- Yellow
        ESP.Distance.Size = 12
        ESP.Distance.Outline = true

        -- Add ESP to the table
        ESPObjects[player] = ESP

        -- Update ESP on RenderStepped
        local updateConnection
        updateConnection = game:GetService("RunService").RenderStepped:Connect(function()
            -- Remove ESP if the player is no longer valid
            if not ESPEnabled or not player.Character or not player.Character:FindFirstChild("HumanoidRootPart") or not player.Character:FindFirstChild("Humanoid") or player.Character.Humanoid.Health <= 0 then
                if ESPObjects[player] then
                    ESPObjects[player].Box:Remove()
                    ESPObjects[player].Name:Remove()
                    ESPObjects[player].Health:Remove()
                    ESPObjects[player].Distance:Remove()
                    ESPObjects[player] = nil
                end
                updateConnection:Disconnect() -- Disconnect the update loop
                return
            end

            -- Update ESP positions and visibility
            local rootPart = character:FindFirstChild("HumanoidRootPart")
            local humanoid = character:FindFirstChild("Humanoid")
            local screenPos, onScreen = workspace.CurrentCamera:WorldToViewportPoint(rootPart.Position)
            if onScreen then
                -- Update Box Position and Size
                local size = (workspace.CurrentCamera:WorldToViewportPoint(rootPart.Position + Vector3.new(3, 3, 0)) - workspace.CurrentCamera:WorldToViewportPoint(rootPart.Position - Vector3.new(3, 3, 0))).X
                ESP.Box.Size = Vector2.new(size, size * 2)
                ESP.Box.Position = Vector2.new(screenPos.X - size / 2, screenPos.Y - size)

                -- Update Text Positions with spacing
                ESP.Name.Position = Vector2.new(screenPos.X, screenPos.Y - size - 20) -- Name is at the top
                ESP.Health.Position = Vector2.new(screenPos.X, screenPos.Y - size - 5) -- Health is below Name
                ESP.Distance.Position = Vector2.new(screenPos.X, screenPos.Y + size + 5) -- Distance is below the Box

                -- Update Text Values
                ESP.Health.Text = "Health: " .. math.floor(humanoid.Health)
                ESP.Distance.Text = "Distance: " .. math.floor((rootPart.Position - game.Players.LocalPlayer.Character.HumanoidRootPart.Position).Magnitude) .. " studs"

                -- Show ESP
                ESP.Box.Visible = true
                ESP.Name.Visible = true
                ESP.Health.Visible = true
                ESP.Distance.Visible = true
            else
                -- Hide ESP
                ESP.Box.Visible = false
                ESP.Name.Visible = false
                ESP.Health.Visible = false
                ESP.Distance.Visible = false
            end
        end)
    end

    -- Handle case where player already has a character
    if player.Character then
        setupCharacter(player.Character)
    end

    -- Listen for the player's character being added
    player.CharacterAdded:Connect(setupCharacter)
end

-- Function to Clear ESP for All Players
local function clearESP()
    for _, esp in pairs(ESPObjects) do
        if esp.Box then esp.Box:Remove() end
        if esp.Name then esp.Name:Remove() end
        if esp.Health then esp.Health:Remove() end
        if esp.Distance then esp.Distance:Remove() end
    end
    ESPObjects = {}
end

-- Function to Toggle ESP
local function toggleESP(state)
    ESPEnabled = state
    if ESPEnabled then
        -- Create ESP for existing players
        for _, player in pairs(game:GetService("Players"):GetPlayers()) do
            if player ~= game.Players.LocalPlayer then
                createESP(player)
            end
        end

        -- Listen for new players
        game:GetService("Players").PlayerAdded:Connect(function(player)
            createESP(player)
        end)

        -- Handle players leaving
        game:GetService("Players").PlayerRemoving:Connect(function(player)
            if ESPObjects[player] then
                ESPObjects[player].Box:Remove()
                ESPObjects[player].Name:Remove()
                ESPObjects[player].Health:Remove()
                ESPObjects[player].Distance:Remove()
                ESPObjects[player] = nil
            end
        end)
    else
        clearESP()
    end
end

-- GUI Integration
ESPSection:AddToggle({
    Name = "Enable ESP",
    Default = false,
    Callback = function(state)
        toggleESP(state)
    end
})



-- Variables
local AimbotEnabled = false
local FOV = 100 -- Default FOV size
local Smoothness = 0.2 -- Default smoothness
local AimbotKey = Enum.UserInputType.MouseButton2 -- Default key (Right Mouse Button)
local HoldingKey = false -- Tracks whether the key is being held
local BulletSpeed = 500 -- Default bullet speed (studs/second), adjust as needed for the game
local FOVCircle

-- Function to Create FOV Circle
local function createFOVCircle()
    FOVCircle = Drawing.new("Circle")
    FOVCircle.Color = Color3.fromRGB(255, 255, 0) -- Yellow FOV Circle
    FOVCircle.Thickness = 2
    FOVCircle.Transparency = 1
    FOVCircle.Radius = FOV
    FOVCircle.Filled = false
    FOVCircle.Visible = false -- Start as hidden
end

createFOVCircle()

-- Function to Predict Target's Position
local function predictTargetPosition(target, distance)
    local velocity = target.Velocity or Vector3.zero -- Use target's velocity or default to zero
    local travelTime = distance / BulletSpeed -- Calculate bullet travel time
    return target.Position + (velocity * travelTime) -- Predicted position
end

-- Function to Find Closest Target
local function getClosestTarget()
    local closestTarget = nil
    local closestDistance = FOV
    local localPlayer = game.Players.LocalPlayer
    local camera = workspace.CurrentCamera

    for _, player in pairs(game:GetService("Players"):GetPlayers()) do
        if player ~= localPlayer and player.Character and player.Character:FindFirstChild("HumanoidRootPart") and player.Character:FindFirstChild("Humanoid") then
            local rootPart = player.Character.HumanoidRootPart
            local screenPos, onScreen = camera:WorldToViewportPoint(rootPart.Position)
            local mousePos = Vector2.new(camera.ViewportSize.X / 2, camera.ViewportSize.Y / 2) -- Center of screen
            local distance = (Vector2.new(screenPos.X, screenPos.Y) - mousePos).Magnitude

            if onScreen and distance < closestDistance and player.Character.Humanoid.Health > 0 then
                closestDistance = distance
                closestTarget = rootPart
            end
        end
    end

    return closestTarget, closestDistance
end

-- Smooth Aiming Function
local function smoothAim(target, predictedPosition)
    local camera = workspace.CurrentCamera
    local mousePos = Vector2.new(camera.ViewportSize.X / 2, camera.ViewportSize.Y / 2) -- Center of screen
    local targetScreenPos = camera:WorldToViewportPoint(predictedPosition)

    local aimPos = Vector2.new(targetScreenPos.X, targetScreenPos.Y)
    local newAimPos = mousePos:Lerp(aimPos, Smoothness)

    mousemoverel(newAimPos.X - mousePos.X, newAimPos.Y - mousePos.Y)
end

-- Aimbot Update Function
game:GetService("RunService").RenderStepped:Connect(function()
    if AimbotEnabled and HoldingKey then
        FOVCircle.Visible = true
        FOVCircle.Position = Vector2.new(workspace.CurrentCamera.ViewportSize.X / 2, workspace.CurrentCamera.ViewportSize.Y / 2)

        local target, distance = getClosestTarget()
        if target then
            local predictedPosition = predictTargetPosition(target, distance)
            smoothAim(target, predictedPosition)
        end
    else
        FOVCircle.Visible = false
    end
end)

-- Key Input Handling
game:GetService("UserInputService").InputBegan:Connect(function(input, gameProcessed)
    if input.UserInputType == AimbotKey and not gameProcessed then
        HoldingKey = true
    end
end)

game:GetService("UserInputService").InputEnded:Connect(function(input, gameProcessed)
    if input.UserInputType == AimbotKey and not gameProcessed then
        HoldingKey = false
    end
end)

-- GUI Integration
local AimbotSection = MainTab:AddSection({Name = "Aimbot"})

AimbotSection:AddToggle({
    Name = "Enable Aimbot",
    Default = false,
    Callback = function(state)
        AimbotEnabled = state
    end
})

AimbotSection:AddSlider({
    Name = "FOV Size",
    Min = 50,
    Max = 500,
    Default = 100,
    Color = Color3.fromRGB(255, 255, 0),
    Increment = 1,
    ValueName = "FOV",
    Callback = function(value)
        FOV = value
        FOVCircle.Radius = FOV
    end
})

AimbotSection:AddSlider({
    Name = "Smoothness",
    Min = 0.1,
    Max = 1,
    Default = 0.2,
    Color = Color3.fromRGB(255, 255, 255),
    Increment = 0.01,
    ValueName = "Smoothness",
    Callback = function(value)
        Smoothness = value
    end
})

AimbotSection:AddSlider({
    Name = "Bullet Speed",
    Min = 100,
    Max = 1000,
    Default = 500,
    Increment = 10,
    ValueName = "Speed",
    Callback = function(value)
        BulletSpeed = value
    end
})

AimbotSection:AddDropdown({
    Name = "Aimbot Key",
    Default = "Right Mouse Button",
    Options = {"Right Mouse Button", "Left Shift", "E", "Q"},
    Callback = function(selected)
        if selected == "Right Mouse Button" then
            AimbotKey = Enum.UserInputType.MouseButton2
        elseif selected == "Left Shift" then
            AimbotKey = Enum.KeyCode.LeftShift
        elseif selected == "E" then
            AimbotKey = Enum.KeyCode.E
        elseif selected == "Q" then
            AimbotKey = Enum.KeyCode.Q
        end
    end
})


-- Function to Enable Fly
local function enableFly()
    Character = game.Players.LocalPlayer.Character
    if not Character or not Character:FindFirstChild("HumanoidRootPart") then return end
    Humanoid = Character:FindFirstChild("Humanoid")

    -- Prevent character from falling
    Humanoid.PlatformStand = true

    -- Disable collisions
    for _, part in pairs(Character:GetDescendants()) do
        if part:IsA("BasePart") then
            part.CanCollide = false
        end
    end

    -- Create BodyGyro and BodyVelocity
    BodyGyro = Instance.new("BodyGyro")
    BodyGyro.P = 9e4
    BodyGyro.CFrame = Character.HumanoidRootPart.CFrame
    BodyGyro.MaxTorque = Vector3.new(9e9, 9e9, 9e9)
    BodyGyro.Parent = Character.HumanoidRootPart

    BodyVelocity = Instance.new("BodyVelocity")
    BodyVelocity.Velocity = Vector3.zero
    BodyVelocity.MaxForce = Vector3.new(9e9, 9e9, 9e9)
    BodyVelocity.Parent = Character.HumanoidRootPart

    FlyEnabled = true
end

-- Function to Disable Fly
local function disableFly()
    if not FlyEnabled then return end

    -- Restore character state
    if BodyGyro then BodyGyro:Destroy() end
    if BodyVelocity then BodyVelocity:Destroy() end
    if Humanoid then Humanoid.PlatformStand = false end

    -- Re-enable collisions
    for _, part in pairs(Character:GetDescendants()) do
        if part:IsA("BasePart") then
            part.CanCollide = true
        end
    end

    FlyEnabled = false
end

-- Handle Fly Movement
game:GetService("RunService").Stepped:Connect(function()
    if FlyEnabled and Character and Character:FindFirstChild("HumanoidRootPart") then
        local moveDirection = Vector3.zero
        local camera = workspace.CurrentCamera

        -- Move with W, A, S, D
        if game:GetService("UserInputService"):IsKeyDown(Enum.KeyCode.W) then
            moveDirection += camera.CFrame.LookVector
        end
        if game:GetService("UserInputService"):IsKeyDown(Enum.KeyCode.S) then
            moveDirection -= camera.CFrame.LookVector
        end
        if game:GetService("UserInputService"):IsKeyDown(Enum.KeyCode.A) then
            moveDirection -= camera.CFrame.RightVector
        end
        if game:GetService("UserInputService"):IsKeyDown(Enum.KeyCode.D) then
            moveDirection += camera.CFrame.RightVector
        end

        -- Elevate with Space and Shift
        if game:GetService("UserInputService"):IsKeyDown(Enum.KeyCode.Space) then
            moveDirection += Vector3.new(0, 1, 0)
        end
        if game:GetService("UserInputService"):IsKeyDown(Enum.KeyCode.LeftShift) then
            moveDirection -= Vector3.new(0, 1, 0)
        end

        -- Apply Movement
        if moveDirection.Magnitude > 0 then
            BodyGyro.CFrame = camera.CFrame
            BodyVelocity.Velocity = moveDirection.Unit * FlySpeed
        else
            BodyVelocity.Velocity = Vector3.zero
        end
    end
end)

-- GUI Integration
local MovementSection = PlayerTab:AddSection({Name = "Movement"})

-- Fly Toggle
MovementSection:AddToggle({
    Name = "Enable Fly",
    Default = false,
    Callback = function(state)
        if state then
            enableFly()
        else
            disableFly()
        end
    end
})

-- Fly Speed Slider
MovementSection:AddSlider({
    Name = "Fly Speed",
    Min = 10,
    Max = 200,
    Default = 50,
    Color = Color3.fromRGB(255, 255, 255),
    Increment = 1,
    ValueName = "Speed",
    Callback = function(value)
        FlySpeed = value
    end
})

-- Zoom Logic
local CameraKey = Enum.KeyCode.LeftControl -- Default zoom key
local ZoomLevel = 30 -- Default zoom level
local NormalZoom = 70 -- Default normal FOV
local IsZooming = false -- Tracks whether the zoom key is held

-- Function to Continuously Enforce Zoom
local function enforceZoom()
    while IsZooming do
        workspace.CurrentCamera.FieldOfView = ZoomLevel
        wait() -- Prevents freezing the game
    end
    workspace.CurrentCamera.FieldOfView = NormalZoom -- Reset FOV when zoom ends
end

-- Key Input Handling
game:GetService("UserInputService").InputBegan:Connect(function(input, gameProcessed)
    if input.KeyCode == CameraKey and not gameProcessed then
        IsZooming = true
        enforceZoom()
    end
end)

game:GetService("UserInputService").InputEnded:Connect(function(input, gameProcessed)
    if input.KeyCode == CameraKey and not gameProcessed then
        IsZooming = false
    end
end)

-- GUI Integration for Zoom Control
local CameraSection = SettingsTab:AddSection({Name = "Camera Control"})

CameraSection:AddDropdown({
    Name = "Zoom Key",
    Default = "Left Control",
    Options = {"Left Control", "Right Control", "Z", "X"},
    Callback = function(selected)
        if selected == "Left Control" then
            CameraKey = Enum.KeyCode.LeftControl
        elseif selected == "Right Control" then
            CameraKey = Enum.KeyCode.RightControl
        elseif selected == "Z" then
            CameraKey = Enum.KeyCode.Z
        elseif selected == "X" then
            CameraKey = Enum.KeyCode.X
        end
    end
})

CameraSection:AddSlider({
    Name = "Zoom Level",
    Min = 10,
    Max = 100,
    Default = 30,
    Color = Color3.fromRGB(255, 255, 255),
    Increment = 1,
    ValueName = "Zoom",
    Callback = function(value)
        ZoomLevel = value
    end
})

CameraSection:AddSlider({
    Name = "Normal Zoom",
    Min = 60,
    Max = 120,
    Default = 70,
    Color = Color3.fromRGB(255, 255, 255),
    Increment = 1,
    ValueName = "FOV",
    Callback = function(value)
        NormalZoom = value
    end
})

local TriggerbotEnabled = false
local Debounce = false -- Prevents spamming
local DebounceTime = 0.1 -- Time between clicks (in seconds)

-- Function to Check for Valid Target
local function isValidTarget(target)
    if not target or not target.Parent then return false end
    local character = target.Parent
    local humanoid = character:FindFirstChild("Humanoid")
    local rootPart = character:FindFirstChild("HumanoidRootPart")

    if humanoid and rootPart and humanoid.Health > 0 then
        local camera = workspace.CurrentCamera
        local screenPos, onScreen = camera:WorldToViewportPoint(rootPart.Position)
        return onScreen -- Ensure the target is visible on the screen
    end

    return false
end

-- Function to Trigger Fire
local function triggerFire()
    if Debounce then return end
    Debounce = true

    local mouse = game.Players.LocalPlayer:GetMouse()
    local target = mouse.Target

    if isValidTarget(target) then
        mouse1click() -- Simulates a left mouse button click
    end

    -- Debounce cooldown
    task.wait(DebounceTime)
    Debounce = false
end

-- Continuous Update for Triggerbot
game:GetService("RunService").RenderStepped:Connect(function()
    if TriggerbotEnabled then
        local mouse = game.Players.LocalPlayer:GetMouse()
        if mouse.Target and isValidTarget(mouse.Target) then
            triggerFire()
        end
    end
end)

-- GUI Integration for Triggerbot
local TriggerbotSection = MainTab:AddSection({Name = "Triggerbot"})

TriggerbotSection:AddToggle({
    Name = "Enable Triggerbot",
    Default = false,
    Callback = function(state)
        TriggerbotEnabled = state
    end
})

TriggerbotSection:AddSlider({
    Name = "Trigger Cooldown",
    Min = 0.05,
    Max = 1,
    Default = 0.1,
    Increment = 0.01,
    ValueName = "Seconds",
    Callback = function(value)
        DebounceTime = value
    end
})

-- Hitbox Expander Variables
local HitboxEnabled = false
local HitboxSizeMultiplier = Vector3.new(5, 5, 5) -- Default multiplier
local HitboxTransparency = 0.5 -- Default transparency
local OriginalSizes = {} -- Store original sizes

-- Function to Expand Hitboxes for a Player
local function expandHitboxes(player)
    if player.Character and player.Character:FindFirstChild("HumanoidRootPart") then
        for _, part in ipairs(player.Character:GetChildren()) do
            if part:IsA("BasePart") and part.Name ~= "HumanoidRootPart" then
                if not OriginalSizes[part] then
                    OriginalSizes[part] = part.Size -- Save original size
                end
                part.Size = OriginalSizes[part] * HitboxSizeMultiplier
                part.Transparency = HitboxTransparency
                part.CanCollide = false -- Optional: prevent collision issues
            end
        end
    end
end

-- Function to Restore Hitboxes for a Player
local function restoreHitboxes(player)
    if player.Character and player.Character:FindFirstChild("HumanoidRootPart") then
        for _, part in ipairs(player.Character:GetChildren()) do
            if part:IsA("BasePart") and part.Name ~= "HumanoidRootPart" then
                if OriginalSizes[part] then
                    part.Size = OriginalSizes[part]
                    part.Transparency = 0 -- Reset transparency
                    part.CanCollide = true
                end
            end
        end
    end
end

-- Function to Toggle Hitbox Expander for All Players
local function toggleHitboxExpander(state)
    HitboxEnabled = state
    if HitboxEnabled then
        for _, player in pairs(game.Players:GetPlayers()) do
            if player ~= game.Players.LocalPlayer then
                expandHitboxes(player)
            end
        end

        -- Listen for new players joining
        game.Players.PlayerAdded:Connect(function(player)
            player.CharacterAdded:Connect(function()
                expandHitboxes(player)
            end)
        end)
    else
        for _, player in pairs(game.Players:GetPlayers()) do
            if player ~= game.Players.LocalPlayer then
                restoreHitboxes(player)
            end
        end
    end
end

HitboxSection:AddToggle({
    Name = "Enable Hitbox Expander",
    Default = false,
    Callback = function(state)
        toggleHitboxExpander(state)
    end
})

HitboxSection:AddSlider({
    Name = "Hitbox Size Multiplier",
    Min = 1,
    Max = 10,
    Default = 5,
    Increment = 0.1,
    Callback = function(value)
        HitboxSizeMultiplier = Vector3.new(value, value, value)
        if HitboxEnabled then
            for _, player in pairs(game.Players:GetPlayers()) do
                if player ~= game.Players.LocalPlayer then
                    expandHitboxes(player)
                end
            end
        end
    end
})

HitboxSection:AddSlider({
    Name = "Hitbox Transparency",
    Min = 0,
    Max = 1,
    Default = 0.5,
    Increment = 0.1,
    Callback = function(value)
        HitboxTransparency = value
        if HitboxEnabled then
            for _, player in pairs(game.Players:GetPlayers()) do
                if player ~= game.Players.LocalPlayer and player.Character then
                    for _, part in ipairs(player.Character:GetChildren()) do
                        if part:IsA("BasePart") and part.Name ~= "HumanoidRootPart" then
                            part.Transparency = HitboxTransparency
                        end
                    end
                end
            end
        end
    end
})

--Chams
local ChamsEnabled = false
local Highlights = {} -- Store highlights for each player

-- Function to Add Chams to a Player
local function addChams(player)
    if player.Character and player.Character:FindFirstChild("HumanoidRootPart") then
        -- Check if the Highlight already exists
        if not Highlights[player] then
            local highlight = Instance.new("Highlight")
            highlight.FillColor = Color3.fromRGB(255, 0, 0) -- Default Red
            highlight.FillTransparency = 0.5 -- Semi-transparent fill
            highlight.OutlineColor = Color3.fromRGB(255, 255, 255) -- Default White
            highlight.OutlineTransparency = 0 -- Fully visible outline
            highlight.Adornee = player.Character -- Attach to player's character
            highlight.Parent = game:GetService("CoreGui") -- Parent it to CoreGui for visibility
            Highlights[player] = highlight
        end
    end
end

-- Function to Remove Chams from a Player
local function removeChams(player)
    if Highlights[player] then
        Highlights[player]:Destroy()
        Highlights[player] = nil
    end
end

-- Function to Toggle Chams for All Players
local function toggleChams(state)
    ChamsEnabled = state
    if ChamsEnabled then
        for _, player in pairs(game.Players:GetPlayers()) do
            if player ~= game.Players.LocalPlayer then
                addChams(player)
            end
        end

        -- Handle new players joining
        game.Players.PlayerAdded:Connect(function(player)
            addChams(player)
        end)

        -- Handle players leaving
        game.Players.PlayerRemoving:Connect(function(player)
            removeChams(player)
        end)
    else
        -- Disable Chams for all players
        for _, player in pairs(Highlights) do
            removeChams(player)
        end
    end
end

-- GUI Integration for Chams
local ChamsSection = VisualsTab:AddSection({Name = "Chams"})

ChamsSection:AddToggle({
    Name = "Enable Chams",
    Default = false,
    Callback = function(state)
        toggleChams(state)
    end
})

ChamsSection:AddColorPicker({
    Name = "Fill Color",
    Default = Color3.fromRGB(255, 0, 0),
    Callback = function(color)
        for _, highlight in pairs(Highlights) do
            highlight.FillColor = color
        end
    end
})

ChamsSection:AddColorPicker({
    Name = "Outline Color",
    Default = Color3.fromRGB(255, 255, 255),
    Callback = function(color)
        for _, highlight in pairs(Highlights) do
            highlight.OutlineColor = color
        end
    end
})

ChamsSection:AddSlider({
    Name = "Fill Transparency",
    Min = 0,
    Max = 1,
    Default = 0.5,
    Increment = 0.01,
    Callback = function(value)
        for _, highlight in pairs(Highlights) do
            highlight.FillTransparency = value
        end
    end
})

ChamsSection:AddSlider({
    Name = "Outline Transparency",
    Min = 0,
    Max = 1,
    Default = 0,
    Increment = 0.01,
    Callback = function(value)
        for _, highlight in pairs(Highlights) do
            highlight.OutlineTransparency = value
        end
    end
})