Custom Timer(Fixed Console Spam)

--Custom Evade Timer--
--Made By cxsir(Claude And Grok AI)--
if not game:IsLoaded() then game.Loaded:Wait() end

--Allowed game IDs
local allowedGames = {
    [9872472334] = true, --Evade
    [10324346056] = true, --Big Teams
    [10324347967] = true, --Social Space
    [10662542523] = true, --Casual
    [10808838353] = true, --VC Only
    [11353528705] = true, --Pro
    [96537472072550] = true, --Legacy
    [99214917572799] = true, --Custom Servers
    [121271605799901] = true --Player Nextbots
}

local currentGameId = game.PlaceId

if allowedGames[currentGameId] then
    local Players = game:GetService("Players")
    local LocalPlayer = Players.LocalPlayer
    local PlayerGui

    --Wait for LocalPlayer if not loaded
    if not LocalPlayer then
        Players:GetPropertyChangedSignal("LocalPlayer"):Wait()
        LocalPlayer = Players.LocalPlayer
    end
    PlayerGui = LocalPlayer:WaitForChild("PlayerGui", 10)
    if not PlayerGui then return end

    --Remove existing custom timer if present
    local existingTimer = PlayerGui:FindFirstChild("CustomEvadeTimer")
    if existingTimer then
        existingTimer:Destroy()
        task.wait(0.1)
    end

    --==================== CUSTOMIZATION SECTION ====================
	--Position/Size
    local TIMER_POSITION = UDim2.new(0.5, 0, 0.025, 0)
    local TIMER_SIZE = UDim2.new(0.09, 0, 0.1, -10)
	
	--Main Box/Background
    local BG_COLOR = Color3.fromRGB(20, 20, 20)
    local BG_TRANSPARENCY = 0.5
    local CORNER_RADIUS = UDim.new(0, 10)
	
	--Border
	local BORDER_GLOW = true --Enable/disable animated border glow
	local BORDER_COLOR = Color3.fromRGB(0, 0, 0) --Static border color (only used when BORDER_GLOW = false)
    local BORDER_THICKNESS = 2.5
    local BORDER_TRANSPARENCY = 0.5
	local GLOW_ROUND_BRIGHT = Color3.fromRGB(255, 80, 80) --Bright red
	local GLOW_ROUND_DARK = Color3.fromRGB(130, 40, 40) --Darker red
	local GLOW_SAFE_BRIGHT = Color3.fromRGB(100, 255, 100) --Bright green
	local GLOW_SAFE_DARK = Color3.fromRGB(50, 130, 50) --Darker green
	local GLOW_SPEED = 1 --How fast it pulses (seconds for one cycle)
	
	--Status (In-Round/Intermission)
    local STATUS_ROUND_TEXT = "Survive"
    local STATUS_INTERMISSION_TEXT = "Safe"
    local STATUS_ROUND_COLOR = Color3.fromRGB(250, 100, 100)
    local STATUS_INTERMISSION_COLOR = Color3.fromRGB(100, 250, 100)
	
	--Timer Color
    local NORMAL_TIMER_COLOR = Color3.fromRGB(255, 255, 255)
    local LOW_TIME_COLOR = Color3.fromRGB(250, 100, 100)
    local LOW_TIME_THRESHOLD = 15
	local SAFE_TIMER_COLOR = Color3.fromRGB(100, 250, 100)
	local LOW_TIME_PULSE = true --Enable/disable pulsing when time is low
	local LOW_TIME_PULSE_SPEED = 0.4
	local LOW_TIME_PULSE_SCALE = 1.15 --How much bigger it gets (1.15 = 15% larger)
	
	--Font (https://create.roblox.com/docs/reference/engine/enums/Font)
    local TEXT_FONT = Enum.Font.GothamBold
	
	--Text Stroke
    local TEXT_STROKE_ENABLED = true
    local TEXT_STROKE_COLOR = Color3.fromRGB(50, 50, 50)
    local TEXT_STROKE_THICKNESS = 2.5
    local TEXT_STROKE_TRANSPARENCY = 0.6

    --==============================================================

    --Create the custom timer GUI
    local function CreateTimerGUI()
        local ScreenGui = Instance.new("ScreenGui")
        ScreenGui.Name = "CustomEvadeTimer"
        ScreenGui.ResetOnSpawn = false
        ScreenGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
        ScreenGui.Parent = PlayerGui

        local Container = Instance.new("Frame")
        Container.Name = "Container"
        Container.Parent = ScreenGui
        Container.AnchorPoint = Vector2.new(0.5, 0)
        Container.Position = TIMER_POSITION
        Container.Size = TIMER_SIZE
        Container.BackgroundColor3 = BG_COLOR
        Container.BackgroundTransparency = BG_TRANSPARENCY
        Container.BorderSizePixel = 0

        local Corner = Instance.new("UICorner")
        Corner.CornerRadius = CORNER_RADIUS
        Corner.Parent = Container

        local Border = Instance.new("UIStroke")
        Border.Thickness = BORDER_THICKNESS
        Border.Color = BORDER_COLOR
        Border.Transparency = BORDER_TRANSPARENCY
        Border.Parent = Container

        local Status = Instance.new("TextLabel")
        Status.Name = "Status"
        Status.Parent = Container
        Status.Position = UDim2.new(0.5, 0, 0.2, 0)
        Status.AnchorPoint = Vector2.new(0.5, 0.3)
        Status.Size = UDim2.new(0.95, 0, 0.45, 0)
        Status.BackgroundTransparency = 1
        Status.Font = TEXT_FONT
        Status.Text = "LOADING..."
        Status.TextColor3 = Color3.fromRGB(255, 255, 255)
        Status.TextScaled = true
        Status.TextStrokeTransparency = 1

        local Timer = Instance.new("TextLabel")
        Timer.Name = "Timer"
        Timer.Parent = Container
        Timer.Position = UDim2.new(0.5, 0, 0.75, 0)
        Timer.AnchorPoint = Vector2.new(0.5, 0.7)
        Timer.Size = UDim2.new(0.95, 0, 0.45, 0)
        Timer.BackgroundTransparency = 1
        Timer.Font = TEXT_FONT
        Timer.Text = "0:00"
        Timer.TextColor3 = NORMAL_TIMER_COLOR
        Timer.TextScaled = true
        Timer.TextStrokeTransparency = 1

        --Add text stroke if enabled
        if TEXT_STROKE_ENABLED then
            local StatusStroke = Instance.new("UIStroke")
            StatusStroke.Parent = Status
            StatusStroke.Color = TEXT_STROKE_COLOR
            StatusStroke.Thickness = TEXT_STROKE_THICKNESS
            StatusStroke.Transparency = TEXT_STROKE_TRANSPARENCY

            local TimerStroke = Instance.new("UIStroke")
            TimerStroke.Parent = Timer
            TimerStroke.Color = TEXT_STROKE_COLOR
            TimerStroke.Thickness = TEXT_STROKE_THICKNESS
            TimerStroke.Transparency = TEXT_STROKE_TRANSPARENCY
        end

        return ScreenGui, Timer, Status
    end

    local Gui, TimerLabel, StatusLabel = CreateTimerGUI()

    --Format seconds into M:SS format
    local function formatTime(sec)
        sec = math.floor(tonumber(sec) or 0)
        if sec <= 0 then return "0:00" end
        return string.format("%d:%02d", math.floor(sec/60), sec%60)
    end

    --Update timer display based on game stats
    local Connection
    local function UpdateTimer()
        local StatsFolder = workspace:FindFirstChild("Game") and workspace.Game:FindFirstChild("Stats")
        if not StatsFolder then
            TimerLabel.Text = "0:00"
            StatusLabel.Text = "WAITING..."
            return
        end

        if Connection then Connection:Disconnect() end

        Connection = StatsFolder:GetAttributeChangedSignal("Timer"):Connect(function()
            local timeLeft = StatsFolder:GetAttribute("Timer")
            local roundActive = StatsFolder:GetAttribute("RoundStarted")

            TimerLabel.Text = formatTime(timeLeft)
            
            --Set timer color based on round state and time remaining
            if roundActive then
                TimerLabel.TextColor3 = (timeLeft and timeLeft <= LOW_TIME_THRESHOLD) and LOW_TIME_COLOR or NORMAL_TIMER_COLOR
            else
                TimerLabel.TextColor3 = SAFE_TIMER_COLOR
            end

            StatusLabel.Text = roundActive and STATUS_ROUND_TEXT or STATUS_INTERMISSION_TEXT
            StatusLabel.TextColor3 = roundActive and STATUS_ROUND_COLOR or STATUS_INTERMISSION_COLOR
        end)
        
        --Trigger initial update
        StatsFolder:SetAttribute("Timer", StatsFolder:GetAttribute("Timer"))
    end

    --Watch for new game rounds
    workspace.ChildAdded:Connect(function(child)
        if child.Name == "Game" then
            task.wait(0.6)
            UpdateTimer()
        end
    end)

    UpdateTimer()

    --Border glow animation
    if BORDER_GLOW then
        task.spawn(function()
            local tweenService = game:GetService("TweenService")
            local border = Gui.Container:FindFirstChild("UIStroke")
            if not border then return end
            
            while Gui and Gui.Parent do
                local StatsFolder = workspace:FindFirstChild("Game") and workspace.Game:FindFirstChild("Stats")
                local roundActive = StatsFolder and StatsFolder:GetAttribute("RoundStarted")
                
                --Choose colors based on round state
                local brightColor = roundActive and GLOW_ROUND_BRIGHT or GLOW_SAFE_BRIGHT
                local darkColor = roundActive and GLOW_ROUND_DARK or GLOW_SAFE_DARK
                
                --Pulse to bright
                local tweenToBright = tweenService:Create(border, TweenInfo.new(GLOW_SPEED, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut), {Color = brightColor})
                tweenToBright:Play()
                tweenToBright.Completed:Wait()
                
                --Pulse to dark
                local tweenToDark = tweenService:Create(border, TweenInfo.new(GLOW_SPEED, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut), {Color = darkColor})
                tweenToDark:Play()
                tweenToDark.Completed:Wait()
            end
        end)
    end
    
    --Low time pulsing animation
    if LOW_TIME_PULSE then
        task.spawn(function()
            local tweenService = game:GetService("TweenService")
            local originalTimerSize = TimerLabel.Size
            local originalStatusSize = StatusLabel.Size
            
            while Gui and Gui.Parent do
                local StatsFolder = workspace:FindFirstChild("Game") and workspace.Game:FindFirstChild("Stats")
                local timeLeft = StatsFolder and StatsFolder:GetAttribute("Timer")
                local roundActive = StatsFolder and StatsFolder:GetAttribute("RoundStarted")
                
                --Pulse when time is low or during intermission
                if (roundActive and timeLeft and timeLeft <= LOW_TIME_THRESHOLD) or (not roundActive) then
                    --Pulse up
                    local timerPulseUp = tweenService:Create(TimerLabel, TweenInfo.new(LOW_TIME_PULSE_SPEED, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), {
                        Size = UDim2.new(originalTimerSize.X.Scale * LOW_TIME_PULSE_SCALE, 0, originalTimerSize.Y.Scale * LOW_TIME_PULSE_SCALE, 0)
                    })
                    timerPulseUp:Play()
                    
                    local statusPulseUp = tweenService:Create(StatusLabel, TweenInfo.new(LOW_TIME_PULSE_SPEED, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), {
                        Size = UDim2.new(originalStatusSize.X.Scale * LOW_TIME_PULSE_SCALE, 0, originalStatusSize.Y.Scale * LOW_TIME_PULSE_SCALE, 0)
                    })
                    statusPulseUp:Play()
                    
                    local border = Gui.Container:FindFirstChild("UIStroke")
                    if border then
                        local borderPulseUp = tweenService:Create(border, TweenInfo.new(LOW_TIME_PULSE_SPEED, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), {Thickness = BORDER_THICKNESS * LOW_TIME_PULSE_SCALE})
                        borderPulseUp:Play()
                    end
                    
                    timerPulseUp.Completed:Wait()
                    
                    --Pulse down
                    local timerPulseDown = tweenService:Create(TimerLabel, TweenInfo.new(LOW_TIME_PULSE_SPEED, Enum.EasingStyle.Quad, Enum.EasingDirection.In), {Size = originalTimerSize})
                    timerPulseDown:Play()
                    
                    local statusPulseDown = tweenService:Create(StatusLabel, TweenInfo.new(LOW_TIME_PULSE_SPEED, Enum.EasingStyle.Quad, Enum.EasingDirection.In), {Size = originalStatusSize})
                    statusPulseDown:Play()
                    
                    if border then
                        local borderPulseDown = tweenService:Create(border, TweenInfo.new(LOW_TIME_PULSE_SPEED, Enum.EasingStyle.Quad, Enum.EasingDirection.In), {Thickness = BORDER_THICKNESS})
                        borderPulseDown:Play()
                    end
                    
                    timerPulseDown.Completed:Wait()
                else
                    task.wait(0.1)
                end
            end
        end)
    end

    --Hide original timers and create dummy elements to prevent game errors
    local cleanupLoop
    cleanupLoop = task.spawn(function()
        while Gui and Gui.Parent do
            --Handle round overlay timer
            pcall(function()
                local round = PlayerGui:FindFirstChild("Shared") 
                    and PlayerGui.Shared:FindFirstChild("HUD")
                    and PlayerGui.Shared.HUD:FindFirstChild("Overlay")
                    and PlayerGui.Shared.HUD.Overlay:FindFirstChild("Default")
                    and PlayerGui.Shared.HUD.Overlay.Default:FindFirstChild("RoundOverlay")
                    and PlayerGui.Shared.HUD.Overlay.Default.RoundOverlay:FindFirstChild("Round")
                
                if round then
                    --Create dummy RoundTimer if it doesn't exist (prevents game errors)
                    if not round:FindFirstChild("RoundTimer") then
                        local dummyTimer = Instance.new("TextLabel")
                        dummyTimer.Name = "RoundTimer"
                        dummyTimer.Parent = round
                        dummyTimer.Visible = false
                        dummyTimer.Text = ""
                    end
                    
                    round.Visible = false
                end
            end)

            --Handle menu intermission timer
            pcall(function()
                local intermissionTimer = PlayerGui:FindFirstChild("Menu")
                    and PlayerGui.Menu:FindFirstChild("IntermissionTimer")
                
                if intermissionTimer then
                    --Create dummy RoundTimer if it doesn't exist (prevents game errors)
                    if not intermissionTimer:FindFirstChild("RoundTimer") then
                        local dummyTimer = Instance.new("TextLabel")
                        dummyTimer.Name = "RoundTimer"
                        dummyTimer.Parent = intermissionTimer
                        dummyTimer.Visible = false
                        dummyTimer.Text = ""
                    end
                    
                    intermissionTimer.Visible = false
                end
            end)

            task.wait(0.5)
        end
    end)

    print("Custom Evade Timer Loaded")
else
    print("This Script Only Works In Evade! If You Have It In Your AutoExec Folder Ignore This!")
end