if game.PlaceId == 17625359962 then
    local OrionLib = loadstring(game:HttpGet("https://raw.githubusercontent.com/jensonhirst/Orion/c8db6d194077f39a806c645243d359187b9b4370/source"))()
    local Window = OrionLib:MakeWindow({Name = "ColdTeam X Rivals", HidePremium = false, SaveConfig = true, IntroEnabled = false})

    local Players = game:GetService("Players")
    local RunService = game:GetService("RunService")
    local UserInputService = game:GetService("UserInputService")
    local Lighting = game:GetService("Lighting")
    local TweenService = game:GetService("TweenService")
    local Debris = game:GetService("Debris")
    local LocalPlayer = Players.LocalPlayer
    local Camera = workspace.CurrentCamera

    local ChamsColor = Color3.fromRGB(255, 0, 0)
    local NameColor = Color3.fromRGB(255, 255, 255)
    local MaxDistance = 500
    local NameSize = 40

    local AimOn = false
    local AimFOV = 100
    local AimSmooth = 0.2
    local AimPart = "Head"
    local AimKey = Enum.UserInputType.MouseButton2
    local AimMaxRange = 1000
    local AimWallCheck = true

    local WeatherOn = false
    local CurrentWeather = "Rain"
    local WeatherObjects = {}
    local WeatherConnections = {}
    local WeatherThreads = {}

    local InfJumpOn = false
    local InfJumpConnection = nil

    local SpeedOn = false
    local SpeedValue = 60
    local SpeedConnection = nil

    local BoxOn = false
    local BoxColor = Color3.fromRGB(255, 0, 0)
    local HealthOn = false
    local BoxData = {}

    local function getRoot()
        local char = LocalPlayer.Character
        if not char then return nil end
        return char:FindFirstChild("HumanoidRootPart")
    end

    local function createPuddle(position)
        local puddle = Instance.new("Part")
        puddle.Name = "WeatherPuddle"
        puddle.Size = Vector3.new(math.random(5, 10), 0.05, math.random(5, 10))
        puddle.Position = position + Vector3.new(0, 0.02, 0)
        puddle.Transparency = 0.25
        puddle.Reflectance = 0.35
        puddle.Color = Color3.fromRGB(90, 110, 150)
        puddle.Material = Enum.Material.Glass
        puddle.Anchored = true
        puddle.CanCollide = false
        puddle.Parent = workspace

        task.spawn(function()
            for i = 1, 15 do
                if not puddle.Parent then return end
                puddle.Transparency = 0.25 + (i * 0.05)
                task.wait(0.3)
            end
            if puddle.Parent then
                puddle:Destroy()
            end
        end)
    end

    local function createLightning()
        if not WeatherOn then return end

        local originalBrightness = Lighting.Brightness
        local originalAmbient = Lighting.OutdoorAmbient
        local originalFogColor = Lighting.FogColor

        TweenService:Create(
            Lighting,
            TweenInfo.new(0.05, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
            {Brightness = 3, OutdoorAmbient = Color3.fromRGB(255, 255, 255), FogColor = Color3.fromRGB(255, 255, 255)}
        ):Play()

        task.delay(0.08, function()
            if not WeatherOn then return end
            TweenService:Create(
                Lighting,
                TweenInfo.new(0.1, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
                {Brightness = originalBrightness, OutdoorAmbient = originalAmbient, FogColor = originalFogColor}
            ):Play()
        end)

        task.delay(0.15, function()
            if not WeatherOn then return end
            TweenService:Create(
                Lighting,
                TweenInfo.new(0.05, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
                {Brightness = 2.5, OutdoorAmbient = Color3.fromRGB(240, 240, 255), FogColor = Color3.fromRGB(240, 240, 255)}
            ):Play()

            task.delay(0.4, function()
                if not WeatherOn then return end
                TweenService:Create(
                    Lighting,
                    TweenInfo.new(1, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut),
                    {Brightness = originalBrightness, OutdoorAmbient = originalAmbient, FogColor = originalFogColor}
                ):Play()
            end)
        end)

        local thunder = Instance.new("Sound")
        thunder.Name = "ThunderSound"
        thunder.SoundId = "rbxassetid://131237241"
        thunder.Volume = 1
        thunder.Parent = workspace
        thunder:Play()
        Debris:AddItem(thunder, 6)
    end

    local function createRainbowFlash()
        if not WeatherOn then return end

        local hue = math.random() * 360
        local color = Color3.fromHSV(hue / 360, 0.6, 1)

        local cc = Lighting:FindFirstChild("WeatherColor")
        if cc then
            local originalTint = cc.TintColor
            cc.TintColor = color

            task.delay(0.3, function()
                if cc.Parent then
                    TweenService:Create(
                        cc,
                        TweenInfo.new(1.5, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut),
                        {TintColor = originalTint}
                    ):Play()
                end
            end)
        end
    end

    local function applyLighting(preset)
        WeatherObjects.originalLighting = {
            Brightness = Lighting.Brightness,
            OutdoorAmbient = Lighting.OutdoorAmbient,
            FogColor = Lighting.FogColor,
            FogStart = Lighting.FogStart,
            FogEnd = Lighting.FogEnd,
            EnvironmentDiffuseScale = Lighting.EnvironmentDiffuseScale,
            EnvironmentSpecularScale = Lighting.EnvironmentSpecularScale
        }

        TweenService:Create(
            Lighting,
            TweenInfo.new(3, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut),
            preset
        ):Play()
    end

    local function createEffects(preset)
        local blur = Instance.new("BlurEffect")
        blur.Name = "WeatherBlur"
        blur.Size = 0
        blur.Parent = Lighting
        TweenService:Create(
            blur,
            TweenInfo.new(2, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
            {Size = preset.blur}
        ):Play()

        local cc = Instance.new("ColorCorrectionEffect")
        cc.Name = "WeatherColor"
        cc.Brightness = 0
        cc.Contrast = 0
        cc.Saturation = 0
        cc.TintColor = Color3.fromRGB(255, 255, 255)
        cc.Parent = Lighting
        TweenService:Create(
            cc,
            TweenInfo.new(2, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
            {
                Contrast = preset.contrast,
                Saturation = preset.saturation,
                TintColor = preset.tint
            }
        ):Play()

        local bloom = Instance.new("BloomEffect")
        bloom.Name = "WeatherBloom"
        bloom.Intensity = 0
        bloom.Size = 10
        bloom.Threshold = 0.7
        bloom.Parent = Lighting
        TweenService:Create(
            bloom,
            TweenInfo.new(2, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
            {Intensity = preset.bloom}
        ):Play()
    end

    local function startRain()
        if WeatherOn then return end
        WeatherOn = true

        WeatherObjects.parts = {}
        WeatherObjects.winds = {}

        for i = 1, 6 do
            local area = Instance.new("Part")
            area.Name = "WeatherArea" .. i
            area.Size = Vector3.new(200, 120, 200)
            area.Transparency = 1
            area.CanCollide = false
            area.Anchored = true

            local root = getRoot()
            if root then
                area.Position = root.Position + Vector3.new(
                    math.random(-100, 100), 40, math.random(-100, 100)
                )
            else
                area.Position = Vector3.new(0, 40, 0)
            end
            area.Parent = workspace

            local drops = Instance.new("ParticleEmitter")
            drops.Texture = "rbxassetid://241876428"
            drops.Rate = 300
            drops.Lifetime = NumberRange.new(1, 1.5)
            drops.Speed = NumberRange.new(30, 50)
            drops.Rotation = NumberRange.new(0, 360)
            drops.RotSpeed = NumberRange.new(0, 0)
            drops.VelocitySpread = 30
            drops.Acceleration = Vector3.new(0, -80, 0)
            drops.LightEmission = 0.3
            drops.LightInfluence = 0.7

            drops.Size = NumberSequence.new({
                NumberSequenceKeypoint.new(0, 0.2),
                NumberSequenceKeypoint.new(0.5, 0.35),
                NumberSequenceKeypoint.new(1, 0.2)
            })

            drops.Transparency = NumberSequence.new({
                NumberSequenceKeypoint.new(0, 0.2),
                NumberSequenceKeypoint.new(0.5, 0.1),
                NumberSequenceKeypoint.new(1, 0.5)
            })

            drops.Color = ColorSequence.new({
                ColorSequenceKeypoint.new(0, Color3.fromRGB(180, 200, 230)),
                ColorSequenceKeypoint.new(0.5, Color3.fromRGB(210, 225, 245)),
                ColorSequenceKeypoint.new(1, Color3.fromRGB(180, 200, 230))
            })

            drops.Parent = area

            local breeze = Instance.new("VectorForce")
            breeze.Name = "WeatherWind"
            breeze.Force = Vector3.new(math.random(-15, 15), -1, math.random(-15, 15))
            breeze.RelativeTo = Enum.ActuatorRelativeTo.World
            breeze.Attachment0 = Instance.new("Attachment", area)
            breeze.Parent = area

            table.insert(WeatherObjects.parts, area)
            table.insert(WeatherObjects.winds, breeze)
        end

        applyLighting({
            Brightness = 0.7,
            OutdoorAmbient = Color3.fromRGB(110, 120, 140),
            FogColor = Color3.fromRGB(130, 145, 165),
            FogStart = 40,
            FogEnd = 1000,
            EnvironmentDiffuseScale = 0.7,
            EnvironmentSpecularScale = 0.4
        })

        createEffects({
            blur = 1.5,
            contrast = 0.15,
            saturation = -0.05,
            tint = Color3.fromRGB(190, 200, 220),
            bloom = 0.2
        })

        local rainSound = Instance.new("Sound")
        rainSound.Name = "WeatherSound"
        rainSound.SoundId = "rbxassetid://1516791621"
        rainSound.Volume = 0
        rainSound.Looped = true
        rainSound.Parent = workspace
        rainSound:Play()
        TweenService:Create(
            rainSound,
            TweenInfo.new(2, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
            {Volume = 0.3}
        ):Play()
        WeatherObjects.sound = rainSound

        local windTick = 0
        local puddleTick = 0
        local followTick = 0
        local rainbowTick = 0

        table.insert(WeatherConnections, RunService.RenderStepped:Connect(function(dt)
            if not WeatherOn then return end

            windTick = windTick + dt
            puddleTick = puddleTick + dt
            followTick = followTick + dt
            rainbowTick = rainbowTick + dt

            if windTick > 3 then
                windTick = 0
                for _, breeze in ipairs(WeatherObjects.winds) do
                    if breeze.Parent then
                        breeze.Force = Vector3.new(math.random(-12, 12), -1, math.random(-12, 12))
                    end
                end
            end

            if puddleTick > 2 then
                puddleTick = 0
                for _, area in ipairs(WeatherObjects.parts) do
                    if math.random() < 0.15 then
                        local spot = area.Position + Vector3.new(math.random(-50, 50), 0, math.random(-50, 50))
                        createPuddle(spot)
                    end
                end
            end

            if followTick > 5 then
                followTick = 0
                local root = getRoot()
                if root then
                    for _, area in ipairs(WeatherObjects.parts) do
                        if area.Parent then
                            local offset = Vector3.new(math.random(-120, 120), 0, math.random(-120, 120))
                            TweenService:Create(
                                area,
                                TweenInfo.new(4, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut),
                                {Position = root.Position + offset + Vector3.new(0, 40, 0)}
                            ):Play()
                        end
                    end
                end
            end

            if rainbowTick > 25 then
                rainbowTick = 0
                if math.random() < 0.3 then
                    createRainbowFlash()
                end
            end
        end))

        table.insert(WeatherThreads, task.spawn(function()
            while WeatherOn do
                task.wait(math.random(20, 45))
                if WeatherOn and math.random() < 0.5 then
                    createLightning()
                end
            end
        end))
    end

    local function startSnow()
        if WeatherOn then return end
        WeatherOn = true

        WeatherObjects.parts = {}
        WeatherObjects.winds = {}

        for i = 1, 6 do
            local area = Instance.new("Part")
            area.Name = "WeatherArea" .. i
            area.Size = Vector3.new(200, 120, 200)
            area.Transparency = 1
            area.CanCollide = false
            area.Anchored = true

            local root = getRoot()
            if root then
                area.Position = root.Position + Vector3.new(
                    math.random(-100, 100), 40, math.random(-100, 100)
                )
            else
                area.Position = Vector3.new(0, 40, 0)
            end
            area.Parent = workspace

            local flakes = Instance.new("ParticleEmitter")
            flakes.Texture = "rbxassetid://1742722513"
            flakes.Rate = 200
            flakes.Lifetime = NumberRange.new(4, 6)
            flakes.Speed = NumberRange.new(3, 6)
            flakes.Rotation = NumberRange.new(0, 360)
            flakes.RotSpeed = NumberRange.new(-20, 20)
            flakes.VelocitySpread = 60
            flakes.Acceleration = Vector3.new(0, -8, 0)
            flakes.LightEmission = 0.1
            flakes.LightInfluence = 0.5

            flakes.Size = NumberSequence.new({
                NumberSequenceKeypoint.new(0, 0.3),
                NumberSequenceKeypoint.new(0.5, 0.6),
                NumberSequenceKeypoint.new(1, 0.3)
            })

            flakes.Transparency = NumberSequence.new({
                NumberSequenceKeypoint.new(0, 0.1),
                NumberSequenceKeypoint.new(0.5, 0),
                NumberSequenceKeypoint.new(1, 0.4)
            })

            flakes.Color = ColorSequence.new({
                ColorSequenceKeypoint.new(0, Color3.fromRGB(255, 255, 255)),
                ColorSequenceKeypoint.new(0.5, Color3.fromRGB(240, 245, 255)),
                ColorSequenceKeypoint.new(1, Color3.fromRGB(255, 255, 255))
            })

            flakes.Parent = area

            local breeze = Instance.new("VectorForce")
            breeze.Name = "WeatherWind"
            breeze.Force = Vector3.new(math.random(-8, 8), -1, math.random(-8, 8))
            breeze.RelativeTo = Enum.ActuatorRelativeTo.World
            breeze.Attachment0 = Instance.new("Attachment", area)
            breeze.Parent = area

            table.insert(WeatherObjects.parts, area)
            table.insert(WeatherObjects.winds, breeze)
        end

        applyLighting({
            Brightness = 1.5,
            OutdoorAmbient = Color3.fromRGB(180, 190, 210),
            FogColor = Color3.fromRGB(220, 230, 245),
            FogStart = 60,
            FogEnd = 1500,
            EnvironmentDiffuseScale = 0.8,
            EnvironmentSpecularScale = 0.5
        })

        createEffects({
            blur = 0.6,
            contrast = 0.05,
            saturation = -0.1,
            tint = Color3.fromRGB(230, 240, 255),
            bloom = 0.15
        })

        local windTick = 0
        local followTick = 0

        table.insert(WeatherConnections, RunService.RenderStepped:Connect(function(dt)
            if not WeatherOn then return end

            windTick = windTick + dt
            followTick = followTick + dt

            if windTick > 4 then
                windTick = 0
                for _, breeze in ipairs(WeatherObjects.winds) do
                    if breeze.Parent then
                        breeze.Force = Vector3.new(math.random(-8, 8), -1, math.random(-8, 8))
                    end
                end
            end

            if followTick > 6 then
                followTick = 0
                local root = getRoot()
                if root then
                    for _, area in ipairs(WeatherObjects.parts) do
                        if area.Parent then
                            local offset = Vector3.new(math.random(-120, 120), 0, math.random(-120, 120))
                            TweenService:Create(
                                area,
                                TweenInfo.new(5, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut),
                                {Position = root.Position + offset + Vector3.new(0, 40, 0)}
                            ):Play()
                        end
                    end
                end
            end
        end))
    end

    local function startAsh()
        if WeatherOn then return end
        WeatherOn = true

        WeatherObjects.parts = {}
        WeatherObjects.winds = {}

        for i = 1, 6 do
            local area = Instance.new("Part")
            area.Name = "WeatherArea" .. i
            area.Size = Vector3.new(200, 120, 200)
            area.Transparency = 1
            area.CanCollide = false
            area.Anchored = true

            local root = getRoot()
            if root then
                area.Position = root.Position + Vector3.new(
                    math.random(-100, 100), 40, math.random(-100, 100)
                )
            else
                area.Position = Vector3.new(0, 40, 0)
            end
            area.Parent = workspace

            local flakes = Instance.new("ParticleEmitter")
            flakes.Texture = "rbxassetid://1742722513"
            flakes.Rate = 120
            flakes.Lifetime = NumberRange.new(5, 8)
            flakes.Speed = NumberRange.new(2, 5)
            flakes.Rotation = NumberRange.new(0, 360)
            flakes.RotSpeed = NumberRange.new(-10, 10)
            flakes.VelocitySpread = 50
            flakes.Acceleration = Vector3.new(0, 5, 0)
            flakes.LightEmission = 0.3
            flakes.LightInfluence = 0.4

            flakes.Size = NumberSequence.new({
                NumberSequenceKeypoint.new(0, 0.2),
                NumberSequenceKeypoint.new(0.5, 0.4),
                NumberSequenceKeypoint.new(1, 0.2)
            })

            flakes.Transparency = NumberSequence.new({
                NumberSequenceKeypoint.new(0, 0.2),
                NumberSequenceKeypoint.new(0.5, 0.4),
                NumberSequenceKeypoint.new(1, 0.7)
            })

            flakes.Color = ColorSequence.new({
                ColorSequenceKeypoint.new(0, Color3.fromRGB(80, 80, 90)),
                ColorSequenceKeypoint.new(0.5, Color3.fromRGB(120, 120, 130)),
                ColorSequenceKeypoint.new(1, Color3.fromRGB(80, 80, 90))
            })

            flakes.Parent = area

            local breeze = Instance.new("VectorForce")
            breeze.Name = "WeatherWind"
            breeze.Force = Vector3.new(math.random(-5, 5), 2, math.random(-5, 5))
            breeze.RelativeTo = Enum.ActuatorRelativeTo.World
            breeze.Attachment0 = Instance.new("Attachment", area)
            breeze.Parent = area

            table.insert(WeatherObjects.parts, area)
            table.insert(WeatherObjects.winds, breeze)
        end

        applyLighting({
            Brightness = 0.4,
            OutdoorAmbient = Color3.fromRGB(70, 60, 60),
            FogColor = Color3.fromRGB(60, 50, 50),
            FogStart = 20,
            FogEnd = 500,
            EnvironmentDiffuseScale = 0.3,
            EnvironmentSpecularScale = 0.2
        })

        createEffects({
            blur = 1,
            contrast = 0.2,
            saturation = -0.3,
            tint = Color3.fromRGB(180, 120, 100),
            bloom = 0.4
        })

        local windTick = 0
        local followTick = 0

        table.insert(WeatherConnections, RunService.RenderStepped:Connect(function(dt)
            if not WeatherOn then return end

            windTick = windTick + dt
            followTick = followTick + dt

            if windTick > 5 then
                windTick = 0
                for _, breeze in ipairs(WeatherObjects.winds) do
                    if breeze.Parent then
                        breeze.Force = Vector3.new(math.random(-5, 5), 2, math.random(-5, 5))
                    end
                end
            end

            if followTick > 7 then
                followTick = 0
                local root = getRoot()
                if root then
                    for _, area in ipairs(WeatherObjects.parts) do
                        if area.Parent then
                            local offset = Vector3.new(math.random(-120, 120), 0, math.random(-120, 120))
                            TweenService:Create(
                                area,
                                TweenInfo.new(6, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut),
                                {Position = root.Position + offset + Vector3.new(0, 40, 0)}
                            ):Play()
                        end
                    end
                end
            end
        end))
    end

    local function startFog()
        if WeatherOn then return end
        WeatherOn = true

        WeatherObjects.parts = {}
        WeatherObjects.winds = {}

        applyLighting({
            Brightness = 0.5,
            OutdoorAmbient = Color3.fromRGB(130, 130, 140),
            FogColor = Color3.fromRGB(200, 200, 210),
            FogStart = 0,
            FogEnd = 150,
            EnvironmentDiffuseScale = 0.5,
            EnvironmentSpecularScale = 0.3
        })

        createEffects({
            blur = 2,
            contrast = 0.05,
            saturation = -0.15,
            tint = Color3.fromRGB(210, 210, 220),
            bloom = 0.25
        })
    end

    local function stopWeather()
        if not WeatherOn then return end
        WeatherOn = false

        for _, conn in ipairs(WeatherConnections) do
            conn:Disconnect()
        end
        WeatherConnections = {}

        for _, thread in ipairs(WeatherThreads) do
            task.cancel(thread)
        end
        WeatherThreads = {}

        for _, part in ipairs(WeatherObjects.parts or {}) do
            if part.Parent then
                local tween = TweenService:Create(
                    part,
                    TweenInfo.new(1.5, Enum.EasingStyle.Quad, Enum.EasingDirection.In),
                    {Size = Vector3.new(0, 0, 0)}
                )
                tween:Play()
                Debris:AddItem(part, 2)
            end
        end

        if WeatherObjects.sound and WeatherObjects.sound.Parent then
            local tween = TweenService:Create(
                WeatherObjects.sound,
                TweenInfo.new(1.5, Enum.EasingStyle.Quad, Enum.EasingDirection.In),
                {Volume = 0}
            )
            tween:Play()
            Debris:AddItem(WeatherObjects.sound, 2)
        end

        for _, name in ipairs({"WeatherBlur", "WeatherColor", "WeatherBloom"}) do
            local fx = Lighting:FindFirstChild(name)
            if fx then
                local target = {Size = 0}
                if fx:IsA("ColorCorrectionEffect") then
                    target = {Contrast = 0, Saturation = 0}
                elseif fx:IsA("BloomEffect") then
                    target = {Intensity = 0}
                end
                local tween = TweenService:Create(
                    fx,
                    TweenInfo.new(1.5, Enum.EasingStyle.Quad, Enum.EasingDirection.In),
                    target
                )
                tween:Play()
                Debris:AddItem(fx, 2)
            end
        end

        if WeatherObjects.originalLighting then
            TweenService:Create(
                Lighting,
                TweenInfo.new(2, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut),
                WeatherObjects.originalLighting
            ):Play()
        end

        for _, obj in ipairs(workspace:GetDescendants()) do
            if obj.Name == "WeatherPuddle" then
                local tween = TweenService:Create(
                    obj,
                    TweenInfo.new(1, Enum.EasingStyle.Quad, Enum.EasingDirection.In),
                    {Transparency = 1}
                )
                tween:Play()
                Debris:AddItem(obj, 1.5)
            end
        end

        WeatherObjects = {}
    end

    local function switchWeather(weatherName)
        if WeatherOn then
            stopWeather()
            task.wait(0.3)
        end

        if weatherName == "Rain" then
            startRain()
        elseif weatherName == "Snow" then
            startSnow()
        elseif weatherName == "Ash" then
            startAsh()
        elseif weatherName == "Fog" then
            startFog()
        end
    end

    local function startInfJump()
        if InfJumpConnection then return end

        InfJumpConnection = UserInputService.JumpRequest:Connect(function()
            if not InfJumpOn then return end

            local char = LocalPlayer.Character
            if not char then return end
            local hum = char:FindFirstChildOfClass("Humanoid")
            if not hum then return end

            hum:ChangeState(Enum.HumanoidStateType.Jumping)
        end)
    end

    local function stopInfJump()
        if InfJumpConnection then
            InfJumpConnection:Disconnect()
            InfJumpConnection = nil
        end
    end

    local function setInfJump(state)
        InfJumpOn = state
        if state then
            startInfJump()
        else
            stopInfJump()
        end
    end

    local function startSpeed()
        if SpeedConnection then return end

        SpeedConnection = RunService.RenderStepped:Connect(function(dt)
            if not SpeedOn then return end

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

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

            local moveDir = hum.MoveDirection
            if moveDir.Magnitude > 0 then
                root.CFrame = root.CFrame + (moveDir * SpeedValue * dt)
            end
        end)
    end

    local function stopSpeed()
        if SpeedConnection then
            SpeedConnection:Disconnect()
            SpeedConnection = nil
        end
    end

    local function setSpeed(state)
        SpeedOn = state
        if state then
            startSpeed()
        else
            stopSpeed()
        end
    end

    local function createBox(plr)
        if plr == LocalPlayer then return end
        if BoxData[plr] then return end

        local gui = Instance.new("BillboardGui")
        gui.Name = "esp_box_" .. plr.Name
        gui.Size = UDim2.new(0, 100, 0, 100)
        gui.AlwaysOnTop = true
        gui.Enabled = false
        gui.Parent = game.CoreGui

        local boxFrame = Instance.new("Frame")
        boxFrame.Name = "box"
        boxFrame.Size = UDim2.new(1, 0, 1, 0)
        boxFrame.BackgroundTransparency = 1
        boxFrame.Parent = gui

        local stroke = Instance.new("UIStroke")
        stroke.Thickness = 1.5
        stroke.Color = BoxColor
        stroke.Transparency = 0
        stroke.Parent = boxFrame

        local healthBg = Instance.new("Frame")
        healthBg.Name = "hpBg"
        healthBg.Size = UDim2.new(0, 3, 1, 0)
        healthBg.Position = UDim2.new(-0.08, 0, 0, 0)
        healthBg.BackgroundColor3 = Color3.fromRGB(30, 30, 30)
        healthBg.BorderSizePixel = 0
        healthBg.Visible = HealthOn
        healthBg.Parent = gui

        local healthBar = Instance.new("Frame")
        healthBar.Name = "hpBar"
        healthBar.Size = UDim2.new(1, 0, 1, 0)
        healthBar.Position = UDim2.new(0, 0, 0, 0)
        healthBar.BackgroundColor3 = Color3.fromRGB(0, 255, 0)
        healthBar.BorderSizePixel = 0
        healthBar.Parent = healthBg

        BoxData[plr] = {
            gui = gui,
            stroke = stroke,
            hpBg = healthBg,
            hpBar = healthBar
        }
    end

    local function removeBox(plr)
        local data = BoxData[plr]
        if data then
            data.gui:Destroy()
            BoxData[plr] = nil
        end
    end

    for _, plr in ipairs(Players:GetPlayers()) do
        createBox(plr)
    end

    Players.PlayerAdded:Connect(createBox)
    Players.PlayerRemoving:Connect(removeBox)

    RunService.RenderStepped:Connect(function()
        if not BoxOn and not HealthOn then return end

        local me = LocalPlayer.Character
        if not me then return end
        local myRoot = me:FindFirstChild("HumanoidRootPart")
        if not myRoot then return end
        local myPos = myRoot.Position

        for plr, data in pairs(BoxData) do
            local char = plr.Character
            local root = char and char:FindFirstChild("HumanoidRootPart")
            local hum = char and char:FindFirstChildOfClass("Humanoid")
            local head = char and char:FindFirstChild("Head")

            if root and hum and head and hum.Health > 0 then
                local dist = (root.Position - myPos).Magnitude

                if dist <= MaxDistance then
                    local screenPos, onScreen = Camera:WorldToViewportPoint(root.Position)
                    if onScreen and screenPos.Z > 0 then
                        local topPos = Camera:WorldToViewportPoint(head.Position + Vector3.new(0, 0.7, 0))
                        local bottomPos = Camera:WorldToViewportPoint(root.Position - Vector3.new(0, 3, 0))

                        local height = math.abs(topPos.Y - bottomPos.Y)
                        local width = height * 0.55

                        if height < 5 then height = 5 end
                        if width < 3 then width = 3 end

                        data.gui.Adornee = root
                        data.gui.Size = UDim2.new(0, width, 0, height)
                        data.gui.Enabled = BoxOn or HealthOn
                        data.stroke.Color = BoxColor
                        data.stroke.Transparency = BoxOn and 0 or 1

                        local hpPercent = hum.Health / hum.MaxHealth
                        data.hpBar.Size = UDim2.new(1, 0, hpPercent, 0)
                        data.hpBar.Position = UDim2.new(0, 0, 1 - hpPercent, 0)

                        if hpPercent > 0.6 then
                            data.hpBar.BackgroundColor3 = Color3.fromRGB(0, 255, 0)
                        elseif hpPercent > 0.3 then
                            data.hpBar.BackgroundColor3 = Color3.fromRGB(255, 200, 0)
                        else
                            data.hpBar.BackgroundColor3 = Color3.fromRGB(255, 0, 0)
                        end

                        data.hpBg.Visible = HealthOn
                    else
                        data.gui.Enabled = false
                    end
                else
                    data.gui.Enabled = false
                end
            else
                data.gui.Enabled = false
            end
        end
    end)

    local Tib = Window:MakeTab({
        Name = "ColdTeam X ESP",
        Icon = "rbxassetid://4483345998",
        PremiumOnly = false
    })

    local Teb = Window:MakeTab({
        Name = "ColdTeam X Aim",
        Icon = "rbxassetid://4483345998",
        PremiumOnly = false
    })

    local Taz = Window:MakeTab({
        Name = "ColdTeam X Fun",
        Icon = "rbxassetid://4483345998",
        PremiumOnly = false
    })

    local chamsOn = false
    local chamsThread = nil
    local chamsJoin = nil

    local function addCham(char)
        if not char or not char.Parent then return end
        if char:FindFirstChild("esp_chams") then return end

        local hl = Instance.new("Highlight")
        hl.Name = "esp_chams"
        hl.FillColor = ChamsColor
        hl.OutlineColor = Color3.fromRGB(0, 0, 0)
        hl.FillTransparency = 0.5
        hl.OutlineTransparency = 0
        hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
        hl.Adornee = char
        hl.Parent = char
    end

    local function dropCham(char)
        if not char then return end
        local hl = char:FindFirstChild("esp_chams")
        if hl then hl:Destroy() end
    end

    local function refreshChams()
        if not chamsOn then return end

        local me = LocalPlayer.Character
        if not me then return end
        local myRoot = me:FindFirstChild("HumanoidRootPart")
        if not myRoot then return end
        local myPos = myRoot.Position

        for _, plr in ipairs(Players:GetPlayers()) do
            if plr ~= LocalPlayer then
                local char = plr.Character
                if char then
                    local root = char:FindFirstChild("HumanoidRootPart")
                    local hum = char:FindFirstChildOfClass("Humanoid")

                    if root and hum and hum.Health > 0 then
                        local dist = (root.Position - myPos).Magnitude
                        if dist <= MaxDistance then
                            addCham(char)
                        else
                            dropCham(char)
                        end
                    else
                        dropCham(char)
                    end
                end
            end
        end
    end

    local function setChams(state)
        chamsOn = state

        if state then
            refreshChams()

            chamsThread = task.spawn(function()
                while chamsOn do
                    task.wait(0.5)
                    refreshChams()
                end
            end)

            chamsJoin = Players.PlayerAdded:Connect(function(plr)
                plr.CharacterAdded:Connect(function()
                    task.wait(1)
                    refreshChams()
                end)
            end)
        else
            if chamsThread then task.cancel(chamsThread) chamsThread = nil end
            if chamsJoin then chamsJoin:Disconnect() chamsJoin = nil end

            for _, plr in ipairs(Players:GetPlayers()) do
                if plr.Character then
                    dropCham(plr.Character)
                end
            end
        end
    end

    local nameOn = false
    local nameTags = {}

    local function applyNameSize()
        for _, tag in pairs(nameTags) do
            tag.gui.Size = UDim2.new(0, NameSize * 5, 0, NameSize * 1.25)
        end
    end

    local function addNameTag(plr)
        if plr == LocalPlayer then return end
        if nameTags[plr] then return end

        local gui = Instance.new("BillboardGui")
        gui.Name = "esp_name_" .. plr.Name
        gui.Size = UDim2.new(0, NameSize * 5, 0, NameSize * 1.25)
        gui.AlwaysOnTop = true
        gui.StudsOffset = Vector3.new(0, 3.5, 0)
        gui.Enabled = false
        gui.Parent = game.CoreGui

        local label = Instance.new("TextLabel")
        label.Size = UDim2.new(1, 0, 1, 0)
        label.BackgroundTransparency = 1
        label.TextColor3 = NameColor
        label.TextStrokeTransparency = 1
        label.TextScaled = true
        label.Font = Enum.Font.GothamBlack
        label.Text = plr.Name
        label.Parent = gui

        local stroke = Instance.new("UIStroke")
        stroke.Thickness = 2
        stroke.Color = Color3.fromRGB(0, 0, 0)
        stroke.Transparency = 0.1
        stroke.Parent = label

        nameTags[plr] = {gui = gui, label = label}
    end

    local function dropNameTag(plr)
        local tag = nameTags[plr]
        if tag then
            tag.gui:Destroy()
            nameTags[plr] = nil
        end
    end

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

        local me = LocalPlayer.Character
        if not me then return end
        local myRoot = me:FindFirstChild("HumanoidRootPart")
        if not myRoot then return end
        local myPos = myRoot.Position

        for plr, tag in pairs(nameTags) do
            local char = plr.Character
            local root = char and char:FindFirstChild("HumanoidRootPart")
            local hum = char and char:FindFirstChildOfClass("Humanoid")

            if root and hum and hum.Health > 0 then
                local dist = (root.Position - myPos).Magnitude

                if dist <= MaxDistance then
                    local screenPos, onScreen = Camera:WorldToViewportPoint(root.Position)
                    if onScreen and screenPos.Z > 0 then
                        tag.gui.Adornee = root
                        tag.gui.Enabled = true
                        tag.label.TextColor3 = NameColor
                    else
                        tag.gui.Enabled = false
                    end
                else
                    tag.gui.Enabled = false
                end
            else
                tag.gui.Enabled = false
            end
        end
    end)

    for _, plr in ipairs(Players:GetPlayers()) do
        addNameTag(plr)
    end

    Players.PlayerAdded:Connect(addNameTag)
    Players.PlayerRemoving:Connect(dropNameTag)

    local fovGui = Instance.new("ScreenGui")
    fovGui.Name = "aim_fov_gui"
    fovGui.ResetOnSpawn = false
    fovGui.IgnoreGuiInset = true
    fovGui.Parent = game.CoreGui

    local fovCircle = Instance.new("Frame")
    fovCircle.Name = "fov_circle"
    fovCircle.AnchorPoint = Vector2.new(0.5, 0.5)
    fovCircle.BackgroundTransparency = 1
    fovCircle.Visible = false
    fovCircle.Parent = fovGui

    local fovCorner = Instance.new("UICorner")
    fovCorner.CornerRadius = UDim.new(1, 0)
    fovCorner.Parent = fovCircle

    local fovStroke = Instance.new("UIStroke")
    fovStroke.Thickness = 1
    fovStroke.Color = Color3.fromRGB(255, 255, 255)
    fovStroke.Transparency = 0.3
    fovStroke.Parent = fovCircle

    RunService.RenderStepped:Connect(function()
        if not AimOn then
            fovCircle.Visible = false
            return
        end

        fovCircle.Visible = true
        local mouse = UserInputService:GetMouseLocation()
        fovCircle.Position = UDim2.fromOffset(mouse.X, mouse.Y)
        fovCircle.Size = UDim2.fromOffset(AimFOV * 2, AimFOV * 2)
    end)

    local function isAlive(plr)
        local char = plr.Character
        if not char then return false end
        local hum = char:FindFirstChildOfClass("Humanoid")
        if not hum or hum.Health <= 0 then return false end
        return true
    end

    local function isVisible(part)
        if not AimWallCheck then return true end

        local origin = Camera.CFrame.Position
        local dir = part.Position - origin

        local params = RaycastParams.new()
        params.FilterType = Enum.RaycastFilterType.Exclude
        params.FilterDescendantsInstances = {LocalPlayer.Character, Camera}

        local result = workspace:Raycast(origin, dir, params)
        if result then
            return result.Instance:IsDescendantOf(part.Parent)
        end
        return true
    end

    local function getClosestToMouse()
        local closest = nil
        local shortest = AimFOV
        local mousePos = UserInputService:GetMouseLocation()

        local me = LocalPlayer.Character
        if not me then return nil end
        local myRoot = me:FindFirstChild("HumanoidRootPart")
        if not myRoot then return nil end
        local myPos = myRoot.Position

        for _, plr in ipairs(Players:GetPlayers()) do
            if plr ~= LocalPlayer and isAlive(plr) then
                local char = plr.Character
                local part = char:FindFirstChild(AimPart) or char:FindFirstChild("HumanoidRootPart")
                if part then
                    local range = (part.Position - myPos).Magnitude
                    if range <= AimMaxRange then
                        local screenPos, onScreen = Camera:WorldToViewportPoint(part.Position)
                        if onScreen and screenPos.Z > 0 then
                            local dist = (Vector2.new(screenPos.X, screenPos.Y) - mousePos).Magnitude
                            if dist < shortest and isVisible(part) then
                                shortest = dist
                                closest = part
                            end
                        end
                    end
                end
            end
        end

        return closest
    end

    RunService.RenderStepped:Connect(function()
        if not AimOn then return end
        if not UserInputService:IsMouseButtonPressed(AimKey) then return end

        local me = LocalPlayer.Character
        if not me then return end
        local myRoot = me:FindFirstChild("HumanoidRootPart")
        if not myRoot then return end

        local target = getClosestToMouse()
        if target then
            local camPos = Camera.CFrame.Position
            Camera.CFrame = Camera.CFrame:Lerp(
                CFrame.new(camPos, target.Position),
                AimSmooth
            )
        end
    end)

    local function setAim(state)
        AimOn = state
    end

    Taz:AddLabel("World Changer")

    Taz:AddToggle({
        Name = "World Changer",
        Default = false,
        Callback = function(Value)
            if Value then
                switchWeather(CurrentWeather)
            else
                stopWeather()
            end
        end
    })

    Taz:AddDropdown({
        Name = "Weather type",
        Default = "Rain",
        Options = {"Rain", "Snow", "Ash", "Fog"},
        Callback = function(Value)
            CurrentWeather = Value

            if WeatherOn then
                switchWeather(Value)
            end
        end
    })

    Taz:AddButton({
        Name = "Lightning test",
        Callback = function()
            createLightning()
        end
    })

    Taz:AddLabel("Movement")

    Taz:AddToggle({
        Name = "Infinite Jump",
        Default = false,
        Callback = function(Value)
            setInfJump(Value)
        end
    })

    Taz:AddToggle({
        Name = "Speed Hack",
        Default = false,
        Callback = function(Value)
            setSpeed(Value)
        end
    })

    Taz:AddSlider({
        Name = "Speed value",
        Min = 20,
        Max = 300,
        Default = 60,
        Increment = 5,
        ValueName = "studs/s",
        Callback = function(Value)
            SpeedValue = Value
        end
    })

    Tib:AddLabel("Chams")

    Tib:AddToggle({
        Name = "Chams",
        Default = false,
        Callback = function(Value)
            setChams(Value)
        end
    })

    Tib:AddColorpicker({
        Name = "Chams color",
        Default = Color3.fromRGB(255, 0, 0),
        Callback = function(Value)
            ChamsColor = Value

            for _, plr in ipairs(Players:GetPlayers()) do
                if plr.Character then
                    local hl = plr.Character:FindFirstChild("esp_chams")
                    if hl then hl.FillColor = Value end
                end
            end
        end
    })

    Tib:AddLabel("ESP Name")

    Tib:AddToggle({
        Name = "ESP Name",
        Default = false,
        Callback = function(Value)
            nameOn = Value
            if not Value then
                for _, tag in pairs(nameTags) do
                    tag.gui.Enabled = false
                end
            end
        end
    })

    Tib:AddColorpicker({
        Name = "Name color",
        Default = Color3.fromRGB(255, 255, 255),
        Callback = function(Value)
            NameColor = Value

            for _, tag in pairs(nameTags) do
                tag.label.TextColor3 = Value
            end
        end
    })

    Tib:AddSlider({
        Name = "Name size",
        Min = 10,
        Max = 100,
        Default = 40,
        Color = Color3.fromRGB(255, 255, 255),
        Increment = 1,
        ValueName = "px",
        Callback = function(Value)
            NameSize = Value
            applyNameSize()
        end
    })

    Tib:AddLabel("Box ESP")

    Tib:AddToggle({
        Name = "Box ESP",
        Default = false,
        Callback = function(Value)
            BoxOn = Value
            if not Value and not HealthOn then
                for _, data in pairs(BoxData) do
                    data.gui.Enabled = false
                end
            end
        end
    })

    Tib:AddToggle({
        Name = "Health Bar",
        Default = false,
        Callback = function(Value)
            HealthOn = Value

            for _, data in pairs(BoxData) do
                data.hpBg.Visible = Value
            end

            if not Value and not BoxOn then
                for _, data in pairs(BoxData) do
                    data.gui.Enabled = false
                end
            end
        end
    })

    Tib:AddColorpicker({
        Name = "Box color",
        Default = Color3.fromRGB(255, 0, 0),
        Callback = function(Value)
            BoxColor = Value
            for _, data in pairs(BoxData) do
                data.stroke.Color = Value
            end
        end
    })

    Teb:AddLabel("Aimbot")

    Teb:AddToggle({
        Name = "Aimbot",
        Default = false,
        Callback = function(Value)
            setAim(Value)
        end
    })

    Teb:AddToggle({
        Name = "Wall check",
        Default = true,
        Callback = function(Value)
            AimWallCheck = Value
        end
    })

    Teb:AddSlider({
        Name = "Aimbot FOV",
        Min = 10,
        Max = 500,
        Default = 100,
        Increment = 1,
        ValueName = "px",
        Callback = function(Value)
            AimFOV = Value
        end
    })

    Teb:AddSlider({
        Name = "Aimbot Range",
        Min = 100,
        Max = 3000,
        Default = 1000,
        Increment = 50,
        ValueName = "studs",
        Callback = function(Value)
            AimMaxRange = Value
        end
    })

    Teb:AddSlider({
        Name = "Aimbot Smooth",
        Min = 1,
        Max = 100,
        Default = 20,
        Increment = 1,
        ValueName = "%",
        Callback = function(Value)
            AimSmooth = Value / 100
        end
    })

    OrionLib:Init()
end