--==================================================
-- SKY AURA HUB V3.1 | DAY / NIGHT / TIME EDITION
-- Roblox LocalScript
-- Tablet / Phone / PC
--==================================================

local Players = game:GetService("Players")
local Lighting = game:GetService("Lighting")
local TweenService = game:GetService("TweenService")
local UIS = game:GetService("UserInputService")
local RunService = game:GetService("RunService")

local player = Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui")

-- CLEANUP OLD GUI
local old = playerGui:FindFirstChild("SkyAuraV3")
if old then old:Destroy() end

-- COLORS
local PURPLE = Color3.fromRGB(170, 75, 255)
local BLUE = Color3.fromRGB(55, 155, 255)
local PINK = Color3.fromRGB(255, 70, 180)
local GREEN = Color3.fromRGB(60, 255, 165)
local GOLD = Color3.fromRGB(255, 190, 65)
local WHITE = Color3.fromRGB(245, 240, 255)
local DARK = Color3.fromRGB(13, 11, 25)
local PANEL = Color3.fromRGB(27, 21, 43)

--==================================================
-- GUI
--==================================================

local gui = Instance.new("ScreenGui")
gui.Name = "SkyAuraV3"
gui.ResetOnSpawn = false
gui.IgnoreGuiInset = true
gui.DisplayOrder = 100
gui.Parent = playerGui

local function make(class, props, parent)
    local obj = Instance.new(class)

    for k, v in pairs(props) do
        obj[k] = v
    end

    obj.Parent = parent
    return obj
end

local main = make("Frame", {
    Name = "Main",
    AnchorPoint = Vector2.new(0.5, 0.5),
    Position = UDim2.fromScale(0.5, 0.5),
    BackgroundColor3 = DARK,
    BorderSizePixel = 0
}, gui)

local scale = make("UIScale", {}, main)

local function resize()
    local camera = workspace.CurrentCamera
    if not camera then return end

    local v = camera.ViewportSize
    local width = math.clamp(v.X * 0.90, 300, 760)
    local height = math.clamp(width / 2.7, 190, 290)

    main.Size = UDim2.fromOffset(width, height)
    scale.Scale = math.min(1, v.X / 320, v.Y / 220)
end

resize()

if workspace.CurrentCamera then
    workspace.CurrentCamera:GetPropertyChangedSignal("ViewportSize"):Connect(resize)
end

make("UICorner", {
    CornerRadius = UDim.new(0, 15)
}, main)

local border = make("UIStroke", {
    Thickness = 2.5,
    Color = PURPLE
}, main)

-- ANIMATED NEON BORDER
task.spawn(function()
    local colors = {PURPLE, BLUE, PINK}
    local index = 1

    while gui.Parent do
        index = index % #colors + 1

        TweenService:Create(
            border,
            TweenInfo.new(1.7, Enum.EasingStyle.Sine),
            {Color = colors[index]}
        ):Play()

        task.wait(1.7)
    end
end)

local function makeButton(parent, text, color)
    local b = make("TextButton", {
        BackgroundColor3 = color or PANEL,
        Text = text,
        TextColor3 = WHITE,
        Font = Enum.Font.GothamBold,
        TextSize = 13,
        BorderSizePixel = 0,
        AutoButtonColor = true
    }, parent)

    make("UICorner", {
        CornerRadius = UDim.new(0, 8)
    }, b)

    make("UIStroke", {
        Color = color or PURPLE,
        Transparency = 0.45,
        Thickness = 1
    }, b)

    return b
end

--==================================================
-- HEADER
--==================================================

local header = make("Frame", {
    Size = UDim2.new(1, 0, 0, 42),
    BackgroundTransparency = 1
}, main)

make("TextLabel", {
    Position = UDim2.fromOffset(12, 0),
    Size = UDim2.new(0.7, 0, 1, 0),
    BackgroundTransparency = 1,
    Text = "✦ SKY AURA HUB V3.1",
    TextColor3 = WHITE,
    Font = Enum.Font.GothamBold,
    TextSize = 17,
    TextXAlignment = Enum.TextXAlignment.Left
}, header)

local close = makeButton(header, "✕", Color3.fromRGB(175, 40, 75))
close.Size = UDim2.fromOffset(32, 28)
close.Position = UDim2.new(1, -42, 0, 7)

local minimize = makeButton(header, "—", PANEL)
minimize.Size = UDim2.fromOffset(32, 28)
minimize.Position = UDim2.new(1, -80, 0, 7)

local reopen = makeButton(gui, "✦ OPEN SKY HUB", PURPLE)
reopen.Size = UDim2.fromOffset(155, 40)
reopen.Position = UDim2.new(0, 15, 0.5, 0)
reopen.AnchorPoint = Vector2.new(0, 0.5)
reopen.Visible = false

local function hideGUI()
    main.Visible = false
    reopen.Visible = true
end

close.MouseButton1Click:Connect(hideGUI)
minimize.MouseButton1Click:Connect(hideGUI)

reopen.MouseButton1Click:Connect(function()
    main.Visible = true
    reopen.Visible = false
    resize()
end)

-- DRAG: TOUCH + MOUSE
local dragging = false
local dragStart
local startPosition

header.InputBegan:Connect(function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1
    or input.UserInputType == Enum.UserInputType.Touch then
        dragging = true
        dragStart = input.Position
        startPosition = main.Position
    end
end)

UIS.InputChanged:Connect(function(input)
    if dragging and (
        input.UserInputType == Enum.UserInputType.MouseMovement
        or input.UserInputType == Enum.UserInputType.Touch
    ) then
        local delta = input.Position - dragStart

        main.Position = UDim2.new(
            startPosition.X.Scale,
            startPosition.X.Offset + delta.X,
            startPosition.Y.Scale,
            startPosition.Y.Offset + delta.Y
        )
    end
end)

UIS.InputEnded:Connect(function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1
    or input.UserInputType == Enum.UserInputType.Touch then
        dragging = false
    end
end)

--==================================================
-- TABS AND PAGES
--==================================================

local sidebar = make("Frame", {
    Position = UDim2.fromOffset(9, 48),
    Size = UDim2.new(0, 105, 1, -57),
    BackgroundTransparency = 1
}, main)

local content = make("Frame", {
    Position = UDim2.fromOffset(122, 48),
    Size = UDim2.new(1, -131, 1, -57),
    BackgroundColor3 = PANEL,
    BorderSizePixel = 0
}, main)

make("UICorner", {
    CornerRadius = UDim.new(0, 10)
}, content)

local pages = {}
local pageLayouts = {}

local function newPage(name)
    local page = make("ScrollingFrame", {
        Size = UDim2.new(1, -10, 1, -10),
        Position = UDim2.fromOffset(5, 5),
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        ScrollBarThickness = 3,
        ScrollBarImageColor3 = PURPLE,
        CanvasSize = UDim2.fromOffset(0, 0),
        Visible = false
    }, content)

    local layout = make("UIGridLayout", {
        CellSize = UDim2.fromOffset(145, 37),
        CellPadding = UDim2.fromOffset(7, 7),
        SortOrder = Enum.SortOrder.LayoutOrder
    }, page)

    local function updateGrid()
        local width = page.AbsoluteSize.X
        local columns = math.max(1, math.floor((width + 7) / 152))
        local cellWidth = (width - (columns + 1) * 7) / columns

        layout.CellSize = UDim2.fromOffset(cellWidth, 37)
    end

    page:GetPropertyChangedSignal("AbsoluteSize"):Connect(updateGrid)

    layout:GetPropertyChangedSignal("AbsoluteContentSize"):Connect(function()
        page.CanvasSize = UDim2.fromOffset(
            0, layout.AbsoluteContentSize.Y + 12
        )
    end)

    pages[name] = page
    pageLayouts[name] = layout

    task.defer(updateGrid)

    return page
end

local skyPage = newPage("SKY")
local auraPage = newPage("AURA")
local trailPage = newPage("TRAILS")
local settingsPage = newPage("SETTINGS")

local function addOption(page, text, color, callback)
    local b = makeButton(page, text, color)
    b.MouseButton1Click:Connect(callback)
    return b
end

local function showPage(name)
    for n, page in pairs(pages) do
        page.Visible = n == name
    end
end

local tabNames = {"SKY", "AURA", "TRAILS", "SETTINGS"}

for i, name in ipairs(tabNames) do
    local b = makeButton(sidebar, name, PURPLE)
    b.Size = UDim2.new(1, 0, 0, 34)
    b.Position = UDim2.fromOffset(0, (i - 1) * 39)

    b.MouseButton1Click:Connect(function()
        showPage(name)
    end)
end

--==================================================
-- SKY PRESETS
--==================================================

local presets = {
    -- DAY SHADERS

    ["Realistic Day"] = {
        13,
        Color3.fromRGB(145,155,170),
        Color3.fromRGB(175,190,205),
        Color3.fromRGB(175,210,245),
        Color3.fromRGB(190,220,255),
        0.12, 0.3
    },

    ["Bright Blue Sky"] = {
        12,
        Color3.fromRGB(175,190,205),
        Color3.fromRGB(190,210,225),
        Color3.fromRGB(100,175,255),
        Color3.fromRGB(160,210,255),
        0.08, 0.2
    },

    ["Golden Hour"] = {
        17,
        Color3.fromRGB(165,135,105),
        Color3.fromRGB(190,155,115),
        Color3.fromRGB(255,195,125),
        Color3.fromRGB(255,220,165),
        0.15, 0.7
    },

    ["Pink Clouds"] = {
        17.5,
        Color3.fromRGB(165,115,145),
        Color3.fromRGB(185,135,160),
        Color3.fromRGB(255,145,195),
        Color3.fromRGB(255,180,220),
        0.18, 0.7
    },

    ["Purple Sunset"] = {
        18,
        Color3.fromRGB(125,95,155),
        Color3.fromRGB(150,115,175),
        Color3.fromRGB(205,115,190),
        Color3.fromRGB(205,155,255),
        0.18, 0.8
    },

    ["Storm Clouds"] = {
        14,
        Color3.fromRGB(100,105,120),
        Color3.fromRGB(115,120,140),
        Color3.fromRGB(85,95,115),
        Color3.fromRGB(130,145,165),
        0.25, 1.5
    },

    ["Blue Dream"] = {
        15,
        Color3.fromRGB(120,145,185),
        Color3.fromRGB(140,165,205),
        Color3.fromRGB(105,175,235),
        Color3.fromRGB(160,205,255),
        0.15, 0.6
    },

    -- NIGHT SHADERS

    ["Bright Night"] = {
        0,
        Color3.fromRGB(105,110,145),
        Color3.fromRGB(115,125,160),
        Color3.fromRGB(45,65,110),
        Color3.fromRGB(135,155,220),
        0.12, 0.5
    },

    ["Moonlight"] = {
        1,
        Color3.fromRGB(100,115,155),
        Color3.fromRGB(110,130,175),
        Color3.fromRGB(55,75,125),
        Color3.fromRGB(155,180,235),
        0.14, 0.6
    },

    ["Purple Night"] = {
        23,
        Color3.fromRGB(105,80,145),
        Color3.fromRGB(120,95,165),
        Color3.fromRGB(75,45,130),
        Color3.fromRGB(175,125,255),
        0.16, 0.7
    },

    ["Neon Night"] = {
        22,
        Color3.fromRGB(90,105,145),
        Color3.fromRGB(105,120,165),
        Color3.fromRGB(40,65,115),
        Color3.fromRGB(100,180,255),
        0.10, 0.4
    },

    ["Dark Galaxy"] = {
        0,
        Color3.fromRGB(90,80,130),
        Color3.fromRGB(100,90,145),
        Color3.fromRGB(45,35,90),
        Color3.fromRGB(150,125,230),
        0.16, 0.7
    },

    ["Northern Lights"] = {
        1,
        Color3.fromRGB(90,125,140),
        Color3.fromRGB(100,140,155),
        Color3.fromRGB(35,110,105),
        Color3.fromRGB(125,220,190),
        0.18, 0.8
    }
}

local atmosphere = Lighting:FindFirstChild("SkyAuraAtmosphere")
if not atmosphere then
    atmosphere = Instance.new("Atmosphere")
    atmosphere.Name = "SkyAuraAtmosphere"
    atmosphere.Parent = Lighting
end

local bloom = Lighting:FindFirstChild("SkyAuraBloom")
if not bloom then
    bloom = Instance.new("BloomEffect")
    bloom.Name = "SkyAuraBloom"
    bloom.Parent = Lighting
end

local sunRays = Lighting:FindFirstChild("SkyAuraSunRays")
if not sunRays then
    sunRays = Instance.new("SunRaysEffect")
    sunRays.Name = "SkyAuraSunRays"
    sunRays.Parent = Lighting
end

local clouds = workspace.Terrain:FindFirstChildOfClass("Clouds")
if not clouds then
    clouds = Instance.new("Clouds")
    clouds.Parent = workspace.Terrain
end

-- TIME VARIABLES
local autoTime = false
local currentHour = 12
local timeLabel
local autoToggle

local function setSky(name)
    local p = presets[name]
    if not p then return end

    autoTime = false

    if autoToggle then
        autoToggle.Text = "AUTO TIME: OFF"
    end

    local isNight =
        name == "Bright Night"
        or name == "Moonlight"
        or name == "Purple Night"
        or name == "Neon Night"
        or name == "Dark Galaxy"
        or name == "Northern Lights"

    currentHour = p[1]

    Lighting.ClockTime = currentHour
    Lighting.Ambient = p[2]
    Lighting.OutdoorAmbient = p[3]
    Lighting.FogColor = p[4]
    Lighting.FogStart = 0
    Lighting.FogEnd = 100000

    -- BRIGHTNESS PROTECTION
    Lighting.Brightness = isNight and 2.5 or 2.2
    Lighting.ExposureCompensation = isNight and 0.25 or 0.1

    atmosphere.Color = p[5]
    atmosphere.Density = p[6]
    atmosphere.Haze = p[7]
    atmosphere.Glare = 0.1

    clouds.Color = p[4]
    clouds.Cover = 0.4
    clouds.Density = 0.55

    bloom.Intensity = isNight and 0.4 or 0.3
    bloom.Size = 24
    bloom.Threshold = 1.2

    sunRays.Intensity = isNight and 0.02 or 0.1
    sunRays.Spread = 0.8

    if timeLabel then
        timeLabel.Text = string.format(
            "TIME: %02d:00",
            math.floor(currentHour)
        )
    end
end

-- DAY SHADERS
addOption(skyPage, "☀ DAY SHADERS", GOLD, function() end)

local dayShaders = {
    "Realistic Day",
    "Bright Blue Sky",
    "Golden Hour",
    "Pink Clouds",
    "Purple Sunset",
    "Storm Clouds",
    "Blue Dream"
}

for _, name in ipairs(dayShaders) do
    addOption(skyPage, name, GOLD, function()
        setSky(name)
    end)
end

-- NIGHT SHADERS
addOption(skyPage, "🌙 NIGHT SHADERS", BLUE, function() end)

local nightShaders = {
    "Bright Night",
    "Moonlight",
    "Purple Night",
    "Neon Night",
    "Dark Galaxy",
    "Northern Lights"
}

for _, name in ipairs(nightShaders) do
    addOption(skyPage, name, BLUE, function()
        setSky(name)
    end)
end

--==================================================
-- TIME MODE
--==================================================

addOption(skyPage, "🕒 TIME MODE", PURPLE, function() end)

timeLabel = makeButton(skyPage, "TIME: 12:00", PURPLE)
timeLabel.Active = false
timeLabel.AutoButtonColor = false

local function updateTime()
    currentHour = currentHour % 24
    Lighting.ClockTime = currentHour

    timeLabel.Text = string.format(
        "TIME: %02d:00",
        math.floor(currentHour)
    )
end

addOption(skyPage, "TIME -1 HOUR", BLUE, function()
    autoTime = false
    autoToggle.Text = "AUTO TIME: OFF"

    currentHour = currentHour - 1
    updateTime()
end)

addOption(skyPage, "TIME +1 HOUR", BLUE, function()
    autoTime = false
    autoToggle.Text = "AUTO TIME: OFF"

    currentHour = currentHour + 1
    updateTime()
end)

addOption(skyPage, "🌅 MORNING", GOLD, function()
    autoTime = false
    autoToggle.Text = "AUTO TIME: OFF"

    currentHour = 7
    updateTime()
end)

addOption(skyPage, "☀ DAY", GOLD, function()
    autoTime = false
    autoToggle.Text = "AUTO TIME: OFF"

    currentHour = 12
    updateTime()
end)

addOption(skyPage, "🌇 EVENING", PINK, function()
    autoTime = false
    autoToggle.Text = "AUTO TIME: OFF"

    currentHour = 18
    updateTime()
end)

addOption(skyPage, "🌙 MIDNIGHT", BLUE, function()
    autoTime = false
    autoToggle.Text = "AUTO TIME: OFF"

    currentHour = 0
    updateTime()
end)

autoToggle = addOption(
    skyPage,
    "AUTO TIME: OFF",
    PURPLE,
    function()
        autoTime = not autoTime

        autoToggle.Text = autoTime
            and "AUTO TIME: ON"
            or "AUTO TIME: OFF"
    end
)

-- AUTOMATIC REAL-WORLD CLOCK
task.spawn(function()
    while gui.Parent do
        if autoTime then
            local realTime = os.date("*t")
            currentHour = realTime.hour
            updateTime()
        end

        task.wait(10)
    end
end)

--==================================================
-- AURA
--==================================================

local auraEnabled = false
local auraColor = PURPLE
local auraObjects = {}

local function clearAura()
    for _, obj in ipairs(auraObjects) do
        if obj and obj.Parent then
            obj:Destroy()
        end
    end

    table.clear(auraObjects)
end

local function applyAura()
    clearAura()

    if not auraEnabled then return end

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

    local highlight = Instance.new("Highlight")
    highlight.Name = "SkyAuraHighlight"
    highlight.Adornee = char
    highlight.FillColor = auraColor
    highlight.OutlineColor = auraColor
    highlight.FillTransparency = 0.65
    highlight.OutlineTransparency = 0
    highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    highlight.Parent = char

    table.insert(auraObjects, highlight)

    local root = char:FindFirstChild("HumanoidRootPart")
    if not root then return end

    local light = Instance.new("PointLight")
    light.Name = "SkyAuraLight"
    light.Color = auraColor
    light.Brightness = 2
    light.Range = 16
    light.Parent = root

    table.insert(auraObjects, light)

    local attachment = Instance.new("Attachment")
    attachment.Name = "AuraAttachment"
    attachment.Parent = root

    table.insert(auraObjects, attachment)

    local particles = Instance.new("ParticleEmitter")
    particles.Name = "AuraParticles"
    particles.Texture = "rbxasset://textures/particles/sparkles_main.dds"
    particles.Color = ColorSequence.new(auraColor)
    particles.LightEmission = 0.9
    particles.Lifetime = NumberRange.new(0.8, 1.6)
    particles.Rate = 18
    particles.Speed = NumberRange.new(0.5, 1.8)
    particles.SpreadAngle = Vector2.new(180, 180)
    particles.Size = NumberSequence.new({
        NumberSequenceKeypoint.new(0, 0.2),
        NumberSequenceKeypoint.new(1, 0)
    })
    particles.Parent = attachment
end

local auraToggle

auraToggle = addOption(
    auraPage,
    "AURA: OFF",
    PURPLE,
    function()
        auraEnabled = not auraEnabled

        auraToggle.Text = auraEnabled
            and "AURA: ON"
            or "AURA: OFF"

        applyAura()
    end
)

local auraColors = {
    {"Purple", PURPLE},
    {"Blue", BLUE},
    {"Pink", PINK},
    {"Green", GREEN},
    {"Gold", GOLD},
    {"White", WHITE}
}

for _, item in ipairs(auraColors) do
    addOption(auraPage, item[1], item[2], function()
        auraColor = item[2]

        if auraEnabled then
            applyAura()
        end
    end)
end

--==================================================
-- TRAILS
--==================================================

local footEnabled = false
local simpleEnabled = false
local rainbowEnabled = false
local trailColor = BLUE
local trailObjects = {}

local function clearTrails()
    for _, obj in ipairs(trailObjects) do
        if obj and obj.Parent then
            obj:Destroy()
        end
    end

    table.clear(trailObjects)
end

local function makeTrail(part, color)
    if not part or not part:IsA("BasePart") then
        return
    end

    local a0 = Instance.new("Attachment")
    a0.Position = Vector3.new(0, 0.1, 0.12)
    a0.Parent = part

    local a1 = Instance.new("Attachment")
    a1.Position = Vector3.new(0, -0.1, 0.12)
    a1.Parent = part

    local tr = Instance.new("Trail")
    tr.Attachment0 = a0
    tr.Attachment1 = a1
    tr.Lifetime = 0.65
    tr.MinLength = 0.05
    tr.FaceCamera = true
    tr.LightEmission = 0.9
    tr.Color = ColorSequence.new(color)

    tr.Transparency = NumberSequence.new({
        NumberSequenceKeypoint.new(0, 0.1),
        NumberSequenceKeypoint.new(1, 1)
    })

    tr.WidthScale = NumberSequence.new({
        NumberSequenceKeypoint.new(0, 0.8),
        NumberSequenceKeypoint.new(1, 0)
    })

    tr.Parent = part

    table.insert(trailObjects, a0)
    table.insert(trailObjects, a1)
    table.insert(trailObjects, tr)
end

local function refreshTrails()
    clearTrails()

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

    if footEnabled then
        for _, name in ipairs({
            "LeftFoot",
            "RightFoot",
            "Left Leg",
            "Right Leg"
        }) do
            makeTrail(char:FindFirstChild(name), trailColor)
        end
    end

    if simpleEnabled then
        for _, name in ipairs({
            "LeftHand",
            "RightHand",
            "Left Arm",
            "Right Arm"
        }) do
            makeTrail(char:FindFirstChild(name), trailColor)
        end
    end
end

local footToggle
local simpleToggle
local rainbowToggle

footToggle = addOption(
    trailPage,
    "FOOT TRAILS: OFF",
    PURPLE,
    function()
        footEnabled = not footEnabled

        footToggle.Text = footEnabled
            and "FOOT TRAILS: ON"
            or "FOOT TRAILS: OFF"

        refreshTrails()
    end
)

simpleToggle = addOption(
    trailPage,
    "SIMPLE TRAILS: OFF",
    BLUE,
    function()
        simpleEnabled = not simpleEnabled

        simpleToggle.Text = simpleEnabled
            and "SIMPLE TRAILS: ON"
            or "SIMPLE TRAILS: OFF"

        refreshTrails()
    end
)

rainbowToggle = addOption(
    trailPage,
    "RAINBOW: OFF",
    PINK,
    function()
        rainbowEnabled = not rainbowEnabled

        rainbowToggle.Text = rainbowEnabled
            and "RAINBOW: ON"
            or "RAINBOW: OFF"
    end
)

local trailColors = {
    {"Blue", BLUE},
    {"Purple", PURPLE},
    {"Pink", PINK},
    {"Green", GREEN},
    {"Gold", GOLD},
    {"White", WHITE}
}

for _, item in ipairs(trailColors) do
    addOption(trailPage, item[1], item[2], function()
        trailColor = item[2]
        refreshTrails()
    end)
end

-- RAINBOW ANIMATION
RunService.Heartbeat:Connect(function()
    if not rainbowEnabled then return end

    local color = Color3.fromHSV(
        (os.clock() * 0.15) % 1,
        1,
        1
    )

    for _, obj in ipairs(trailObjects) do
        if obj and obj.Parent and obj:IsA("Trail") then
            obj.Color = ColorSequence.new(color)
        end
    end
end)

--==================================================
-- SETTINGS
--==================================================

addOption(
    settingsPage,
    "SKY AURA HUB V3.1",
    PURPLE,
    function() end
)

addOption(
    settingsPage,
    "Tablet / Phone / PC",
    BLUE,
    function() end
)

addOption(settingsPage, "RESET SKY", PANEL, function()
    setSky("Realistic Day")
end)

addOption(settingsPage, "RESET AURA", PANEL, function()
    auraEnabled = false
    auraToggle.Text = "AURA: OFF"
    clearAura()
end)

addOption(settingsPage, "RESET TRAILS", PANEL, function()
    footEnabled = false
    simpleEnabled = false
    rainbowEnabled = false

    footToggle.Text = "FOOT TRAILS: OFF"
    simpleToggle.Text = "SIMPLE TRAILS: OFF"
    rainbowToggle.Text = "RAINBOW: OFF"

    clearTrails()
end)

addOption(settingsPage, "RESET ALL", Color3.fromRGB(175, 40, 75), function()
    setSky("Realistic Day")

    auraEnabled = false
    auraToggle.Text = "AURA: OFF"
    clearAura()

    footEnabled = false
    simpleEnabled = false
    rainbowEnabled = false

    footToggle.Text = "FOOT TRAILS: OFF"
    simpleToggle.Text = "SIMPLE TRAILS: OFF"
    rainbowToggle.Text = "RAINBOW: OFF"

    clearTrails()
end)

--==================================================
-- CHARACTER RESPAWN
--==================================================

player.CharacterAdded:Connect(function()
    task.wait(1)

    if auraEnabled then
        applyAura()
    end

    if footEnabled or simpleEnabled then
        refreshTrails()
    end
end)

--==================================================
-- START
--==================================================

showPage("SKY")
setSky("Realistic Day")

TweenService:Create(
    main,
    TweenInfo.new(0.4, Enum.EasingStyle.Back),
    {BackgroundTransparency = 0}
):Play()

print("SKY AURA HUB V3.1 loaded!")