DOOMSENSE

 Players             = :()
 RunService          = :()
 UserInputService    = :()
 TweenService        = :()
 Workspace           = :()
 CoreGui             = :()
 Lighting            = :()
 ReplicatedStorage   = :()
 StatsService        = :()
 SoundService        = :()
 VirtualInputManager = :()
 Debris              = :()
 TeleportService     = :()
 CollectionService   = :()

 LocalPlayer = Players.LocalPlayer
 Camera      = Workspace.CurrentCamera


 LMS_DIR = 

.(()
     isfolder  makefolder 
          ()  () 
          ()  () 
          ()  () 
          (LMS_DIR)  (LMS_DIR) 
    
)


 Fluent           = (:())()
 SaveManager      = (:())()
 InterfaceManager = (:())()




 SaveManager  SaveManager.Parser 
     SaveManager.Parser.Slider 
        SaveManager.Parser.Slider.Load = (idx, data)
             SaveManager.Options  SaveManager.Options[idx] 
                 numVal = (data.value)
                SaveManager.Options[idx]:(numVal ~=   numVal  data.value)
            
        
    

     oldLoad = SaveManager.Load
    SaveManager.Load = (self, name)
         (name) ==  
            name = name:(, ):()
        
         (self, name)
    



 MODEL_DATABASE = {
    [] = {
        []     = {[] = {[] = {[] = , [] = , [] = }}},
        []   = {[] = {[] = {[] = , [] = , [] = }}},
        []      = {[] = {[] = {[] = , [] = , [] = }}},
        []      = {[] = {[] = {[] = , [] = , [] = }}},
        []     = {
            []  = {[] = {[] = , [] = , [] = }},
            [] = {[] = {[] = , [] = , [] = }}
        },
        []      = {[] = {[] = {[] = , [] = , [] = }}},
        []      = {[] = {[] = {[] = , [] = , [] = }}},
        []        = {[] = {[] = {[] = , [] = , [] = }}},
        [] = {[] = {[] = {[] = , [] = , [] = }}}
    },
    [] = {
        [] = {
            []           = {[] = {[] = ,  [] = , [] = }},
            [] = {[] = {[] = , [] = , [] = }},
            []        = {[] = {[] = ,  [] = , [] = }},
            []          = {[] = {[] = ,  [] = , [] = }},
            []        = {[] = {[] = , [] = , [] = }},
            []          = {[] = {[] = , [] = , [] = }}
        },
        [] = {
            [] = {[] = {[] = , [] = , [] = }},
            []  = {[] = {[] = ,  [] = , [] = }}
        },
        [] = {
            []  = {[] = {[] = , [] = , [] = }},
            [] = {[] = {[] = , [] = , [] = }}
        },
        [] = {
            [] = {[] = {[] = , [] = , [] = }},
            []  = {[] = {[] = , [] = , [] = }},
            []    = {[] = {[] = , [] = , [] = }}
        }
    }
}


 GlobalConfig = {
    IsFlying    = ,
    IsSpeeding  = ,
    FlySpeed    = ,
    WalkSpeed   = ,
    AutoRing    = ,
    NoCDJump    = ,
    
    Main = {
        FlyUpKey    = ,
        FlyDownKey  = ,
        NoclipMode  = ,
    },

    Visuals = {},

    AH = {
        Enabled           = ,
        Mode              = ,
        ManualTarget      = ,
        TargetChar        = ,
        Color             = .(, , ),
        Delay             = ,
        Height            = ,
        Distance          = ,
        RotX              = ,
        RotY              = ,
        RotZ              = ,
        Noclip            = ,
        SmartAttack       = ,
        IndicatorSize     = ,
        IndicatorTransp   = ,
        IndicatorRotate   = ,
        IndicatorSpeed    = ,
        IndicatorDir      = ,
        IndicatorDecal    = ,
        IndicatorCustomID = ,
    },

    Vote = {
        Enabled    = ,
        SurvTarget = ,
        ExeTarget  = ,
        Randomize  = ,
        Delay      = ,
    },

    LMS = {
        Enabled      = ,
        Volume       = ,
        StartDelay   = ,
        StartEffect  = ,
        EffectVolume = ,
        LoopTrack    = ,
        Track        = ,
        ClassTracks  = { Survivor = , EXE =  },
    },

    Anim = {
        AutoDetect  = ,
        CurrentChar = ,
        CurrentName = ,
        MuteSound   = ,
        Volume      = ,
    },

    ShowMobileBtn = ,
}


 GlobalState = {
    ScriptActive    = ,
    SelectedPlayer  = ,
    TeleportBind    = .KeyCode.V,
    UpdateMobileBtn = ,
    CurrentPing     = ,

    Silver = {
        IsRecording = ,
        IsRewinding = ,
        Points      = {},
        LastPos     = ,
        MaxPoints   = ,
        MinDist     = ,
    },

    AH = {
        Target             = ,
        LockedRandomTarget = ,
        LastAttack         = ,
        DownedDB           = {},
        Keys               = {, , , },
        Visual             = ,
        History            = ({}, { __mode =  }),
        ActiveNoclipParts  = {},
    },

    Noclip = {
        ActiveObstacles = {},
        PendingExit     = {},
    },

    Vote = {
        VotedInRound = ,
        Phase        = ,
        Timer        = ,
    },

    ART = {
        HandledThisRound  = ,
        SavedRingCF       = ,
        LastTeleportTime  = ,
    },

    LMS = {
        IsCapturing        = ,
        StopRoutineRunning = ,
        VisualPlayed       = ,
        CachedFolder       = ,
        TrackFinished      = ,
        LmsCounter         = ,
        RoundActive        = 
    },

    Vis = {
        PadCache       = {},
        HighlightCache = {},
        TagCache       = {},
        TrapCache      = {},
        LightCache     = {},
        HasScannedPads = ,
    },

    Anim = {
        Track = ,
        Sound = ,
    },
}

 Options = Fluent.Options
 AHCharDropdownControl   = 
 AnimCharDropdownControl = 
 AnimNameDropdownControl = 


 CachedEscapeZones = {}
 CachedLobbyPos = .(, , )
 LastMapScanState = 


 FX_Gui = 
  ()
      FX_Gui   FX_Gui.Parent 
        FX_Gui = .()
        FX_Gui.Name           = 
        FX_Gui.ResetOnSpawn   = 
        FX_Gui.IgnoreGuiInset = 
        FX_Gui.DisplayOrder   = 
        FX_Gui.Parent         = CoreGui
    
     FX_Gui


  (control, values, defaultVal)
      control  (values) ~=    
    (()
         (control.SetValues) ==  
            control:(values)
         (control.Refresh) ==  
            control:(values)
        
         defaultVal  (control.SetValue) ==  
            control:(defaultVal)
        
    )



 GAME_EXE_NAMES = {
    , , , , ,
    , , , , , ,
    , , , , ,
    , 
}

  (model)
      model   model.Parent    
     charAttr = model:()  model:()
     targetName = .((charAttr  model.Name  ))
     _, k  (GAME_EXE_NAMES) 
         .(targetName, k)    
    
     


 RAGE_IDS = { ,  }
  (model)
      model   model.Parent    
     n = (model:()  model:()  model.Name  )
     .(.(n), ) 
         model:()  model:()  model:(, )  
              
        
         _, s  (SoundService:()) 
             s:()  s.Playing 
                 _, id  (RAGE_IDS)  
                     .(s.SoundId, id)     
                
            
        
    
     


 VoteLists = {
    EXE = { , , ,  },
    Survivor = { , , , , , , , ,  }
}

  ()
     list = {}
     _, v  (Players:()) 
         v ~= LocalPlayer  .(list, v.Name) 
    
     list


  ()
     Workspace:()  Workspace.GameProperties:() 
         Workspace.GameProperties.State.Value
    
     


  ()
     candidates = {
        Workspace:(),
        Workspace:(),
        Workspace:()
    }
     _, parent  (candidates) 
         parent 
             sp = parent:(, )  parent:(, )
             sp  sp:()   sp.CFrame 
        
    
    
     globalSpawn = Workspace:()
     globalSpawn   globalSpawn.CFrame 
    
     .(, , )


  ()
     spawnCF = ()
     spawnCF  CachedLobbyPos = spawnCF.Position 

    .(CachedEscapeZones)
     _, v  (Workspace:()) 
         v:()  v.MeshId ==  
            .(CachedEscapeZones, v.Position)
         v:()  (v.Name ==   v.Name ==   v.Name ==   v.Name == ) 
            .(CachedEscapeZones, v.Position)
        
    

.(UpdateMapCaches)

  (pos)
      pos    
     dist3D = (pos - CachedLobbyPos).Magnitude
     diffY  = .(pos.Y - CachedLobbyPos.Y)
     (dist3D <=   diffY <= )


  (pos)
      pos    
     _, zonePos  (CachedEscapeZones) 
         (zonePos - pos).Magnitude <=     
    
     





 SURVIVOR_CANON_NAMES = {
    [] = , [] = , [] = ,
    [] = , [] = , [] = ,
    [] = , [] = , [] = ,
    [] = , [] = , [] = ,
    [] = 
}

 EXE_CANON_NAMES = {
    [] = , [] = , [] = ,
    [] = , [] = , [] = ,
    [] = , [] = , [] = ,
    [] = , [] = 
}

 EntityInfoCache = ({}, { __mode =  })

  (target)
     plr, char = , 
     (target) ==  
         target:() 
            plr = target
            char = plr.Character
         target:() 
            char = target
            plr = Players:(char)  Players:(char.Name)
        
    

     char  EntityInfoCache[char] 
         EntityInfoCache[char]
    

     isExe = 
     char 
        isExe = (char)  (char:() == )
     plr 
        isExe = (plr.Team  .(.(plr.Team.Name), ))    
    

     rawCharName = 
     char 
         attr = char:()  char:()  char:()
         attr  attr ~=   attr ~=  
            rawCharName = (attr)
        
             valObj = char:()  char:()
             valObj  valObj:()  (valObj.Value) ~=  
                rawCharName = (valObj.Value)
            
        
    

     rawCharName ==   plr  plr:()  plr.leaderstats:() 
        rawCharName = (plr.leaderstats.Character.Value)
    

     canonCharName = 
     cleanKey = .(rawCharName):(, )

     isExe 
         k, canon  (EXE_CANON_NAMES) 
             kClean = .(k):(, )
             cleanKey == kClean 
                canonCharName = canon
                
            
        
          canonCharName 
             k, canon  (EXE_CANON_NAMES) 
                 kClean = .(k):(, )
                 .(cleanKey, kClean, , ) 
                    canonCharName = canon
                    
                
            
        
          canonCharName  canonCharName =  
    
         .(cleanKey, )  .(cleanKey, ) 
            canonCharName = 
         .(cleanKey, )  .(cleanKey, ) 
            canonCharName = 
        
             k, canon  (SURVIVOR_CANON_NAMES) 
                 kClean = .(k):(, )
                 cleanKey == kClean 
                    canonCharName = canon
                    
                
            
              canonCharName 
                 k, canon  (SURVIVOR_CANON_NAMES) 
                     kClean = .(k):(, )
                     .(cleanKey, kClean, , ) 
                        canonCharName = canon
                        
                    
                
            
        
          canonCharName  canonCharName =  
    

     rawPlayerName = (plr  plr.Name  plr.Name ~= )  plr.Name  (isExe    )

     result = {
        Player    = plr,
        Character = char,
        IsEXE     = isExe,
        Role      = isExe    ,
        CharName  = canonCharName,
        RawName   = rawPlayerName,
        UserName  =  .. rawPlayerName
    }

     char 
        EntityInfoCache[char] = result
    

     result


  (target)
     info = (target)
     info.CharName


  (char, player)
     player 
         playersFolder = Workspace:()
         pModel = playersFolder  playersFolder:(player.Name)
         pModel 
             hObj = pModel:()
             hObj 
                 hObj:() 
                     hObj.Value
                 (hObj.Value) ==  
                     hObj.Value
                
            
        
    

     char 
         hObj = char:()
         hObj  hObj:()   hObj.Value 
         hum = char:()
         hum   hum.Health 
    

     


  (player, char)
     escapedFolder = ReplicatedStorage:()
     player  escapedFolder  escapedFolder:(player.Name) 
         
    
     char 
         char:() ==   (char:()  ):() ==  
             
        
         escapedFolder  escapedFolder:(char.Name) 
             
        
    
     


  ()
    .(GlobalState.AH.DownedDB)
     rs = ReplicatedStorage
     ca = rs:()
      ca   
     chars = ca:()
     survFolder = chars  chars:()
     survFolder 
         _, charModel  (survFolder:()) 
             charName = charModel.Name
            GlobalState.AH.DownedDB[charName] = {}
             ss    = charModel:()
             ani   = ss  ss:()
             anims = ani  ani:()
             downed = anims  anims:()
             downed 
                 _, track  (downed:()) 
                     track:()  track.AnimationId 
                        GlobalState.AH.DownedDB[charName][track.AnimationId] = 
                    
                
            
        
    

.(ScanDownedAssets)

  (char, player)
      char   char.Parent    
     CollectionService:(char, )  CollectionService:(char, )  CollectionService:(char, )  CollectionService:(char, )  char:() 
         
    
     char:() ==   char:() ==  
         
    
     


  (char, player)
      char   char.Parent    

     cName = .((char, player))
     .(cName, )  .(cName, ) 
         
    

     char:() ==   char:() ==   char:() ==   
          
    
    
     CollectionService:(char, ) 
         
    

     .(cName, ) 
         hum = char:()
         hum  (hum:() == .HumanoidStateType.Ragdoll  hum:() == .HumanoidStateType.Physics)  char:() ==  
             
        
    

     


  (char, player)
      char   char.Parent    

     char:() ==   char:() ==   CollectionService:(char, )  CollectionService:(char, )  
          
    
     hum = char:()
     hum  hum.Health <=     

     


  (char, player)
      char   char.Parent    
     (char)    

     cName = .((char, player))
     .(cName, )  .(cName, )  .(cName, )  .(cName, ) 
         
    

     char:() ==   CollectionService:(char, ) 
         
    

     downCount = char:()  char:()  
     downCount >=  
         
    

     


  (char, player)
      char   char.Parent   char:(Workspace)    
      player   player.Parent    

     (player, char)    

     root = char:()  char.PrimaryPart
     hum  = char:()
      root   hum  hum.Health <=     

     (char, player)  (char, player)    

     (char)    
     (root.Position)    
     (root.Position)    

     GlobalConfig.AH.ManualTarget  GlobalConfig.AH.TargetChar ~=  
         cName = (char, player)
         cName ~= GlobalConfig.AH.TargetChar    
    

     


  ()
     activeStandingSurvs = {}
     downedOrStunSurvs   = {}
     escapedSurvs        = {}
     activeEXEs          = {}

     escapedFolder = ReplicatedStorage:()
     escapedNames = {}
     escapedFolder 
         _, child  (escapedFolder:()) 
            escapedNames[child.Name] = 
            .(escapedSurvs, child.Name)
        
    

     playersFolder = Workspace:()
     searchList = {}
     playersFolder 
         _, c  (playersFolder:())  .(searchList, c) 
    
     _, p  (Players:()) 
         p.Character   .(searchList, p.Character) 
            .(searchList, p.Character)
        
    

     _, char  (searchList) 
         char:() 
             hum = char:()
             plr = Players:(char)  Players:(char.Name)
             pName = plr  plr.Name  char.Name
             health = (char, plr)

             health >    (char, plr) 
                 root = char:()  char.PrimaryPart
                 rootPos = root  root.Position

                 escapedNames[pName]  (plr, char) 
                      escapedNames[pName] 
                        escapedNames[pName] = 
                        .(escapedSurvs, pName)
                    
                  (rootPos) 
                     isExe = (char)  (char:() == )
                     entInfo = (char)
                     entityData = {
                        Player    = plr,
                        Character = char,
                        Name      = pName,
                        CharName  = entInfo.CharName  (char)
                    }

                     isExe 
                        .(activeEXEs, entityData)
                    
                         isDown = (char, plr)  (char:() == )  CollectionService:(char, )
                         isDown 
                            .(downedOrStunSurvs, entityData)
                        
                            .(activeStandingSurvs, entityData)
                        
                    
                
            
        
    

     activeStandingSurvs, downedOrStunSurvs, escapedSurvs, activeEXEs


  ()
     activeSurvs, _, _, activeEXEs = ()
     activeSurvs, activeEXEs


  ()
     myChar = LocalPlayer.Character
     role = (myChar  (myChar))    
    
     track = GlobalConfig.LMS.ClassTracks  GlobalConfig.LMS.ClassTracks[role]
     track  track ~=   track ~=  
         track
    
    
     


 BodyVel, BodyGyro
  ()
     BodyVel  BodyVel:(); BodyVel =  
     BodyGyro  BodyGyro:(); BodyGyro =  

     char = LocalPlayer.Character
     char 
         hum  = char:()
         root = char:()  char.PrimaryPart
         root  (GlobalConfig.IsFlying  GlobalConfig.IsSpeeding) 
            root.Velocity = .zero
        
         hum  hum.PlatformStand =  
        char:(, )
    


  (toggleId, state)
     Options  Options[toggleId]  (Options[toggleId].SetValue) ==  
        (() Options[toggleId]:(state) )
    


 PriorityList = {
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = , [] = 
}


 Window = Fluent:({
    Title       = ,
    SubTitle    =  .. Fluent.Version,
    TabWidth    = ,
    Size        = .(, ),
    Acrylic     = ,
    Theme       = ,
    MinimizeKey = .KeyCode.Insert
})

 Tabs = {
    Main       = Window:({ Title = ,       Icon =  }),
    Teleport   = Window:({ Title = ,   Icon =  }),
    Combat     = Window:({ Title = ,  Icon =  }),
    AutoVote   = Window:({ Title = ,  Icon =  }),
    Animations = Window:({ Title = , Icon =  }),
    Visuals    = Window:({ Title = ,    Icon =  }),
    NightMode  = Window:({ Title = , Icon =  }),
    LMS        = Window:({ Title = , Icon =  }),
    Mobile     = Window:({ Title = ,     Icon =  }),
    Settings   = Window:({ Title = ,   Icon =  }),
}


 TabMain = Tabs.Main

TabMain:()

TabMain:(, {
    Title       = ,
    Description = ,
    Default     = ,
    Callback    = (v)
        GlobalConfig.IsFlying = v
         v 
             char = LocalPlayer.Character
             char  (char:()  char.PrimaryPart) 
                 root = char:()  char.PrimaryPart
                ()
                BodyVel = .(, root)
                BodyVel.Name = 
                BodyVel.MaxForce = .(, , )
                BodyGyro = .(, root)
                BodyGyro.Name = 
                BodyGyro.MaxTorque = .(, , )
                BodyGyro.P = 
                char:().PlatformStand = 
            
        
            ()
        
         GlobalState.UpdateMobileBtn  GlobalState.(, v) 
    
})

TabMain:(, {
    Title = , Default = , Mode = ,
    Callback = () (,  (Options.FlyTog  Options.FlyTog.Value)) 
})

TabMain:(, {
    Title = , Default = , Min = , Max = , Rounding = ,
    Callback = (v) GlobalConfig.FlySpeed = v 
})

TabMain:(, {
    Title       = ,
    Description = ,
    Values      = { ,  },
    Default     = ,
    Callback    = (v) GlobalConfig.Main.NoclipMode = v 
})

TabMain:()

TabMain:(, {
    Title       = ,
    Description = ,
    Default     = ,
    Callback    = (v)
        GlobalConfig.IsSpeeding = v
         GlobalState.UpdateMobileBtn  GlobalState.(, v) 
    
})

TabMain:(, {
    Title = , Default = , Mode = ,
    Callback = () (,  (Options.SpeedTog  Options.SpeedTog.Value)) 
})

TabMain:(, {
    Title = , Default = , Min = , Max = , Rounding = ,
    Callback = (v) GlobalConfig.WalkSpeed = v 
})

TabMain:()

TabMain:(, {
    Title       = ,
    Description = ,
    Default     = ,
    Callback    = (v)
        GlobalConfig.AutoRing = v
         GlobalState.UpdateMobileBtn  GlobalState.(, v) 
    
})

TabMain:(, {
    Title = , Default = , Mode = ,
    Callback = () (,  (Options.ARTTog  Options.ARTTog.Value)) 
})

TabMain:(, {
    Title       = ,
    Description = ,
    Default     = ,
    Callback    = (v) GlobalConfig.NoCDJump = v 
})


 TabTeleport = Tabs.Teleport

  ()
     spawnCF = ()
     LocalPlayer.Character 
         root = LocalPlayer.Character:()  LocalPlayer.Character.PrimaryPart
         root 
            LocalPlayer.Character:(spawnCF + .(, , ))
            Fluent:({ Title = , Content = , Duration =  })
            
        
    
    Fluent:({ Title = , Content = , Duration =  })


  ()
     GlobalState.SelectedPlayer 
         target = Players:(GlobalState.SelectedPlayer)
         target  target.Character 
             tRoot = target.Character:()  target.Character.PrimaryPart
             tRoot  LocalPlayer.Character 
                 cf = tRoot.CFrame * .(, , )
                LocalPlayer.Character:(cf)
                Fluent:({ Title = , Content =  .. target.Name, Duration =  })
                
            
        
            Fluent:({ Title = , Content = , Duration =  })
            
        
    
    ()


  (cframe, isStart)
     part = .()
    part.Name         = isStart    
    part.Anchored     = 
    part.CanCollide   = 
    part.CanQuery     = 
    part.CastShadow   = 
    part.Transparency = 
    part.Size          = .(, , )
    part.CFrame        = cframe - .(, , )
    part.Parent        = Workspace

     bb = .()
    bb.Adornee         = part
    bb.Parent           = part
    bb.AlwaysOnTop      = 
    bb.LightInfluence   = 
    bb.Size = isStart  .(, , , )  .(, , , )

     img = .()
    img.Parent               = bb
    img.BackgroundTransparency = 
    img.Size                 = .(, )
    img.Image                = isStart    
    img.ImageColor3          = isStart  .(, , )  .(, , )

    TweenService:(img, TweenInfo.(, .EasingStyle.Linear, .EasingDirection.InOut, -), { Rotation =  }):()
     part


  ()
     _, p  (GlobalState.Silver.Points) 
         p  p.Parent  p:() 
    
    GlobalState.Silver.Points = {}
    GlobalState.Silver.LastPos = 


  ()
     S = GlobalState.Silver
     S.IsRewinding  #S.Points ==    
    S.IsRewinding = 
    S.IsRecording = 

     char = LocalPlayer.Character
     root = char  (char:()  char.PrimaryPart)
     root 
        root.Anchored = 
         i = #S.Points, , - 
             pointPart = S.Points[i]
             pointPart  pointPart.Parent 
                root.CFrame = .(pointPart.Position + .(, , ), pointPart.Position + .(, , ) + root.CFrame.LookVector)
                 bb = pointPart:()
                 bb 
                     im = bb:()
                     im 
                        TweenService:(im, TweenInfo.(), { ImageTransparency = , Size = .(, ) }):()
                    
                
                Debris:(pointPart, )
            
            .()
        
        root.Anchored = 
    

    ()
    S.IsRewinding = 
     Options.SilverTog  Options.SilverTog:() 


TabTeleport:()

 PlayerDropdown = TabTeleport:(, {
    Title    = ,
    Values   = (),
    Multi    = ,
    Default  = ,
    Callback = (v) GlobalState.SelectedPlayer = v 
})

TabTeleport:({
    Title    = ,
    Callback = ()
        PlayerDropdown:(())
        PlayerDropdown:()
        GlobalState.SelectedPlayer = 
    
})

TabTeleport:({
    Title       = ,
    Description = ,
    Callback    = SmartTeleport
})

TabTeleport:(, {
    Title    = ,
    Default  = ,
    Mode     = ,
    Callback = () () ,
    ChangedCallback = (New) GlobalState.TeleportBind = New 
})

TabTeleport:({ Title = , Callback = TeleportToLobby })

TabTeleport:()

TabTeleport:(, {
    Title       = ,
    Description = ,
    Default     = ,
    Callback    = (v)
         S = GlobalState.Silver
         v 
             S.IsRewinding   
            ()
            S.IsRecording = 
            S.LastPos = 
            Fluent:({ Title = , Content = , Duration =  })
        
             S.IsRecording  () 
        
         GlobalState.UpdateMobileBtn  GlobalState.(, v) 
    
})

TabTeleport:(, {
    Title = , Default = , Mode = ,
    Callback = ()
         Options.SilverTog  Options.SilverTog:( Options.SilverTog.Value) 
    
})

TabTeleport:(, {
    Title = , Default = , Min = , Max = , Rounding = ,
    Callback = (v) GlobalState.Silver.MaxPoints = v 
})

TabTeleport:(, {
    Title = , Default = , Min = , Max = , Rounding = ,
    Callback = (v) GlobalState.Silver.MinDist = v 
})


 TabVote = Tabs.AutoVote

TabVote:(, {
    Title   = ,
    Default = ,
    Callback = (v) GlobalConfig.Vote.Enabled = v 
})

TabVote:({ Title = , Content =  })
TabVote:(, {
    Title    = ,
    Values   = VoteLists.Survivor,
    Default  = ,
    Callback = (v) GlobalConfig.Vote.SurvTarget = v 
})

TabVote:({ Title = , Content =  })
TabVote:(, {
    Title    = ,
    Values   = VoteLists.EXE,
    Default  = ,
    Callback = (v) GlobalConfig.Vote.ExeTarget = v 
})

TabVote:(, {
    Title       = ,
    Description = ,
    Default     = ,
    Callback    = (v) GlobalConfig.Vote.Randomize = v 
})

TabVote:(, {
    Title    = ,
    Default  = , Min = , Max = , Rounding = ,
    Callback = (v) GlobalConfig.Vote.Delay = v 
})


 TabCombat = Tabs.Combat

 TargetIndicatorPresets = {
    [] = ,
    []   = ,
    []    = ,
    [] = ,
    []    = ,
}

  (force)
     list = {  }
     seen = {}
    
     playersFolder = Workspace:()
     candidates = {}
     playersFolder 
         _, c  (playersFolder:()) 
             c:()  .(candidates, c) 
        
    
     _, p  (Players:()) 
         p ~= LocalPlayer  p.Character   .(candidates, p.Character) 
            .(candidates, p.Character)
        
    

     _, char  (candidates) 
         plr = Players:(char)  Players:(char.Name)
         (char, plr) 
             n = (char, plr)
             n  n ~=    seen[n] 
                .(list, n)
                seen[n] = 
            
        
    

    .(list)
    
     currentVal = GlobalConfig.AH.TargetChar
     validDefault = .(list, currentVal)  currentVal  
    GlobalConfig.AH.TargetChar = validDefault

     listSignature = .(list, )
     force  GlobalState.AH.LastListSignature ~= listSignature 
        GlobalState.AH.LastListSignature = listSignature
        (AHCharDropdownControl, list, validDefault)
    


  ()
     myChar = LocalPlayer.Character
      myChar    
     myRoot = myChar:()  myChar.PrimaryPart
      myRoot    

     myPos = myRoot.Position
     potential = {}

     currentPingMs = GlobalState.CurrentPing  
     leadTime = .((currentPingMs / ) + , , )

     _, p  (Players:()) 
         p ~= LocalPlayer  p.Character 
             char = p.Character
             root = char:()  char.PrimaryPart
             root  (char, p) 
                 charName = (char, p)
                .(potential, {
                    Model    = char,
                    Player   = p,
                    Root     = root,
                    LeadTime = leadTime,
                    Dist     = (root.Position - myPos).Magnitude,
                    Prio     = PriorityList[charName]  
                })
            
        
    

     #potential ==  
        GlobalState.AH.LockedRandomTarget = 
         
    

     mode = GlobalConfig.AH.Mode

     mode ==  
        GlobalState.AH.LockedRandomTarget = 
        .(potential, (a, b)  a.Dist < b.Dist )
         potential[].Model
     mode ==  
        GlobalState.AH.LockedRandomTarget = 
        .(potential, (a, b)
             a.Prio == b.Prio   a.Dist < b.Dist 
             a.Prio > b.Prio
        )
         potential[].Model
     mode ==  
         currentLocked = GlobalState.AH.LockedRandomTarget
         currentLocked 
             lockedPlr = Players:(currentLocked)
             lockedPlr  (currentLocked, lockedPlr) 
                 currentLocked
            
        
        
         newTarget = potential[.(, #potential)].Model
        GlobalState.AH.LockedRandomTarget = newTarget
         newTarget
    

     


  ()
    .(()
        VirtualInputManager:(, , , , , )
        .()
        VirtualInputManager:(, , , , , )

         randKey = GlobalState.AH.Keys[.(, #GlobalState.AH.Keys)]
         kCode   = .KeyCode[randKey]
        VirtualInputManager:(, kCode, , )
        .()
        VirtualInputManager:(, kCode, , )
    )


  (targetRoot)
     V = GlobalState.AH
     AH_Cfg = GlobalConfig.AH
    
      V.Visual 
         bg = .()
        bg.Name        = 
        bg.AlwaysOnTop = 
        bg.Parent      = CoreGui
         img = .(, bg)
        img.Size = .(, )
        img.BackgroundTransparency = 
        V.Visual = { Gui = bg, Img = img, Rot =  }
    

     targetRoot 
        V.Visual.Gui.Enabled = 
        V.Visual.Gui.Adornee = targetRoot
        V.Visual.Gui.Size    = .(AH_Cfg.IndicatorSize, AH_Cfg.IndicatorSize)
        
         finalDecal = TargetIndicatorPresets[AH_Cfg.IndicatorDecal]  
         AH_Cfg.IndicatorDecal ==  
             numID = .(AH_Cfg.IndicatorCustomID, )
             numID  finalDecal =  .. numID 
        
        
        V.Visual.Img.Image = finalDecal
        V.Visual.Img.ImageColor3 = AH_Cfg.Color
        V.Visual.Img.ImageTransparency = .(AH_Cfg.IndicatorTransp / , , )
        
         AH_Cfg.IndicatorRotate 
             dirMultiplier = (AH_Cfg.IndicatorDir == )  -AH_Cfg.IndicatorSpeed  AH_Cfg.IndicatorSpeed
            V.Visual.Rot = V.Visual.Rot + dirMultiplier
            V.Visual.Img.Rotation = V.Visual.Rot
        
    
        V.Visual.Gui.Enabled = 
    


TabCombat:()

TabCombat:(, {
    Title       = ,
    Description = ,
    Default     = ,
    Callback    = (v)
         v 
            ()
             Options.FlyTog  Options.FlyTog.Value  Options.FlyTog:() 
             Options.SpeedTog  Options.SpeedTog.Value  Options.SpeedTog:() 
             GlobalState.UpdateMobileBtn  GlobalState.(, ) 
        
            GlobalState.AH.LockedRandomTarget = 
            ()
             LocalPlayer.Character  (LocalPlayer.Character:()  LocalPlayer.Character.PrimaryPart) 
                 root = LocalPlayer.Character:()  LocalPlayer.Character.PrimaryPart
                root.Velocity = .zero
            
             GlobalState.UpdateMobileBtn  GlobalState.(, ) 
        
        GlobalConfig.AH.Enabled = v
    
})

TabCombat:(, {
    Title = , Default = , Mode = ,
    Callback = ()  Options.AHTog  Options.AHTog:( Options.AHTog.Value)  
})

TabCombat:(, {
    Title       = ,
    Description = ,
    Default     = , Min = -, Max = , Rounding = ,
    Callback    = (v) GlobalConfig.AH.Height = v 
})

TabCombat:(, {
    Title       = ,
    Description = ,
    Default     = , Min = -, Max = , Rounding = ,
    Callback    = (v) GlobalConfig.AH.Distance = v 
})

TabCombat:()

TabCombat:(, {
    Title = , Default = , Min = -, Max = , Rounding = ,
    Callback = (v) GlobalConfig.AH.RotX = v 
})

TabCombat:(, {
    Title = , Default = , Min = -, Max = , Rounding = ,
    Callback = (v) GlobalConfig.AH.RotY = v 
})

TabCombat:(, {
    Title = , Default = , Min = -, Max = , Rounding = ,
    Callback = (v) GlobalConfig.AH.RotZ = v 
})

TabCombat:(, {
    Title       = ,
    Description = ,
    Default     = ,
    Callback    = (v) GlobalConfig.AH.Noclip = v 
})

TabCombat:(, {
    Title       = ,
    Description = ,
    Default     = ,
    Callback    = (v) GlobalConfig.AH.SmartAttack = v 
})

TabCombat:(, {
    Title    = ,
    Values   = { , ,  },
    Default  = ,
    Callback = (v) GlobalConfig.AH.Mode = v 
})

TabCombat:()

TabCombat:(, {
    Title    = ,
    Default  = ,
    Callback = (v) GlobalConfig.AH.ManualTarget = v 
})

AHCharDropdownControl = TabCombat:(, {
    Title    = ,
    Values   = {  },
    Default  = ,
    Callback = (v) GlobalConfig.AH.TargetChar = v 
})

TabCombat:({
    Title       = ,
    Description = ,
    Callback    = ()
        ()
        Fluent:({ Title = , Content = , Duration =  })
    
})

TabCombat:()

TabCombat:(, {
    Title    = ,
    Default  = .(, , ),
    Callback = (v) GlobalConfig.AH.Color = v 
})

TabCombat:(, {
    Title    = ,
    Default  = , Min = , Max = , Rounding = ,
    Callback = (v) GlobalConfig.AH.IndicatorSize = v 
})

TabCombat:(, {
    Title    = ,
    Default  = , Min = , Max = , Rounding = ,
    Callback = (v) GlobalConfig.AH.IndicatorTransp = v 
})

TabCombat:(, {
    Title    = ,
    Values   = { , , , , ,  },
    Default  = ,
    Callback = (v) GlobalConfig.AH.IndicatorDecal = v 
})

TabCombat:(, {
    Title    = ,
    Default  = ,
    Callback = (v) GlobalConfig.AH.IndicatorCustomID = v 
})

TabCombat:(, {
    Title    = ,
    Default  = ,
    Callback = (v) GlobalConfig.AH.IndicatorRotate = v 
})

TabCombat:(, {
    Title    = ,
    Default  = , Min = , Max = , Rounding = ,
    Callback = (v) GlobalConfig.AH.IndicatorSpeed = v 
})

TabCombat:(, {
    Title    = ,
    Values   = { ,  },
    Default  = ,
    Callback = (v) GlobalConfig.AH.IndicatorDir = v 
})


 TabAnim = Tabs.Animations

 AnimDB = {
    [] = {
        { Name = , Id = ,  SoundId =  },
        { Name = , Id = ,  SoundId =  },
        { Name = , Id = ,  SoundId =  }
    },
    [] = {
        { Name = ,   Id = ,  SoundId =  },
        { Name = ,     Id = , SoundId =  },
        { Name = ,      Id = , SoundId =  },
        { Name = ,       Id = , SoundId =  },
        { Name = ,     Id = ,  SoundId =  },
        { Name = ,        Id = , SoundId =  },
        { Name = ,        Id = , SoundId =  },
        { Name = ,   Id = ,  SoundId =  },
        { Name = ,   Id = ,  SoundId =  },
        { Name = ,          Id = , SoundId =  },
        { Name = ,    Id = , SoundId =  },
        { Name = ,   Id = , SoundId =  },
        { Name = ,   Id = ,  SoundId =  },
        { Name = ,      Id = ,  SoundId =  },
    },
    [] = {
        { Name = ,    Id = ,  SoundId =  },
        { Name = ,          Id = , SoundId =  },
        { Name = ,         Id = , SoundId =  },
        { Name = ,     Id = , SoundId =  },
        { Name = ,   Id = ,  SoundId =  },
        { Name = ,          Id = ,  SoundId =  },
        { Name = ,        Id = ,  SoundId =  },
        { Name = ,      Id = ,  SoundId =  },
    },
    [] = {
        { Name = ,    Id = , SoundId =  },
        { Name = ,     Id = ,  SoundId =  },
        { Name = ,         Id = ,  SoundId =  },
        { Name = ,      Id = ,  SoundId =  },
        { Name = ,Id = ,  SoundId =  },
        { Name = ,Id= ,  SoundId =  },
        { Name = ,Id= , SoundId =  },
    },
    [] = {
        { Name = ,       Id = ,  SoundId =  },
        { Name = ,        Id = , SoundId =  },
        { Name = ,Id = , SoundId =  },
        { Name = ,          Id = ,  SoundId =  },
        { Name = ,          Id = , SoundId =  },
        { Name = ,          Id = ,  SoundId =  },
        { Name = ,   Id = ,  SoundId =  },
        { Name = ,          Id = , SoundId =  },
        { Name = ,            Id = ,  SoundId =  },
        { Name = ,         Id = , SoundId =  },
    },
    [] = {
        { Name = ,    Id = , SoundId =  },
        { Name = ,    Id = , SoundId =  },
        { Name = ,    Id = , SoundId =  },
        { Name = ,      Id = , SoundId =  },
        { Name = ,       Id = , SoundId =  },
        { Name = ,       Id = ,  SoundId =  },
    },
    [] = {
        { Name = ,   Id = , SoundId =  },
        { Name = ,       Id = , SoundId =  },
        { Name = ,       Id = , SoundId =  },
        { Name = ,  Id = , SoundId =  },
        { Name = ,     Id = ,  SoundId =  },
        { Name = ,        Id = , SoundId =  },
        { Name = ,    Id = , SoundId =  },
        { Name = ,     Id = , SoundId =  },
    },
    [] = {
        { Name = ,     Id = ,  SoundId =  },
        { Name = , Id = ,  SoundId =  },
        { Name = ,  Id = , SoundId =  },
    },
    [] = {
        { Name = , Id = , SoundId =  },
        { Name = ,    Id = , SoundId =  },
        { Name = ,      Id = , SoundId =  },
    },
    [] = {
        { Name = , Id = , SoundId =  },
        { Name = ,  Id = , SoundId =  },
        { Name = ,       Id = , SoundId =  },
        { Name = ,     Id = , SoundId =  },
        { Name = ,  Id = ,  SoundId =  },
    },
    [] = {
        { Name = , Id = ,  SoundId =  },
        { Name = ,        Id = ,  SoundId =  },
        { Name = ,  Id = , SoundId =  },
    },
    [] = {
        { Name = ,  Id = ,  SoundId =  },
        { Name = ,    Id = , SoundId =  },
        { Name = , Id = , SoundId =  },
        { Name = ,    Id = , SoundId =  },
    },
    [] = {
        { Name = , Id = ,  SoundId =  },
        { Name = ,  Id = ,  SoundId =  },
        { Name = ,   Id = , SoundId =  },
    },
    [] = {
        { Name = , Id = , SoundId =  },
        { Name = ,  Id = ,  SoundId =  },
        { Name = ,      Id = , SoundId =  },
        { Name = ,      Id = ,  SoundId =  },
    },
}

 NameToKey = {
    []     = ,
    []   = ,
    []   = ,
    []        = ,
    []  = ,
}

 CharList = {}
 k, _  (AnimDB)  .(CharList, k) 
.(CharList)

  ()
     A = GlobalState.Anim
     A.Track  A.Track:(); A.Track:(); A.Track =  
     A.Sound  A.Sound:(); A.Sound:(); A.Sound =  


  ()
     A = GlobalState.Anim
     A.Track  () 

     isR6 = (GlobalConfig.Anim.CurrentChar == )
     charKey = isR6    (NameToKey[GlobalConfig.Anim.CurrentChar]  GlobalConfig.Anim.CurrentChar)
     db = AnimDB[charKey]
      db   

     animData = nil
    for _, a in pairs(db) do
        if a.Name == GlobalConfig.Anim.CurrentName then animData = a; break end
    end

    if animData and LocalPlayer.Character then
        local hum  = LocalPlayer.Character:FindFirstChildOfClass("Humanoid")
        local root = LocalPlayer.Character:FindFirstChild("HumanoidRootPart") or LocalPlayer.Character.PrimaryPart
        if hum and root then
            local animator = hum:FindFirstChildOfClass("Animator") or Instance.new("Animator", hum)

            local aObj = Instance.new("Animation")
            aObj.AnimationId = "rbxassetid://" .. animData.Id

            local s, track = pcall(function() return animator:LoadAnimation(aObj) end)
            if s and track then
                A.Track = track
                A.Track.Priority = Enum.AnimationPriority.Action4
                A.Track.Looped = true
                A.Track:Play()

                if animData.SoundId and animData.SoundId ~= "0" then
                    A.Sound = Instance.new("Sound")
                    A.Sound.Name    = "DoomAnimSound"
                    A.Sound.SoundId = "rbxassetid://" .. animData.SoundId
                    A.Sound.Volume  = GlobalConfig.Anim.MuteSound and 0 or GlobalConfig.Anim.Volume
                    A.Sound.Looped  = true
                    A.Sound.Parent  = root
                    A.Sound:Play()
                end

                A.Track.Stopped:Connect(function()
                    if Options.Anim_PlayTog then Options.Anim_PlayTog:SetValue(false) end
                    StopAnim()
                end)
            else
                Fluent:Notify({ Title = "Error", Content = "Invalid Animation ID", Duration = 2 })
                if Options.Anim_PlayTog then Options.Anim_PlayTog:SetValue(false) end
            end
        end
    end
end

TabAnim:AddSection("Animation Controls")

AnimCharDropdownControl = TabAnim:AddDropdown("Anim_Char", {
    Title    = "Character",
    Values   = CharList,
    Default  = "R6",
    Callback = function(v)
        GlobalConfig.Anim.CurrentChar = v
        local key  = NameToKey[v] or v
        local list = {}
        if AnimDB[key] then
            for _, a in pairs(AnimDB[key]) do table.insert(list, a.Name) end
        end
        SafeSetDropdownValues(AnimNameDropdownControl, list, list[1])
    end
})

AnimNameDropdownControl = TabAnim:AddDropdown("Anim_Name", {
    Title    = "Animation",
    Values   = { "Select Char" },
    Default  = "...",
    Callback = function(v)
        GlobalConfig.Anim.CurrentName = v
        if GlobalState.Anim.Track then
            StopAnim()
            PlayAnim()
        end
    end
})

TabAnim:AddToggle("Anim_Auto", {
    Title       = "Auto Detect Character",
    Description = "Updates list on character spawn",
    Default     = false,
    Callback    = function(v) GlobalConfig.Anim.AutoDetect = v end
})

TabAnim:AddToggle("Anim_PlayTog", {
    Title    = "Play Animation",
    Default  = false,
    Callback = function(v)
        if v then PlayAnim() else StopAnim() end
    end
})

TabAnim:AddToggle("Anim_Mute", {
    Title       = "Mute Animation Sound",
    Description = "Disables playing sound entirely",
    Default     = false,
    Callback    = function(v)
        GlobalConfig.Anim.MuteSound = v
        local snd = GlobalState.Anim.Sound
        if v and snd then
            snd.Volume = 0
        elseif not v and snd then
            snd.Volume = GlobalConfig.Anim.Volume
        end
    end
})

TabAnim:AddSlider("Anim_Vol", {
    Title    = "Sound Volume",
    Default  = 2, Min = 0, Max = 6, Rounding = 1,
    Callback = function(v)
        GlobalConfig.Anim.Volume = v
        local snd = GlobalState.Anim.Sound
        if snd and not GlobalConfig.Anim.MuteSound then snd.Volume = v end
    end
})

TabAnim:AddKeybind("Anim_Bind", {
    Title    = "Animation Keybind",
    Default  = "R",
    Mode     = "Toggle",
    Callback = function()
        if Options.Anim_PlayTog then Options.Anim_PlayTog:SetValue(not Options.Anim_PlayTog.Value) end
    end
})

-- UI: Visuals Tab
local TabVisuals    = Tabs.Visuals
local Visuals_Folder = Instance.new("Folder", CoreGui)
Visuals_Folder.Name  = "Doomsense_Vis_Logic"

local VisualsGui = Instance.new("ScreenGui")
VisualsGui.Name           = "Doomsense_2D_Overlay"
VisualsGui.ResetOnSpawn   = false
VisualsGui.IgnoreGuiInset = true
VisualsGui.Parent         = CoreGui

local function ValidateConfig(tbl, defaults)
    for key, value in pairs(defaults) do
        if tbl[key] == nil then
            tbl[key] = value
        elseif type(value) == "table" and type(tbl[key]) == "table" then
            ValidateConfig(tbl[key], value)
        end
    end
end

local VisualsDefaults = {
    Chams = {
        Surv_Enabled  = false,
        Surv_Style    = { Outline = true, Fill = true },
        Surv_OutCol   = Color3.fromRGB(255, 255, 255),
        Surv_FillCol  = Color3.fromRGB(0, 255, 0),
        Surv_Limp_Out = 0, Surv_Limp_Fill = 2,
        
        EXE_Enabled  = false,
        EXE_Style    = { Outline = true, Fill = true },
        EXE_OutCol   = Color3.fromRGB(255, 255, 255),
        EXE_FillCol  = Color3.fromRGB(255, 0, 0),
        EXE_Limp_Out = 0, EXE_Limp_Fill = 2,
    },
    Tripwire = {
        Enabled    = false,
        CustomID   = "",
        Speed      = 5,
        Direction  = "Right",
        RandMin    = 2,
        RandMax    = 5,
        Style      = "Shockwave",
        Size       = 5,
        ScaleMode  = "3D",
        FillCol    = Color3.fromRGB(255, 50, 50),
        LimpFill   = 2,
    },
    TwoD = {
        GlobalLimp          = 0,

        -- 2D Box Visual Settings

        Surv_Box_WOffset = 0,
        Surv_Box_HOffset = 0,
        EXE_Box_WOffset  = 0,
        EXE_Box_HOffset  = 0,

        Surv_Box_Tog        = false,
        Surv_Box_Fill       = Color3.fromRGB(0, 255, 120),
        Surv_Box_Out        = Color3.fromRGB(255, 255, 255),
        Surv_Box_Limp_Fill  = 4,
        Surv_Box_Limp_Out   = 0,

        EXE_Box_Tog         = false,
        EXE_Box_Fill        = Color3.fromRGB(255, 0, 0),
        EXE_Box_Out         = Color3.fromRGB(255, 255, 255),
        EXE_Box_Limp_Fill   = 4,
        EXE_Box_Limp_Out    = 0,

        -- SURV Tags (10 Separate Controls)
        Surv_Role_Tog       = false,
        Surv_Role_Dir       = "Top",
        Surv_Role_Order     = 1,
        Surv_Role_Fill      = Color3.fromRGB(0, 255, 120),
        Surv_Role_Out       = Color3.fromRGB(0, 0, 0),
        Surv_Role_Limp      = 0,

        Surv_Down_Tog       = false,
        Surv_Down_Dir       = "Top",
        Surv_Down_Order     = 3,
        Surv_Down_Fill      = Color3.fromRGB(255, 140, 0),
        Surv_Down_Out       = Color3.fromRGB(255, 255, 255),
        Surv_Down_Limp      = 0,

        Surv_LastLife_Tog   = false,
        Surv_LastLife_Dir   = "Top",
        Surv_LastLife_Order = 4,
        Surv_LastLife_Fill  = Color3.fromRGB(255, 220, 0),
        Surv_LastLife_Out   = Color3.fromRGB(0, 0, 0),
        Surv_LastLife_Limp  = 0,

        Surv_Dead_Tog       = false,
        Surv_Dead_Dir       = "Top",
        Surv_Dead_Order     = 6,
        Surv_Dead_Fill      = Color3.fromRGB(120, 120, 120),
        Surv_Dead_Out       = Color3.fromRGB(0, 0, 0),
        Surv_Dead_Limp      = 0,

        Surv_CharName_Tog   = false,
        Surv_CharName_Dir   = "Top",
        Surv_CharName_Order = 7,
        Surv_CharName_Fill  = Color3.fromRGB(0, 255, 255),
        Surv_CharName_Out   = Color3.fromRGB(0, 0, 0),
        Surv_CharName_Limp = 0,

        Surv_UserName_Tog   = false,
        Surv_UserName_Dir   = "Top",
        Surv_UserName_Order = 8,
        Surv_UserName_Fill  = Color3.fromRGB(255, 255, 255),
        Surv_UserName_Out   = Color3.fromRGB(0, 0, 0),
        Surv_UserName_Limp = 0,

        Surv_Dist_Tog       = false,
        Surv_Dist_Dir       = "Bottom",
        Surv_Dist_Order     = 1,
        Surv_Dist_Fill      = Color3.fromRGB(255, 255, 255),
        Surv_Dist_Out       = Color3.fromRGB(0, 0, 0),
        Surv_Dist_Limp      = 0,

        -- EXE Tags (10 Separate Controls)
        EXE_Role_Tog        = false,
        EXE_Role_Dir        = "Top",
        EXE_Role_Order      = 1,
        EXE_Role_Fill       = Color3.fromRGB(255, 0, 0),
        EXE_Role_Out        = Color3.fromRGB(0, 0, 0),
        EXE_Role_Limp       = 0,

        EXE_Rage_Tog        = false,
        EXE_Rage_Dir        = "Top",
        EXE_Rage_Order      = 2,
        EXE_Rage_Fill       = Color3.fromRGB(255, 140, 0),
        EXE_Rage_Out        = Color3.fromRGB(255, 255, 0),
        EXE_Rage_Limp       = 0,

        EXE_Stun_Tog        = false,
        EXE_Stun_Dir        = "Top",
        EXE_Stun_Order      = 3,
        EXE_Stun_Fill       = Color3.fromRGB(170, 0, 255),
        EXE_Stun_Out        = Color3.fromRGB(255, 255, 255),
        EXE_Stun_Limp       = 0,

        EXE_Dead_Tog        = false,
        EXE_Dead_Dir        = "Top",
        EXE_Dead_Order      = 4,
        EXE_Dead_Fill       = Color3.fromRGB(120, 120, 120),
        EXE_Dead_Out        = Color3.fromRGB(0, 0, 0),
        EXE_Dead_Limp       = 0,

        EXE_CharName_Tog    = false,
        EXE_CharName_Dir    = "Top",
        EXE_CharName_Order  = 5,
        EXE_CharName_Fill   = Color3.fromRGB(255, 100, 100),
        EXE_CharName_Out    = Color3.fromRGB(0, 0, 0),
        EXE_CharName_Limp  = 0,

        EXE_UserName_Tog    = false,
        EXE_UserName_Dir    = "Top",
        EXE_UserName_Order  = 6,
        EXE_UserName_Fill   = Color3.fromRGB(255, 200, 200),
        EXE_UserName_Out    = Color3.fromRGB(0, 0, 0),
        EXE_UserName_Limp  = 0,

        EXE_Dist_Tog        = false,
        EXE_Dist_Dir        = "Bottom",
        EXE_Dist_Order      = 1,
        EXE_Dist_Fill       = Color3.fromRGB(255, 0, 0),
        EXE_Dist_Out        = Color3.fromRGB(0, 0, 0),
        EXE_Dist_Limp       = 0,
    },
    Distance = {},
    Pad = {
        Enabled  = false,
        Style    = { Outline = true, Fill = true },
        OutCol   = Color3.fromRGB(255, 255, 0),
        FillCol  = Color3.fromRGB(255, 255, 0),
        Limp_Out = 0, Limp_Fill = 2,
    },
    Night = {
        Enabled      = false,
        AmbCol       = Color3.fromRGB(50, 50, 80),
        lightCol     = Color3.fromRGB(0, 0, 0),
        
        -- Lights
        ModifyLights = false,
        LightBright  = 2,
        LightColor   = Color3.fromRGB(255, 255, 255),
        
        -- Fog
        FogEnabled   = false,
        FogColor     = Color3.fromRGB(50, 50, 80),
        FogDensity   = 2.5,
    },
    Local = {
        Enabled  = false,
        Style    = { Outline = true, Fill = true },
        OutCol   = Color3.fromRGB(255, 255, 255),
        FillCol  = Color3.fromRGB(100, 100, 255),
        Limp_Out = 0, Limp_Fill = 2,
    },
}

ValidateConfig(GlobalConfig.Visuals, VisualsDefaults)
local Cfg = GlobalConfig.Visuals

-- ═══════════════════════════════════════════════════════════════════════════
-- WORLD ATMOSPHERE & FOG CONTROLLER
-- ═══════════════════════════════════════════════════════════════════════════
local function UpdateWorldLights()
    local nCfg = (GlobalConfig and GlobalConfig.Visuals and GlobalConfig.Visuals.Night) or (Cfg and Cfg.Night)
    if not nCfg then return end
    local cache = GlobalState.Vis.LightCache

    for light, _ in pairs(cache) do
        if not light or not light.Parent then
            cache[light] = nil
        end
    end

    if nCfg.ModifyLights then
        Lighting.Brightness = tonumber(nCfg.LightBright) or 2
        for _, light in ipairs(Workspace:GetDescendants()) do
            if light:IsA("PointLight") or light:IsA("SpotLight") or light:IsA("SurfaceLight") then
                if not cache[light] then
                    cache[light] = {
                        Color      = light.Color,
                        Brightness = light.Brightness,
                    }
                end
                light.Color      = nCfg.LightColor or Color3.fromRGB(255, 255, 255)
                light.Brightness = tonumber(nCfg.LightBright) or 2
            end
        end
    else
        Lighting.Brightness = 1
        for light, orig in pairs(cache) do
            if light and light.Parent then
                pcall(function()
                    light.Color      = orig.Color
                    light.Brightness = orig.Brightness
                end)
            end
        end
        table.clear(cache)
    end
end

local function ApplyAtmosphereAndFog()
    local nCfg = (GlobalConfig and GlobalConfig.Visuals and GlobalConfig.Visuals.Night) or (Cfg and Cfg.Night)
    if not nCfg then return end

    if nCfg.Enabled then
        Lighting.TimeOfDay      = "00:00:00"
        Lighting.Ambient        = nCfg.AmbCol or Color3.fromRGB(50, 50, 80)
        Lighting.OutdoorAmbient = nCfg.lightCol or Color3.fromRGB(0, 0, 0)
    else
        Lighting.TimeOfDay      = "12:00:00"
        Lighting.Ambient        = Color3.fromRGB(128, 128, 128)
        Lighting.OutdoorAmbient = Color3.fromRGB(128, 128, 128)
    end

    local atmosphere = Lighting:FindFirstChildOfClass("Atmosphere")
    if nCfg.FogEnabled then
        local fogCol = nCfg.FogColor or Color3.fromRGB(50, 50, 80)
        Lighting.FogColor = fogCol
        Lighting.FogStart = 0
        Lighting.FogEnd   = 350

        if not atmosphere then
            atmosphere = Instance.new("Atmosphere")
            atmosphere.Parent = Lighting
        end
        local densityVal = tonumber(nCfg.FogDensity) or 2.5
        atmosphere.Density = math.clamp(densityVal / 5, 0, 1)
        atmosphere.Color   = fogCol
        atmosphere.Decay   = fogCol
        atmosphere.Offset  = 0.25
        atmosphere.Glare   = 0
        atmosphere.Haze    = 1
    else
        Lighting.FogEnd = 9e9
        if atmosphere then
            atmosphere.Density = 0
        end
    end
end

local function GetTrans(sliderVal, isEnabled)
    if not isEnabled then return 1 end
    return math.clamp(sliderVal / 5, 0, 1)
end

local function GetHighlight(model)
    local cache = GlobalState.Vis.HighlightCache
    if not cache[model] or not cache[model].Parent then
        local hl = Instance.new("Highlight")
        hl.Name = "Doom_Highlight"
        hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
        hl.Adornee = model
        hl.Parent = Visuals_Folder
        cache[model] = hl
    end
    return cache[model]
end

local function GetModelStudSize(charModel)
    local charName = charModel:GetAttribute("Character") or charModel:GetAttribute("CharName") or charModel.Name
    local skinName = charModel:GetAttribute("Skin") or charModel:GetAttribute("SkinName") or "Default"

    for _, category in ipairs({"EXE", "Survivors"}) do
        local catData = MODEL_DATABASE[category]
        if catData and catData[charName] then
            local charData = catData[charName]
            if charData[skinName] and charData[skinName].Studs then
                local s = charData[skinName].Studs
                return Vector3.new(s.X, s.Y, s.Z)
            elseif charData["Default"] and charData["Default"].Studs then
                local s = charData["Default"].Studs
                return Vector3.new(s.X, s.Y, s.Z)
            end
        end
    end

    return charModel:GetExtentsSize()
end

local function GetTags(model)
    local cache = GlobalState.Vis.TagCache
    if not cache[model] or not cache[model].BoxFrame or not cache[model].BoxFrame.Parent then
        local boxFrame = Instance.new("Frame")
        boxFrame.Name                   = "Doom_2D_Box"
        boxFrame.BackgroundTransparency  = 1
        boxFrame.BorderSizePixel        = 0
        boxFrame.Visible                = false
        boxFrame.Position               = UDim2.fromOffset(-5000, -5000)
        boxFrame.Size                   = UDim2.fromOffset(0, 0)
        boxFrame.Parent                 = VisualsGui

        local boxStroke = Instance.new("UIStroke", boxFrame)
        boxStroke.Name         = "BoxStroke"
        boxStroke.Thickness    = 1.5
        boxStroke.Transparency = 1

        local function MakeHolder(name, anchor, pos, hAlign, vAlign)
            local h = Instance.new("Frame", boxFrame)
            h.Name                  = name
            h.BackgroundTransparency = 1
            h.AnchorPoint           = anchor
            h.Position              = pos
            h.Size                  = UDim2.new(0, 200, 0, 0)
            h.AutomaticSize         = Enum.AutomaticSize.Y

            local layout = Instance.new("UIListLayout", h)
            layout.SortOrder            = Enum.SortOrder.LayoutOrder
            layout.HorizontalAlignment  = hAlign
            layout.VerticalAlignment    = vAlign
            layout.Padding              = UDim.new(0, 1)
            return h
        end

        local topHolder   = MakeHolder("TopHolder",   Vector2.new(0.5, 1), UDim2.new(0.5, 0, 0, -4), Enum.HorizontalAlignment.Center, Enum.VerticalAlignment.Bottom)
        local botHolder   = MakeHolder("BottomHolder",Vector2.new(0.5, 0), UDim2.new(0.5, 0, 1, 4),  Enum.HorizontalAlignment.Center, Enum.VerticalAlignment.Top)
        local leftHolder  = MakeHolder("LeftHolder",  Vector2.new(1, 0),   UDim2.new(0, -2, 0, 0),    Enum.HorizontalAlignment.Right,  Enum.VerticalAlignment.Top)
        local rightHolder = MakeHolder("RightHolder", Vector2.new(0, 0),   UDim2.new(1, 2, 0, 0),     Enum.HorizontalAlignment.Left,   Enum.VerticalAlignment.Top)

        local function CreateTagLabel(name)
            local lbl = Instance.new("TextLabel")
            lbl.Name                  = name
            lbl.Text                  = ""
            lbl.BackgroundTransparency = 1
            lbl.Font                  = Enum.Font.GothamBold
            lbl.TextSize              = 12
            lbl.TextStrokeTransparency = 0
            lbl.Size                  = UDim2.new(1, 0, 0, 14)
            lbl.Visible               = false
            return lbl
        end

        cache[model] = {
            BoxFrame  = boxFrame,
            BoxStroke = boxStroke,
            Holders   = {
                Top    = topHolder,
                Bottom = botHolder,
                Left   = leftHolder,
                Right  = rightHolder,
            },
            SURV = {
                Role     = CreateTagLabel("SURV_Role"),
                Down     = CreateTagLabel("SURV_Down"),
                LastLife = CreateTagLabel("SURV_LastLife"),
                Dead     = CreateTagLabel("SURV_Dead"),
                CharName = CreateTagLabel("SURV_CharName"),
                UserName = CreateTagLabel("SURV_UserName"),
                Dist     = CreateTagLabel("SURV_Dist"),
            },
            EXE = {
                Role     = CreateTagLabel("EXE_Role"),
                Rage     = CreateTagLabel("EXE_Rage"),
                Stun     = CreateTagLabel("EXE_Stun"),
                Dead     = CreateTagLabel("EXE_Dead"),
                CharName = CreateTagLabel("EXE_CharName"),
                UserName = CreateTagLabel("EXE_UserName"),
                Dist     = CreateTagLabel("EXE_Dist"),
            }
        }
    end
    return cache[model]
end

local SecChams = TabVisuals:AddSection("Chams (Wallhack)")
SecChams:AddParagraph({ Title = "Survivor Chams", Content = "" })
SecChams:AddToggle("Chams_S_Tog", { Title = "Enable Survivor Chams", Default = Cfg.Chams.Surv_Enabled, Callback = function(v) Cfg.Chams.Surv_Enabled = v end })
SecChams:AddDropdown("Chams_S_Style", { Title = "Survivor Style Options", Values = {"Outline","Fill"}, Multi = true, Default = {"Outline","Fill"}, Callback = function(v) Cfg.Chams.Surv_Style = v end })
SecChams:AddColorpicker("Chams_S_Out",  { Title = "Surv Outline Color", Default = Cfg.Chams.Surv_OutCol, Callback = function(v) Cfg.Chams.Surv_OutCol = v end })
SecChams:AddColorpicker("Chams_S_Fill", { Title = "Surv Fill Color",    Default = Cfg.Chams.Surv_FillCol, Callback = function(v) Cfg.Chams.Surv_FillCol = v end })
SecChams:AddSlider("Chams_S_LO", { Title = "Surv Outline Transparency", Min = 0, Max = 5, Default = Cfg.Chams.Surv_Limp_Out, Rounding = 1, Callback = function(v) Cfg.Chams.Surv_Limp_Out = v end })
SecChams:AddSlider("Chams_S_LF", { Title = "Surv Fill Transparency",    Min = 0, Max = 5, Default = Cfg.Chams.Surv_Limp_Fill, Rounding = 1, Callback = function(v) Cfg.Chams.Surv_Limp_Fill = v end })

SecChams:AddParagraph({ Title = "EXE Chams", Content = "" })
SecChams:AddToggle("Chams_E_Tog", { Title = "Enable EXE Chams", Default = Cfg.Chams.EXE_Enabled, Callback = function(v) Cfg.Chams.EXE_Enabled = v end })
SecChams:AddDropdown("Chams_E_Style", { Title = "EXE Style Options", Values = {"Outline","Fill"}, Multi = true, Default = {"Outline","Fill"}, Callback = function(v) Cfg.Chams.EXE_Style = v end })
SecChams:AddColorpicker("Chams_E_Out",  { Title = "EXE Outline Color", Default = Cfg.Chams.EXE_OutCol, Callback = function(v) Cfg.Chams.EXE_OutCol = v end })
SecChams:AddColorpicker("Chams_E_Fill", { Title = "EXE Fill Color",    Default = Cfg.Chams.EXE_FillCol, Callback = function(v) Cfg.Chams.EXE_FillCol = v end })
SecChams:AddSlider("Chams_E_LO", { Title = "EXE Outline Transparency", Min = 0, Max = 5, Default = Cfg.Chams.EXE_Limp_Out, Rounding = 1, Callback = function(v) Cfg.Chams.EXE_Limp_Out = v end })
SecChams:AddSlider("Chams_E_LF", { Title = "EXE Fill Transparency",    Min = 0, Max = 5, Default = Cfg.Chams.EXE_Limp_Fill, Rounding = 1, Callback = function(v) Cfg.Chams.EXE_Limp_Fill = v end })

local Sec2D = TabVisuals:AddSection("2D Box & Tags System")
Sec2D:AddSlider("2D_GlobalLimp", { Title = "Global Text Transparency", Min = 0, Max = 5, Default = Cfg.TwoD.GlobalLimp, Rounding = 1, Callback = function(v) Cfg.TwoD.GlobalLimp = v end })

local DirValues = { "Top", "Bottom", "Left", "Right" }

-- SURVIVOR 2D BOX & TAGS

Sec2D:AddSlider("S_Box_WOffset", { Title = "Survivor Box Width Offset", Min = -15, Max = 15, Default = 0, Rounding = 1, Callback = function(v) Cfg.TwoD.Surv_Box_WOffset = v end })
Sec2D:AddSlider("S_Box_HOffset", { Title = "Survivor Box Height Offset", Min = -15, Max = 15, Default = 0, Rounding = 1, Callback = function(v) Cfg.TwoD.Surv_Box_HOffset = v end })

Sec2D:AddParagraph({ Title = "Survivor 2D Box Visual", Content = "" })
Sec2D:AddToggle("S_Box_Tog", { Title = "Enable Survivor 2D Box", Default = Cfg.TwoD.Surv_Box_Tog, Callback = function(v) Cfg.TwoD.Surv_Box_Tog = v end })
Sec2D:AddColorpicker("S_Box_Fill", { Title = "Box Fill Color", Default = Cfg.TwoD.Surv_Box_Fill, Callback = function(v) Cfg.TwoD.Surv_Box_Fill = v end })
Sec2D:AddColorpicker("S_Box_Out",  { Title = "Box Outline Color", Default = Cfg.TwoD.Surv_Box_Out, Callback = function(v) Cfg.TwoD.Surv_Box_Out = v end })
Sec2D:AddSlider("S_Box_Limp_Fill", { Title = "Fill Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.Surv_Box_Limp_Fill, Rounding = 1, Callback = function(v) Cfg.TwoD.Surv_Box_Limp_Fill = v end })
Sec2D:AddSlider("S_Box_Limp_Out",  { Title = "Outline Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.Surv_Box_Limp_Out, Rounding = 1, Callback = function(v) Cfg.TwoD.Surv_Box_Limp_Out = v end })

Sec2D:AddParagraph({ Title = "Survivor Tag: SURV", Content = "" })
Sec2D:AddToggle("S_Role_Tog", { Title = "Show SURV Tag", Default = Cfg.TwoD.Surv_Role_Tog, Callback = function(v) Cfg.TwoD.Surv_Role_Tog = v end })
Sec2D:AddDropdown("S_Role_Dir", { Title = "Placement Direction", Values = DirValues, Default = Cfg.TwoD.Surv_Role_Dir, Callback = function(v) Cfg.TwoD.Surv_Role_Dir = v end })
Sec2D:AddSlider("S_Role_Order", { Title = "Queue Order", Min = 1, Max = 10, Default = Cfg.TwoD.Surv_Role_Order, Rounding = 0, Callback = function(v) Cfg.TwoD.Surv_Role_Order = v end })
Sec2D:AddColorpicker("S_Role_Fill", { Title = "SURV Color", Default = Cfg.TwoD.Surv_Role_Fill, Callback = function(v) Cfg.TwoD.Surv_Role_Fill = v end })
Sec2D:AddColorpicker("S_Role_Out",  { Title = "SURV Outline", Default = Cfg.TwoD.Surv_Role_Out, Callback = function(v) Cfg.TwoD.Surv_Role_Out = v end })
Sec2D:AddSlider("S_Role_Limp", { Title = "SURV Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.Surv_Role_Limp, Rounding = 1, Callback = function(v) Cfg.TwoD.Surv_Role_Limp = v end })

Sec2D:AddParagraph({ Title = "Survivor Tag: DOWN", Content = "" })
Sec2D:AddToggle("S_Down_Tog", { Title = "Show DOWN Tag", Default = Cfg.TwoD.Surv_Down_Tog, Callback = function(v) Cfg.TwoD.Surv_Down_Tog = v end })
Sec2D:AddDropdown("S_Down_Dir", { Title = "Placement Direction", Values = DirValues, Default = Cfg.TwoD.Surv_Down_Dir, Callback = function(v) Cfg.TwoD.Surv_Down_Dir = v end })
Sec2D:AddSlider("S_Down_Order", { Title = "Queue Order", Min = 1, Max = 10, Default = Cfg.TwoD.Surv_Down_Order, Rounding = 0, Callback = function(v) Cfg.TwoD.Surv_Down_Order = v end })
Sec2D:AddColorpicker("S_Down_Fill", { Title = "DOWN Color", Default = Cfg.TwoD.Surv_Down_Fill, Callback = function(v) Cfg.TwoD.Surv_Down_Fill = v end })
Sec2D:AddColorpicker("S_Down_Out",  { Title = "DOWN Outline", Default = Cfg.TwoD.Surv_Down_Out, Callback = function(v) Cfg.TwoD.Surv_Down_Out = v end })
Sec2D:AddSlider("S_Down_Limp", { Title = "DOWN Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.Surv_Down_Limp, Rounding = 1, Callback = function(v) Cfg.TwoD.Surv_Down_Limp = v end })

Sec2D:AddParagraph({ Title = "Survivor Tag: LAST LIFE", Content = "" })
Sec2D:AddToggle("S_LastLife_Tog", { Title = "Show LAST LIFE Tag", Default = Cfg.TwoD.Surv_LastLife_Tog, Callback = function(v) Cfg.TwoD.Surv_LastLife_Tog = v end })
Sec2D:AddDropdown("S_LastLife_Dir", { Title = "Placement Direction", Values = DirValues, Default = Cfg.TwoD.Surv_LastLife_Dir, Callback = function(v) Cfg.TwoD.Surv_LastLife_Dir = v end })
Sec2D:AddSlider("S_LastLife_Order", { Title = "Queue Order", Min = 1, Max = 10, Default = Cfg.TwoD.Surv_LastLife_Order, Rounding = 0, Callback = function(v) Cfg.TwoD.Surv_LastLife_Order = v end })
Sec2D:AddColorpicker("S_LastLife_Fill", { Title = "LAST LIFE Color", Default = Cfg.TwoD.Surv_LastLife_Fill, Callback = function(v) Cfg.TwoD.Surv_LastLife_Fill = v end })
Sec2D:AddColorpicker("S_LastLife_Out",  { Title = "LAST LIFE Outline", Default = Cfg.TwoD.Surv_LastLife_Out, Callback = function(v) Cfg.TwoD.Surv_LastLife_Out = v end })
Sec2D:AddSlider("S_LastLife_Limp", { Title = "LAST LIFE Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.Surv_LastLife_Limp, Rounding = 1, Callback = function(v) Cfg.TwoD.Surv_LastLife_Limp = v end })

Sec2D:AddParagraph({ Title = "Survivor Tag: DEAD", Content = "" })
Sec2D:AddToggle("S_Dead_Tog", { Title = "Show DEAD Tag", Default = Cfg.TwoD.Surv_Dead_Tog, Callback = function(v) Cfg.TwoD.Surv_Dead_Tog = v end })
Sec2D:AddDropdown("S_Dead_Dir", { Title = "Placement Direction", Values = DirValues, Default = Cfg.TwoD.Surv_Dead_Dir, Callback = function(v) Cfg.TwoD.Surv_Dead_Dir = v end })
Sec2D:AddSlider("S_Dead_Order", { Title = "Queue Order", Min = 1, Max = 10, Default = Cfg.TwoD.Surv_Dead_Order, Rounding = 0, Callback = function(v) Cfg.TwoD.Surv_Dead_Order = v end })
Sec2D:AddColorpicker("S_Dead_Fill", { Title = "DEAD Color", Default = Cfg.TwoD.Surv_Dead_Fill, Callback = function(v) Cfg.TwoD.Surv_Dead_Fill = v end })
Sec2D:AddColorpicker("S_Dead_Out",  { Title = "DEAD Outline", Default = Cfg.TwoD.Surv_Dead_Out, Callback = function(v) Cfg.TwoD.Surv_Dead_Out = v end })
Sec2D:AddSlider("S_Dead_Limp", { Title = "DEAD Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.Surv_Dead_Limp, Rounding = 1, Callback = function(v) Cfg.TwoD.Surv_Dead_Limp = v end })

Sec2D:AddParagraph({ Title = "Survivor Tag: Character Name", Content = "" })
Sec2D:AddToggle("S_CharName_Tog", { Title = "Show Character Name", Default = Cfg.TwoD.Surv_CharName_Tog, Callback = function(v) Cfg.TwoD.Surv_CharName_Tog = v end })
Sec2D:AddDropdown("S_CharName_Dir", { Title = "Placement Direction", Values = DirValues, Default = Cfg.TwoD.Surv_CharName_Dir, Callback = function(v) Cfg.TwoD.Surv_CharName_Dir = v end })
Sec2D:AddSlider("S_CharName_Order", { Title = "Queue Order", Min = 1, Max = 10, Default = Cfg.TwoD.Surv_CharName_Order, Rounding = 0, Callback = function(v) Cfg.TwoD.Surv_CharName_Order = v end })
Sec2D:AddColorpicker("S_CharName_Fill", { Title = "Name Color", Default = Cfg.TwoD.Surv_CharName_Fill, Callback = function(v) Cfg.TwoD.Surv_CharName_Fill = v end })
Sec2D:AddColorpicker("S_CharName_Out",  { Title = "Name Outline", Default = Cfg.TwoD.Surv_CharName_Out, Callback = function(v) Cfg.TwoD.Surv_CharName_Out = v end })
Sec2D:AddSlider("S_CharName_Limp", { Title = "Name Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.Surv_CharName_Limp, Rounding = 1, Callback = function(v) Cfg.TwoD.Surv_CharName_Limp = v end })

Sec2D:AddParagraph({ Title = "Survivor Tag: Player Nickname", Content = "" })
Sec2D:AddToggle("S_UserName_Tog", { Title = "Show @Username", Default = Cfg.TwoD.Surv_UserName_Tog, Callback = function(v) Cfg.TwoD.Surv_UserName_Tog = v end })
Sec2D:AddDropdown("S_UserName_Dir", { Title = "Placement Direction", Values = DirValues, Default = Cfg.TwoD.Surv_UserName_Dir, Callback = function(v) Cfg.TwoD.Surv_UserName_Dir = v end })
Sec2D:AddSlider("S_UserName_Order", { Title = "Queue Order", Min = 1, Max = 10, Default = Cfg.TwoD.Surv_UserName_Order, Rounding = 0, Callback = function(v) Cfg.TwoD.Surv_UserName_Order = v end })
Sec2D:AddColorpicker("S_UserName_Fill", { Title = "@User Color", Default = Cfg.TwoD.Surv_UserName_Fill, Callback = function(v) Cfg.TwoD.Surv_UserName_Fill = v end })
Sec2D:AddColorpicker("S_UserName_Out",  { Title = "@User Outline", Default = Cfg.TwoD.Surv_UserName_Out, Callback = function(v) Cfg.TwoD.Surv_UserName_Out = v end })
Sec2D:AddSlider("S_UserName_Limp", { Title = "@User Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.Surv_UserName_Limp, Rounding = 1, Callback = function(v) Cfg.TwoD.Surv_UserName_Limp = v end })

Sec2D:AddParagraph({ Title = "Survivor Tag: Distance", Content = "" })
Sec2D:AddToggle("Dist_S_Tog", { Title = "Show Distance Tag", Default = Cfg.TwoD.Surv_Dist_Tog, Callback = function(v) Cfg.TwoD.Surv_Dist_Tog = v end })
Sec2D:AddDropdown("Dist_S_Dir", { Title = "Placement Direction", Values = DirValues, Default = Cfg.TwoD.Surv_Dist_Dir, Callback = function(v) Cfg.TwoD.Surv_Dist_Dir = v end })
Sec2D:AddSlider("Dist_S_Order", { Title = "Queue Order", Min = 1, Max = 10, Default = Cfg.TwoD.Surv_Dist_Order, Rounding = 0, Callback = function(v) Cfg.TwoD.Surv_Dist_Order = v end })
Sec2D:AddColorpicker("Dist_S_Fill", { Title = "Distance Color", Default = Cfg.TwoD.Surv_Dist_Fill, Callback = function(v) Cfg.TwoD.Surv_Dist_Fill = v end })
Sec2D:AddColorpicker("Dist_S_Out",  { Title = "Distance Outline", Default = Cfg.TwoD.Surv_Dist_Out, Callback = function(v) Cfg.TwoD.Surv_Dist_Out = v end })
Sec2D:AddSlider("Dist_S_Limp", { Title = "Distance Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.Surv_Dist_Limp, Rounding = 1, Callback = function(v) Cfg.TwoD.Surv_Dist_Limp = v end })

-- EXE 2D BOX & TAGS

Sec2D:AddSlider("E_Box_WOffset", { Title = "EXE Box Width Offset", Min = -15, Max = 15, Default = 0, Rounding = 1, Callback = function(v) Cfg.TwoD.EXE_Box_WOffset = v end })
Sec2D:AddSlider("E_Box_HOffset", { Title = "EXE Box Height Offset", Min = -15, Max = 15, Default = 0, Rounding = 1, Callback = function(v) Cfg.TwoD.EXE_Box_HOffset = v end })

Sec2D:AddParagraph({ Title = "EXE 2D Box Visual", Content = "" })
Sec2D:AddToggle("E_Box_Tog", { Title = "Enable EXE 2D Box", Default = Cfg.TwoD.EXE_Box_Tog, Callback = function(v) Cfg.TwoD.EXE_Box_Tog = v end })
Sec2D:AddColorpicker("E_Box_Fill", { Title = "Box Fill Color", Default = Cfg.TwoD.EXE_Box_Fill, Callback = function(v) Cfg.TwoD.EXE_Box_Fill = v end })
Sec2D:AddColorpicker("E_Box_Out",  { Title = "Box Outline Color", Default = Cfg.TwoD.EXE_Box_Out, Callback = function(v) Cfg.TwoD.EXE_Box_Out = v end })
Sec2D:AddSlider("E_Box_Limp_Fill", { Title = "Fill Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.EXE_Box_Limp_Fill, Rounding = 1, Callback = function(v) Cfg.TwoD.EXE_Box_Limp_Fill = v end })
Sec2D:AddSlider("E_Box_Limp_Out",  { Title = "Outline Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.EXE_Box_Limp_Out, Rounding = 1, Callback = function(v) Cfg.TwoD.EXE_Box_Limp_Out = v end })

Sec2D:AddParagraph({ Title = "EXE Tag: EXE", Content = "" })
Sec2D:AddToggle("E_Role_Tog", { Title = "Show EXE Tag", Default = Cfg.TwoD.EXE_Role_Tog, Callback = function(v) Cfg.TwoD.EXE_Role_Tog = v end })
Sec2D:AddDropdown("E_Role_Dir", { Title = "Placement Direction", Values = DirValues, Default = Cfg.TwoD.EXE_Role_Dir, Callback = function(v) Cfg.TwoD.EXE_Role_Dir = v end })
Sec2D:AddSlider("E_Role_Order", { Title = "Queue Order", Min = 1, Max = 10, Default = Cfg.TwoD.EXE_Role_Order, Rounding = 0, Callback = function(v) Cfg.TwoD.EXE_Role_Order = v end })
Sec2D:AddColorpicker("E_Role_Fill", { Title = "EXE Color", Default = Cfg.TwoD.EXE_Role_Fill, Callback = function(v) Cfg.TwoD.EXE_Role_Fill = v end })
Sec2D:AddColorpicker("E_Role_Out",  { Title = "EXE Outline", Default = Cfg.TwoD.EXE_Role_Out, Callback = function(v) Cfg.TwoD.EXE_Role_Out = v end })
Sec2D:AddSlider("E_Role_Limp", { Title = "EXE Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.EXE_Role_Limp, Rounding = 1, Callback = function(v) Cfg.TwoD.EXE_Role_Limp = v end })

Sec2D:AddParagraph({ Title = "EXE Tag: RAGE", Content = "" })
Sec2D:AddToggle("E_Rage_Tog", { Title = "Show RAGE Tag", Default = Cfg.TwoD.EXE_Rage_Tog, Callback = function(v) Cfg.TwoD.EXE_Rage_Tog = v end })
Sec2D:AddDropdown("E_Rage_Dir", { Title = "Placement Direction", Values = DirValues, Default = Cfg.TwoD.EXE_Rage_Dir, Callback = function(v) Cfg.TwoD.EXE_Rage_Dir = v end })
Sec2D:AddSlider("E_Rage_Order", { Title = "Queue Order", Min = 1, Max = 10, Default = Cfg.TwoD.EXE_Rage_Order, Rounding = 0, Callback = function(v) Cfg.TwoD.EXE_Rage_Order = v end })
Sec2D:AddColorpicker("E_Rage_Fill", { Title = "RAGE Color", Default = Cfg.TwoD.EXE_Rage_Fill, Callback = function(v) Cfg.TwoD.EXE_Rage_Fill = v end })
Sec2D:AddColorpicker("E_Rage_Out",  { Title = "RAGE Outline", Default = Cfg.TwoD.EXE_Rage_Out, Callback = function(v) Cfg.TwoD.EXE_Rage_Out = v end })
Sec2D:AddSlider("E_Rage_Limp", { Title = "RAGE Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.EXE_Rage_Limp, Rounding = 1, Callback = function(v) Cfg.TwoD.EXE_Rage_Limp = v end })

Sec2D:AddParagraph({ Title = "EXE Tag: STUN", Content = "" })
Sec2D:AddToggle("E_Stun_Tog", { Title = "Show STUN Tag", Default = Cfg.TwoD.EXE_Stun_Tog, Callback = function(v) Cfg.TwoD.EXE_Stun_Tog = v end })
Sec2D:AddDropdown("E_Stun_Dir", { Title = "Placement Direction", Values = DirValues, Default = Cfg.TwoD.EXE_Stun_Dir, Callback = function(v) Cfg.TwoD.EXE_Stun_Dir = v end })
Sec2D:AddSlider("E_Stun_Order", { Title = "Queue Order", Min = 1, Max = 10, Default = Cfg.TwoD.EXE_Stun_Order, Rounding = 0, Callback = function(v) Cfg.TwoD.EXE_Stun_Order = v end })
Sec2D:AddColorpicker("E_Stun_Fill", { Title = "STUN Color", Default = Cfg.TwoD.EXE_Stun_Fill, Callback = function(v) Cfg.TwoD.EXE_Stun_Fill = v end })
Sec2D:AddColorpicker("E_Stun_Out",  { Title = "STUN Outline", Default = Cfg.TwoD.EXE_Stun_Out, Callback = function(v) Cfg.TwoD.EXE_Stun_Out = v end })
Sec2D:AddSlider("E_Stun_Limp", { Title = "STUN Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.EXE_Stun_Limp, Rounding = 1, Callback = function(v) Cfg.TwoD.EXE_Stun_Limp = v end })

Sec2D:AddParagraph({ Title = "EXE Tag: DEAD", Content = "" })
Sec2D:AddToggle("E_Dead_Tog", { Title = "Show DEAD Tag", Default = Cfg.TwoD.EXE_Dead_Tog, Callback = function(v) Cfg.TwoD.EXE_Dead_Tog = v end })
Sec2D:AddDropdown("E_Dead_Dir", { Title = "Placement Direction", Values = DirValues, Default = Cfg.TwoD.EXE_Dead_Dir, Callback = function(v) Cfg.TwoD.EXE_Dead_Dir = v end })
Sec2D:AddSlider("E_Dead_Order", { Title = "Queue Order", Min = 1, Max = 10, Default = Cfg.TwoD.EXE_Dead_Order, Rounding = 0, Callback = function(v) Cfg.TwoD.EXE_Dead_Order = v end })
Sec2D:AddColorpicker("E_Dead_Fill", { Title = "DEAD Color", Default = Cfg.TwoD.EXE_Dead_Fill, Callback = function(v) Cfg.TwoD.EXE_Dead_Fill = v end })
Sec2D:AddColorpicker("E_Dead_Out",  { Title = "DEAD Outline", Default = Cfg.TwoD.EXE_Dead_Out, Callback = function(v) Cfg.TwoD.EXE_Dead_Out = v end })
Sec2D:AddSlider("E_Dead_Limp", { Title = "DEAD Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.EXE_Dead_Limp, Rounding = 1, Callback = function(v) Cfg.TwoD.EXE_Dead_Limp = v end })

Sec2D:AddParagraph({ Title = "EXE Tag: Character Name", Content = "" })
Sec2D:AddToggle("E_CharName_Tog", { Title = "Show Character Name", Default = Cfg.TwoD.EXE_CharName_Tog, Callback = function(v) Cfg.TwoD.EXE_CharName_Tog = v end })
Sec2D:AddDropdown("E_CharName_Dir", { Title = "Placement Direction", Values = DirValues, Default = Cfg.TwoD.EXE_CharName_Dir, Callback = function(v) Cfg.TwoD.EXE_CharName_Dir = v end })
Sec2D:AddSlider("E_CharName_Order", { Title = "Queue Order", Min = 1, Max = 10, Default = Cfg.TwoD.EXE_CharName_Order, Rounding = 0, Callback = function(v) Cfg.TwoD.EXE_CharName_Order = v end })
Sec2D:AddColorpicker("E_CharName_Fill", { Title = "Name Color", Default = Cfg.TwoD.EXE_CharName_Fill, Callback = function(v) Cfg.TwoD.EXE_CharName_Fill = v end })
Sec2D:AddColorpicker("E_CharName_Out",  { Title = "Name Outline", Default = Cfg.TwoD.EXE_CharName_Out, Callback = function(v) Cfg.TwoD.EXE_CharName_Out = v end })
Sec2D:AddSlider("E_CharName_Limp", { Title = "Name Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.EXE_CharName_Limp, Rounding = 1, Callback = function(v) Cfg.TwoD.EXE_CharName_Limp = v end })

Sec2D:AddParagraph({ Title = "EXE Tag: Player Nickname", Content = "" })
Sec2D:AddToggle("E_UserName_Tog", { Title = "Show @Username", Default = Cfg.TwoD.EXE_UserName_Tog, Callback = function(v) Cfg.TwoD.EXE_UserName_Tog = v end })
Sec2D:AddDropdown("E_UserName_Dir", { Title = "Placement Direction", Values = DirValues, Default = Cfg.TwoD.EXE_UserName_Dir, Callback = function(v) Cfg.TwoD.EXE_UserName_Dir = v end })
Sec2D:AddSlider("E_UserName_Order", { Title = "Queue Order", Min = 1, Max = 10, Default = Cfg.TwoD.EXE_UserName_Order, Rounding = 0, Callback = function(v) Cfg.TwoD.EXE_UserName_Order = v end })
Sec2D:AddColorpicker("E_UserName_Fill", { Title = "@User Color", Default = Cfg.TwoD.EXE_UserName_Fill, Callback = function(v) Cfg.TwoD.EXE_UserName_Fill = v end })
Sec2D:AddColorpicker("E_UserName_Out",  { Title = "@User Outline", Default = Cfg.TwoD.EXE_UserName_Out, Callback = function(v) Cfg.TwoD.EXE_UserName_Out = v end })
Sec2D:AddSlider("E_UserName_Limp", { Title = "@User Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.EXE_UserName_Limp, Rounding = 1, Callback = function(v) Cfg.TwoD.EXE_UserName_Limp = v end })

Sec2D:AddParagraph({ Title = "EXE Tag: Distance", Content = "" })
Sec2D:AddToggle("Dist_E_Tog", { Title = "Show Distance Tag", Default = Cfg.TwoD.EXE_Dist_Tog, Callback = function(v) Cfg.TwoD.EXE_Dist_Tog = v end })
Sec2D:AddDropdown("Dist_E_Dir", { Title = "Placement Direction", Values = DirValues, Default = Cfg.TwoD.EXE_Dist_Dir, Callback = function(v) Cfg.TwoD.EXE_Dist_Dir = v end })
Sec2D:AddSlider("Dist_E_Order", { Title = "Queue Order", Min = 1, Max = 10, Default = Cfg.TwoD.EXE_Dist_Order, Rounding = 0, Callback = function(v) Cfg.TwoD.EXE_Dist_Order = v end })
Sec2D:AddColorpicker("Dist_E_Fill", { Title = "Distance Color", Default = Cfg.TwoD.EXE_Dist_Fill, Callback = function(v) Cfg.TwoD.EXE_Dist_Fill = v end })
Sec2D:AddColorpicker("Dist_E_Out",  { Title = "Distance Outline", Default = Cfg.TwoD.EXE_Dist_Out, Callback = function(v) Cfg.TwoD.EXE_Dist_Out = v end })
Sec2D:AddSlider("Dist_E_Limp", { Title = "Distance Transp.", Min = 0, Max = 5, Default = Cfg.TwoD.EXE_Dist_Limp, Rounding = 1, Callback = function(v) Cfg.TwoD.EXE_Dist_Limp = v end })

local SecPad = TabVisuals:AddSection("Pad ESP")
SecPad:AddToggle("Pad_Tog", {
    Title = "Show Pads",
    Default = Cfg.Pad.Enabled,
    Callback = function(v)
        Cfg.Pad.Enabled = v
        if not v then
            for obj, hl in pairs(GlobalState.Vis.PadCache) do
                if hl and hl.Parent then hl:Destroy() end
            end
            table.clear(GlobalState.Vis.PadCache)
            GlobalState.Vis.HasScannedPads = false
        else
            GlobalState.Vis.HasScannedPads = false
        end
    end
})

SecPad:AddDropdown("Pad_Style",    { Title = "Style Options", Values = {"Outline","Fill"}, Multi = true, Default = {"Outline","Fill"}, Callback = function(v) Cfg.Pad.Style = v end })

SecPad:AddColorpicker("Pad_OutCol", { Title = "Pad Outline", Default = Cfg.Pad.OutCol, Callback = function(v)
    Cfg.Pad.OutCol = v
    for _, hl in pairs(GlobalState.Vis.PadCache) do
        if hl and hl.Parent then hl.OutlineColor = v end
    end
end })

SecPad:AddColorpicker("Pad_FillCol",{ Title = "Pad Fill", Default = Cfg.Pad.FillCol, Callback = function(v)
    Cfg.Pad.FillCol = v
    for _, hl in pairs(GlobalState.Vis.PadCache) do
        if hl and hl.Parent then hl.FillColor = v end
    end
end })

SecPad:AddSlider("Pad_LimpOut",     { Title = "Outline Transp.", Min = 0, Max = 5, Default = Cfg.Pad.Limp_Out, Rounding = 1, Callback = function(v) Cfg.Pad.Limp_Out = v end })
SecPad:AddSlider("Pad_LimpFill",    { Title = "Fill Transp.",   Min = 0, Max = 5, Default = Cfg.Pad.Limp_Fill, Rounding = 1, Callback = function(v) Cfg.Pad.Limp_Fill = v end })

local SecTrap = TabVisuals:AddSection("Tripwire Mines ESP")

local function WipeTrapCache()
    for obj, data in pairs(GlobalState.Vis.TrapCache) do
        if data.Proxy then data.Proxy:Destroy() end
    end
    table.clear(GlobalState.Vis.TrapCache)
end

SecTrap:AddToggle("Trap_Tog", { Title = "Show Tripwire Mines", Default = Cfg.Tripwire.Enabled, Callback = function(v) Cfg.Tripwire.Enabled = v; WipeTrapCache() end })

SecTrap:AddDropdown("Trap_Style", {
    Title = "Visual Style (Decal)",
    Values = {"Shockwave", "Circle Dashed 4", "Shift Lock", "Custom"},
    Default = Cfg.Tripwire.Style,
    Callback = function(v) Cfg.Tripwire.Style = v; WipeTrapCache() end
})

SecTrap:AddInput("Trap_CustomID", { Title = "Custom ID (Numbers only)", Default = Cfg.Tripwire.CustomID, Callback = function(v) Cfg.Tripwire.CustomID = v; WipeTrapCache() end })

SecTrap:AddSlider("Trap_Size", { Title = "Size", Min = 0.1, Max = 20, Default = Cfg.Tripwire.Size, Rounding = 1, Callback = function(v) Cfg.Tripwire.Size = v end })

SecTrap:AddDropdown("Trap_ScaleMode", {
    Title = "Scale Mode",
    Description = "2D: Static screen size | 3D: Scales with distance",
    Values = {"2D", "3D"},
    Default = Cfg.Tripwire.ScaleMode,
    Callback = function(v) Cfg.Tripwire.ScaleMode = v end
})

SecTrap:AddParagraph({ Title = "Rotation Settings", Content = "" })
SecTrap:AddSlider("Trap_Speed", { Title = "Rotation Speed", Min = 0.1, Max = 30, Default = Cfg.Tripwire.Speed, Rounding = 1, Callback = function(v) Cfg.Tripwire.Speed = v end })
SecTrap:AddDropdown("Trap_Dir", { Title = "Rotation Direction", Values = {"Left", "Right", "Random"}, Default = Cfg.Tripwire.Direction, Callback = function(v) Cfg.Tripwire.Direction = v end })
SecTrap:AddSlider("Trap_RandMin", { Title = "Random Min Time (s)", Min = 0.1, Max = 10, Default = Cfg.Tripwire.RandMin, Rounding = 1, Callback = function(v) Cfg.Tripwire.RandMin = v end })
SecTrap:AddSlider("Trap_RandMax", { Title = "Random Max Time (s)", Min = 0.1, Max = 10, Default = Cfg.Tripwire.RandMax, Rounding = 1, Callback = function(v) Cfg.Tripwire.RandMax = v end })

SecTrap:AddParagraph({ Title = "Color & Transparency", Content = "" })
SecTrap:AddColorpicker("Trap_FillCol", { Title = "Image Color", Default = Cfg.Tripwire.FillCol, Callback = function(v) Cfg.Tripwire.FillCol = v end })
SecTrap:AddSlider("Trap_LimpFill", { Title = "Image Transp.", Min = 0, Max = 5, Default = Cfg.Tripwire.LimpFill, Rounding = 1, Callback = function(v) Cfg.Tripwire.LimpFill = v end })

local SecLocal = TabVisuals:AddSection("Local Player")
SecLocal:AddToggle("Loc_Tog",        { Title = "Local Chams",    Default = Cfg.Local.Enabled, Callback = function(v) Cfg.Local.Enabled = v end })
SecLocal:AddDropdown("Loc_Style",     { Title = "Style", Values = {"Outline","Fill"}, Multi = true, Default = {"Outline","Fill"}, Callback = function(v) Cfg.Local.Style = v end })
SecLocal:AddColorpicker("Loc_OutCol", { Title = "Outline Color", Default = Cfg.Local.OutCol,  Callback = function(v) Cfg.Local.OutCol = v end })
SecLocal:AddColorpicker("Loc_FillCol",{ Title = "Fill Color",    Default = Cfg.Local.FillCol, Callback = function(v) Cfg.Local.FillCol = v end })
SecLocal:AddSlider("Loc_LimpOut",     { Title = "Outline Transp.", Min = 0, Max = 5, Default = Cfg.Local.Limp_Out, Rounding = 1, Callback = function(v) Cfg.Local.Limp_Out = v end })
SecLocal:AddSlider("Loc_LimpFill",    { Title = "Fill Transp.",   Min = 0, Max = 5, Default = Cfg.Local.Limp_Fill, Rounding = 1, Callback = function(v) Cfg.Local.Limp_Fill = v end })

-- ═════════════════════════════════════════════════════════════════════════
-- UI: NIGHT MODE & WORLD TAB
-- ═════════════════════════════════════════════════════════════════════════
local TabNight = Tabs.NightMode

local SecNightMode = TabNight:AddSection("Night Mode")

SecNightMode:AddToggle("Night_Tog", {
    Title = "Enable Night Mode", 
    Default = Cfg.Night.Enabled,
    Callback = function(v)
        Cfg.Night.Enabled = v
        ApplyAtmosphereAndFog()
    end
})

SecNightMode:AddColorpicker("Night_Amb", { 
    Title = "Ambient Color (Shadows)", 
    Default = Cfg.Night.AmbCol, 
    Callback = function(v) 
        Cfg.Night.AmbCol = v 
        ApplyAtmosphereAndFog()
    end 
})

SecNightMode:AddColorpicker("light_Col", { 
    Title = "Outdoor Light Color", 
    Default = Cfg.Night.lightCol, 
    Callback = function(v) 
        Cfg.Night.lightCol = v 
        ApplyAtmosphereAndFog()
    end 
})

local SecNightLights = TabNight:AddSection("Light Modifiers")

SecNightLights:AddToggle("Light_Mod_Tog", { 
    Title = "Modify Map Lights", 
    Default = Cfg.Night.ModifyLights, 
    Callback = function(v)
        Cfg.Night.ModifyLights = v
        UpdateWorldLights()
    end 
})

local LastLightUpdate = 0
local function RequestLightUpdate()
    local now = tick()
    if now - LastLightUpdate >= 0.2 then
        LastLightUpdate = now
        task.spawn(UpdateWorldLights)
    end
end

SecNightLights:AddSlider("Light_Bright", { 
    Title = "Brightness Level", 
    Min = 0, 
    Max = 10, 
    Default = Cfg.Night.LightBright, 
    Rounding = 1, 
    Callback = function(v)
        Cfg.Night.LightBright = v
        if Cfg.Night.ModifyLights then RequestLightUpdate() end
    end 
})

SecNightLights:AddColorpicker("Light_Color", { 
    Title = "Light Source Color", 
    Default = Cfg.Night.LightColor, 
    Callback = function(v)
        Cfg.Night.LightColor = v
        if Cfg.Night.ModifyLights then RequestLightUpdate() end
    end 
})

local SecNightFog = TabNight:AddSection("Atmosphere & Fog")

SecNightFog:AddToggle("Fog_Tog", { 
    Title = "Enable Custom Fog", 
    Default = Cfg.Night.FogEnabled, 
    Callback = function(v)
        Cfg.Night.FogEnabled = v
        ApplyAtmosphereAndFog()
    end 
})

SecNightFog:AddColorpicker("Fog_Color", { 
    Title = "Fog Color", 
    Default = Cfg.Night.FogColor, 
    Callback = function(v) 
        Cfg.Night.FogColor = v 
        ApplyAtmosphereAndFog()
    end 
})

SecNightFog:AddSlider("Fog_Density", { 
    Title = "Fog Density", 
    Min = 0, 
    Max = 5, 
    Default = Cfg.Night.FogDensity, 
    Rounding = 1, 
    Callback = function(v) 
        Cfg.Night.FogDensity = v 
        ApplyAtmosphereAndFog()
    end 
})

local SecWorldRem = TabNight:AddSection("World Removals")

SecWorldRem:AddButton({
    Title = "Delete Fog & Atmosphere",
    Callback = function()
        Lighting.FogEnd = 9e9
        if Lighting:FindFirstChild("Atmosphere") then Lighting.Atmosphere:Destroy() end
        if Lighting:FindFirstChild("Sky")        then Lighting.Sky:Destroy() end
        local cam = Workspace.CurrentCamera
        if cam:FindFirstChild("WaterBlur")       then cam.WaterBlur:Destroy() end
        if cam:FindFirstChild("WaterCorrection") then cam.WaterCorrection:Destroy() end
        for _, v in pairs(Lighting:GetChildren()) do
            if v:IsA("BlurEffect") then v:Destroy() end
        end
        Fluent:Notify({ Title = "World", Content = "Fog & Atmosphere Deleted", Duration = 2 })
    end
})

-- UI: Custom LMS & Music Tab
local TabLMS = Tabs.LMS

local CHARACTER_LIST_LMS = {
    { Key = "Sonic",      Label = "Sonic" },
    { Key = "Tails",      Label = "Tails" },
    { Key = "Knuckles",   Label = "Knuckles" },
    { Key = "Amy",        Label = "Amy" },
    { Key = "Cream",      Label = "Cream" },
    { Key = "Eggman",     Label = "Eggman" },
    { Key = "Silver",     Label = "Silver" },
    { Key = "Blaze",      Label = "Blaze" },
    { Key = "MetalSonic", Label = "Metal Sonic" },
    { Key = "Shadow",     Label = "Shadow" },
    { Key = "Fang",       Label = "Fang" },
}

local LMS_Originals_Lookup = {
    ["AmySolo"] = true, ["BlazeSolo"] = true, ["CreamSolo"] = true,
    ["EggmanSolo"] = true, ["KnucklesSolo"] = true, ["MetalSonicSolo"] = true,
    ["ShadowSolo"] = true, ["SilverSolo"] = true, ["SonicSolo"] = true,
    ["SuperSonicSolo"] = true, ["TailsSolo"] = true, ["FangSolo"] = true,
}

local DOD_Assets = {
    Survivor = {
        ["Cream"]       = "rbxassetid://110574647259027",
        ["Sonic"]       = "rbxassetid://116105674203386",
        ["Blaze"]       = "rbxassetid://132823832100556",
        ["Silver"]      = "rbxassetid://127572902749122",
        ["Tails"]       = "rbxassetid://127820761709025",
        ["Knuckles"]    = "rbxassetid://83319953418213",
        ["MetalSonic"]  = "rbxassetid://139874742917760",
        ["Metal Sonic"] = "rbxassetid://139874742917760",
        ["Eggman"]      = "rbxassetid://85769780673032",
        ["Amy"]         = "rbxassetid://111226713397041",
        ["Shadow"]      = "rbxassetid://113857022513506",
        ["SuperSonic"]  = "rbxassetid://112771236848699",
        ["Super Sonic"] = "rbxassetid://112771236848699",
    },
    EXE = {
        ["TailsDoll"]     = "rbxassetid://88717022359465",
        ["Tripwire"]      = "rbxassetid://88717022359465",
        ["Kolossos"]      = "rbxassetid://119601323636555",
        ["2011x"]         = "rbxassetid://121016358955184",
        ["Fleetway"]      = "rbxassetid://126606461926165",
        ["Furnace"]       = "rbxassetid://117495151098938",
        ["LegacyFurnace"] = "rbxassetid://102159711895519",
        ["OldFurnace"]    = "rbxassetid://102159711895519",
        ["Lord X"]        = "rbxassetid://93696635906407",
        ["2017x"]         = "rbxassetid://120562962195804",
        ["Executor"]      = "rbxassetid://120562962195804",
    },
}

local function GetAssetSafe(path)
    if not isfile(path) then return nil end
    local func = getcustomasset or getsynasset
    if func then
        local s, res = pcall(func, path)
        if s then return res end
    end
    return nil
end

local LMS_PreloadCache = {}

local function ResolveAssetPath(trackName)
    if not trackName or trackName == "None" then return nil end
    if LMS_PreloadCache[trackName] then return LMS_PreloadCache[trackName] end

    local p1 = LMS_DIR .. "/" .. trackName .. ".ogg"
    local p2 = LMS_DIR .. "/" .. trackName .. ".mp3"
    local finalPath = isfile(p1) and p1 or (isfile(p2) and p2 or nil)
    local asset = finalPath and GetAssetSafe(finalPath) or nil
    if asset then LMS_PreloadCache[trackName] = asset end
    return asset
end

local function PreloadAllLMSTracks()
    task.spawn(function()
        for _, name in pairs(GlobalConfig.LMS.ClassTracks) do ResolveAssetPath(name) end
        if GlobalConfig.LMS.Track then ResolveAssetPath(GlobalConfig.LMS.Track) end
    end)
end

local function GetFilesList()
    local list = { "None" }
    if LMS_DIR and type(LMS_DIR) == "string" and isfolder and isfolder(LMS_DIR) then
        local success, files = pcall(listfiles, LMS_DIR)
        if success and files then
            for _, path in pairs(files) do
                if string.match(path, "%.ogg$") or string.match(path, "%.mp3$") then
                    local name = string.match(path, "[^/\\]+$")
                    name = string.gsub(name, "%.ogg$", ""):gsub("%.mp3$", "")
                    table.insert(list, name)
                end
            end
        end
    end
    table.sort(list)
    return list
end

local function PlayFXSound(id, baseVolume)
    local masterVol = GlobalConfig.LMS.EffectVolume or 1
    local s     = Instance.new("Sound")
    s.SoundId   = "rbxassetid://" .. id
    s.Volume    = baseVolume * masterVol
    s.Parent    = SoundService
    s.Name      = "LMS_FX_Audio"
    s:Play()
    Debris:AddItem(s, 10)
    return s
end

local function GetActiveSoloSound()
    local assets = Workspace:FindFirstChild("Assets")
    local songs = assets and assets:FindFirstChild("Songs")
    if songs then
        for _, s in ipairs(songs:GetChildren()) do
            if s:IsA("Sound") and (LMS_Originals_Lookup[s.Name] or string.find(s.Name, "Solo")) and (s.IsPlaying or s.Playing or s.TimePosition > 0) then
                return s
            end
        end
    end

    local reMus = ReplicatedStorage:FindFirstChild("ClientAssets")
    local soloFolder = reMus and reMus:FindFirstChild("Sounds") and reMus.Sounds:FindFirstChild("mus") and reMus.Sounds.mus:FindFirstChild("Game") and reMus.Sounds.mus.Game:FindFirstChild("Round") and reMus.Sounds.mus.Game.Round:FindFirstChild("SoloTheme")
    if soloFolder then
        for _, s in ipairs(soloFolder:GetChildren()) do
            if s:IsA("Sound") and LMS_Originals_Lookup[s.Name] and (s.IsPlaying or s.Playing or s.TimePosition > 0) then
                return s
            end
        end
    end

    for _, s in ipairs(SoundService:GetChildren()) do
        if s:IsA("Sound") and (LMS_Originals_Lookup[s.Name] or string.find(s.Name, "Solo")) and (s.IsPlaying or s.Playing or s.TimePosition > 0) then
            return s
        end
    end

    return nil
end

local LMS_Visuals = {}

LMS_Visuals["Pizza Tower"] = function()
    local fxContainer = GetFXGui()
    local img = Instance.new("ImageLabel", fxContainer)
    img.BackgroundTransparency = 1; img.Size = UDim2.fromScale(0.55, 0.4)
    img.SizeConstraint = Enum.SizeConstraint.RelativeYY; img.AnchorPoint = Vector2.new(0.5, 0.5)
    img.Position = UDim2.fromScale(0.5, 1.5); img.Image = "rbxassetid://77264911614141"

    PlayFXSound("96050676918804", 1)
    TweenService:Create(img, TweenInfo.new(5, Enum.EasingStyle.Linear), { Position = UDim2.fromScale(0.5, -0.5) }):Play()

    task.spawn(function()
        local toggle = false
        while img and img.Parent and img.Position.Y.Scale > -0.5 do
            img.Image = toggle and "rbxassetid://77264911614141" or "rbxassetid://92555127882199"
            toggle = not toggle; task.wait(0.05)
        end
        if img then img:Destroy() end
    end)
end

LMS_Visuals["FNF"] = function()
    local fxContainer = GetFXGui()
    PlayFXSound("6555005549", 0.3)
    task.wait(0.85)
    local function CreateText(id)
        local im = Instance.new("ImageLabel", fxContainer)
        im.Size = UDim2.fromScale(0.4, 0.2); im.SizeConstraint = Enum.SizeConstraint.RelativeYY
        im.AnchorPoint = Vector2.new(0.5, 0.5); im.Position = UDim2.fromScale(0.5, 0.5)
        im.BackgroundTransparency = 1; im.Image = "rbxassetid://" .. id; im.ImageTransparency = 1
        return im
    end
    task.spawn(function()
        local r = CreateText("6443228613")
        TweenService:Create(r, TweenInfo.new(0.1), { ImageTransparency = 0 }):Play(); task.wait(0.6)
        TweenService:Create(r, TweenInfo.new(0.1), { ImageTransparency = 1, Position = UDim2.fromScale(0.5, 0.4) }):Play(); r:Destroy()
        local s = CreateText("6443225217")
        TweenService:Create(s, TweenInfo.new(0.1), { ImageTransparency = 0 }):Play(); task.wait(0.6)
        TweenService:Create(s, TweenInfo.new(0.1), { ImageTransparency = 1, Position = UDim2.fromScale(0.5, 0.4) }):Play(); s:Destroy()
        local g = CreateText("6443224742")
        TweenService:Create(g, TweenInfo.new(0.1), { ImageTransparency = 0 }):Play(); task.wait(0.8)
        TweenService:Create(g, TweenInfo.new(0.5), { ImageTransparency = 1, Size = UDim2.fromScale(0.6, 0.3) }):Play(); g:Destroy()
    end)
end

LMS_Visuals["DOD"] = function(isTest)
    local fxContainer = GetFXGui()
    local activeSurvs, downedSurvs, _, activeExes = AnalyzeLMSState()

    local survChar, exeChar = "", ""

    if isTest then
        survChar = "Tails"
        exeChar  = "2011x"
    else
        local targetSurv = activeSurvs[1]
        if not targetSurv then
            targetSurv = downedSurvs[1]
        end

        if not targetSurv then
            local soloSnd = GetActiveSoloSound()
            if soloSnd then
                local rawSoloName = soloSnd.Name:gsub("Solo", ""):gsub("Theme", "")
                for key, canon in pairs(SURVIVOR_CANON_NAMES) do
                    if string.lower(rawSoloName):find(key, 1, true) then
                        survChar = canon
                        break
                    end
                end
            end
        end

        if survChar == "" and targetSurv then
            survChar = tostring(targetSurv.CharName or "Tails")
        end
        if survChar == "" then
            survChar = "Tails"
        end

        local targetEXE = activeExes[1]
        if targetEXE then
            exeChar = tostring(targetEXE.CharName or "2011x")
        else
            exeChar = "2011x"
        end
    end

    local survNameStr = survChar
    local exeNameStr  = exeChar

    local survImg = DOD_Assets.Survivor[survChar] or DOD_Assets.Survivor["Tails"] or "rbxassetid://127820761709025"
    local exeImg  = DOD_Assets.EXE[exeChar]       or DOD_Assets.EXE["2011x"]     or "rbxassetid://121016358955184"

    local Container = Instance.new("Frame", fxContainer)
    Container.Name = "DOD_Container"
    Container.Size = UDim2.fromScale(1, 1)
    Container.BackgroundTransparency = 1

    local flash = Instance.new("Frame", Container)
    flash.Size = UDim2.fromScale(1, 1)
    flash.BackgroundColor3 = Color3.fromRGB(180, 0, 0)
    flash.BackgroundTransparency = 0.3
    TweenService:Create(flash, TweenInfo.new(0.4, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), { BackgroundTransparency = 1 }):Play()

    PlayFXSound("132670234831172", 0.7)

    -- (Survivor)
    local leftGroup = Instance.new("Frame", Container)
    leftGroup.Size = UDim2.new(0, 650, 0, 180)
    leftGroup.Position = UDim2.new(-0.55, 0, 0.015, 0)
    leftGroup.BackgroundTransparency = 1

    local diesHeader = Instance.new("TextLabel", leftGroup)
    diesHeader.Size = UDim2.new(0, 350, 0, 35)
    diesHeader.Position = UDim2.new(1, -350, 0, 0)
    diesHeader.BackgroundTransparency = 1
    diesHeader.Text = "Here dies..."
    diesHeader.TextColor3 = Color3.fromRGB(255, 255, 255)
    diesHeader.TextTransparency = 0.4
    diesHeader.TextStrokeTransparency = 0.6
    diesHeader.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
    diesHeader.FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Italic)
    diesHeader.TextSize = 34
    diesHeader.TextXAlignment = Enum.TextXAlignment.Right

    local survBox = Instance.new("Frame", leftGroup)
    survBox.Size = UDim2.new(1, 0, 0, 60)
    survBox.Position = UDim2.new(0, 0, 0, 35)
    survBox.BackgroundColor3 = Color3.fromRGB(12, 12, 12)
    survBox.BackgroundTransparency = 0.2
    survBox.ZIndex = 2
    local survStroke = Instance.new("UIStroke", survBox)
    survStroke.Color = Color3.fromRGB(255, 255, 255)
    survStroke.Transparency = 0.45
    survStroke.Thickness = 2

    local survLbl = Instance.new("TextLabel", survBox)
    survLbl.Size = UDim2.fromScale(1, 1)
    survLbl.BackgroundTransparency = 1
    survLbl.Text = survNameStr
    survLbl.TextColor3 = Color3.fromRGB(255, 255, 255)
    survLbl.Font = Enum.Font.GothamBold
    survLbl.TextSize = 40
    survLbl.ZIndex = 3

    local leftExcl = Instance.new("TextLabel", leftGroup)
    leftExcl.Size = UDim2.new(0, 180, 0, 180)
    leftExcl.Position = UDim2.new(1, -140, 0, 45)
    leftExcl.BackgroundTransparency = 1
    leftExcl.Text = "!"
    leftExcl.TextColor3 = Color3.fromRGB(255, 255, 255)
    leftExcl.TextTransparency = 0.4
    leftExcl.TextStrokeTransparency = 0.6
    leftExcl.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
    leftExcl.Font = Enum.Font.GothamBold
    leftExcl.TextSize = 210
    leftExcl.Rotation = 90
    leftExcl.ZIndex = 1

    TweenService:Create(leftGroup, TweenInfo.new(0.65, Enum.EasingStyle.Exponential, Enum.EasingDirection.Out), { Position = UDim2.new(0.015, 0, 0.015, 0) }):Play()

    -- (EXE)
    local rightGroup = Instance.new("Frame", Container)
    rightGroup.Size = UDim2.new(0, 650, 0, 180)
    rightGroup.Position = UDim2.new(1.55, -650, 0.015, 0)
    rightGroup.BackgroundTransparency = 1

    local deathsHeader = Instance.new("TextLabel", rightGroup)
    deathsHeader.Size = UDim2.new(0, 350, 0, 35)
    deathsHeader.Position = UDim2.new(0, 0, 0, 0)
    deathsHeader.BackgroundTransparency = 1
    deathsHeader.Text = "Here deaths..."
    deathsHeader.TextColor3 = Color3.fromRGB(255, 255, 255)
    deathsHeader.TextTransparency = 0.4
    deathsHeader.TextStrokeTransparency = 0.6
    deathsHeader.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
    deathsHeader.FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Italic)
    deathsHeader.TextSize = 34
    deathsHeader.TextXAlignment = Enum.TextXAlignment.Left

    local exeBox = Instance.new("Frame", rightGroup)
    exeBox.Size = UDim2.new(1, 0, 0, 60)
    exeBox.Position = UDim2.new(0, 0, 0, 35)
    exeBox.BackgroundColor3 = Color3.fromRGB(12, 12, 12)
    exeBox.BackgroundTransparency = 0.2
    exeBox.ZIndex = 2
    local exeStroke = Instance.new("UIStroke", exeBox)
    exeStroke.Color = Color3.fromRGB(255, 255, 255)
    exeStroke.Transparency = 0.45
    exeStroke.Thickness = 2

    local exeLbl = Instance.new("TextLabel", exeBox)
    exeLbl.Size = UDim2.fromScale(1, 1)
    exeLbl.BackgroundTransparency = 1
    exeLbl.Text = exeNameStr
    exeLbl.TextColor3 = Color3.fromRGB(255, 255, 255)
    exeLbl.Font = Enum.Font.GothamBold
    exeLbl.TextSize = 40
    exeLbl.ZIndex = 3

    local rightExcl = Instance.new("TextLabel", rightGroup)
    rightExcl.Size = UDim2.new(0, 180, 0, 180)
    rightExcl.Position = UDim2.new(0, -40, 0, 45)
    rightExcl.BackgroundTransparency = 1
    rightExcl.Text = "!"
    rightExcl.TextColor3 = Color3.fromRGB(255, 255, 255)
    rightExcl.TextTransparency = 0.4
    rightExcl.TextStrokeTransparency = 0.6
    rightExcl.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
    rightExcl.Font = Enum.Font.GothamBold
    rightExcl.TextSize = 210
    rightExcl.Rotation = -90
    rightExcl.ZIndex = 1

    TweenService:Create(rightGroup, TweenInfo.new(0.65, Enum.EasingStyle.Exponential, Enum.EasingDirection.Out), { Position = UDim2.new(0.985, -650, 0.015, 0) }):Play()

    -- VS
    local vsGroup = Instance.new("Frame", Container)
    vsGroup.Size = UDim2.new(0, 380, 0, 160)
    vsGroup.AnchorPoint = Vector2.new(0.5, 0)
    vsGroup.Position = UDim2.new(0.5, 0, -0.4, 0)
    vsGroup.BackgroundTransparency = 1

    local rope1 = Instance.new("Frame", vsGroup)
    rope1.Name = "RopeLeft"
    rope1.Size = UDim2.new(0, 3, 0, 60)
    rope1.Position = UDim2.new(0.5, -80, 0, 0)
    rope1.BackgroundColor3 = Color3.fromRGB(12, 12, 12)
    rope1.BackgroundTransparency = 0.2
    rope1.BorderSizePixel = 0
    rope1.ZIndex = 3
    local r1Stroke = Instance.new("UIStroke", rope1)
    r1Stroke.Color = Color3.fromRGB(255, 255, 255)
    r1Stroke.Transparency = 0.45
    r1Stroke.Thickness = 1.5

    local rope2 = Instance.new("Frame", vsGroup)
    rope2.Name = "RopeRight"
    rope2.Size = UDim2.new(0, 3, 0, 60)
    rope2.Position = UDim2.new(0.5, 80, 0, 0)
    rope2.BackgroundColor3 = Color3.fromRGB(12, 12, 12)
    rope2.BackgroundTransparency = 0.2
    rope2.BorderSizePixel = 0
    rope2.ZIndex = 3
    local r2Stroke = Instance.new("UIStroke", rope2)
    r2Stroke.Color = Color3.fromRGB(255, 255, 255)
    r2Stroke.Transparency = 0.45
    r2Stroke.Thickness = 1.5

    local vsBox = Instance.new("Frame", vsGroup)
    vsBox.Size = UDim2.new(1, 0, 0, 100)
    vsBox.Position = UDim2.new(0, 0, 0, 60)
    vsBox.BackgroundColor3 = Color3.fromRGB(12, 12, 12)
    vsBox.BackgroundTransparency = 0.2
    vsBox.ZIndex = 2
    local vsBoxStroke = Instance.new("UIStroke", vsBox)
    vsBoxStroke.Color = Color3.fromRGB(255, 255, 255)
    vsBoxStroke.Transparency = 0.45
    vsBoxStroke.Thickness = 2

    local vsExcl1 = Instance.new("TextLabel", vsBox)
    vsExcl1.Size = UDim2.new(0.28, 0, 1, 0)
    vsExcl1.Position = UDim2.new(0, 10, 0, 0)
    vsExcl1.BackgroundTransparency = 1
    vsExcl1.Text = "!"
    vsExcl1.TextColor3 = Color3.fromRGB(255, 255, 255)
    vsExcl1.TextTransparency = 0.15
    vsExcl1.Font = Enum.Font.GothamBold
    vsExcl1.TextSize = 52
    vsExcl1.ZIndex = 3

    local vsCenterLbl = Instance.new("TextLabel", vsBox)
    vsCenterLbl.Size = UDim2.new(0.44, 0, 1, 0)
    vsCenterLbl.Position = UDim2.new(0.28, 0, 0, 0)
    vsCenterLbl.BackgroundTransparency = 1
    vsCenterLbl.Text = "VS."
    vsCenterLbl.TextColor3 = Color3.fromRGB(255, 220, 0)
    vsCenterLbl.Font = Enum.Font.FredokaOne
    vsCenterLbl.TextSize = 56
    vsCenterLbl.ZIndex = 3

    local vsGrad = Instance.new("UIGradient", vsCenterLbl)
    vsGrad.Color = ColorSequence.new({
        ColorSequenceKeypoint.new(0, Color3.fromRGB(255, 140, 0)),
        ColorSequenceKeypoint.new(0.5, Color3.fromRGB(255, 245, 100)),
        ColorSequenceKeypoint.new(1, Color3.fromRGB(255, 140, 0))
    })

    local gradConn
    local tGrad = 0
    gradConn = RunService.RenderStepped:Connect(function(dt)
        if not vsGrad or not vsGrad.Parent then
            if gradConn then gradConn:Disconnect(); gradConn = nil end
            return
        end
        tGrad = tGrad + dt
        vsGrad.Rotation = (tGrad * 120) % 360
    end)

    local vsExcl2 = Instance.new("TextLabel", vsBox)
    vsExcl2.Size = UDim2.new(0.28, 0, 1, 0)
    vsExcl2.Position = UDim2.new(0.72, -10, 0, 0)
    vsExcl2.BackgroundTransparency = 1
    vsExcl2.Text = "!"
    vsExcl2.TextColor3 = Color3.fromRGB(255, 255, 255)
    vsExcl2.TextTransparency = 0.15
    vsExcl2.Font = Enum.Font.GothamBold
    vsExcl2.TextSize = 52
    vsExcl2.ZIndex = 3

    TweenService:Create(vsGroup, TweenInfo.new(0.65, Enum.EasingStyle.Exponential, Enum.EasingDirection.Out), { Position = UDim2.new(0.5, 0, 0, 0) }):Play()

    local function SpawnSprite(imgId, isLeft, startPos, endPos)
        local box = Instance.new("Frame", Container)
        box.Size = UDim2.fromScale(0.28, 0.52)
        box.AnchorPoint = isLeft and Vector2.new(0, 1) or Vector2.new(1, 1)
        box.Position = startPos
        box.BackgroundTransparency = 1

        local im = Instance.new("ImageLabel", box)
        im.Size = UDim2.fromScale(1, 1)
        im.BackgroundTransparency = 1
        im.Image = imgId
        im.ScaleType = Enum.ScaleType.Fit

        TweenService:Create(box, TweenInfo.new(0.65, Enum.EasingStyle.Exponential, Enum.EasingDirection.Out), { Position = endPos }):Play()
        return box
    end

    local sBox = SpawnSprite(survImg, true,  UDim2.new(-0.35, 0, 1, 0), UDim2.new(0, 0, 1, 0))
    local eBox = SpawnSprite(exeImg,  false, UDim2.new(1.35, 0, 1, 0),  UDim2.new(1, 0, 1, 0))

    task.delay(3.2, function()
        if gradConn then gradConn:Disconnect(); gradConn = nil end
        if sBox and sBox.Parent then TweenService:Create(sBox, TweenInfo.new(0.4, Enum.EasingStyle.Cubic, Enum.EasingDirection.In), { Position = UDim2.new(-0.35, 0, 1, 0) }):Play() end
        if eBox and eBox.Parent then TweenService:Create(eBox, TweenInfo.new(0.4, Enum.EasingStyle.Cubic, Enum.EasingDirection.In), { Position = UDim2.new(1.35, 0, 1, 0) }):Play() end
        if leftGroup and leftGroup.Parent then TweenService:Create(leftGroup, TweenInfo.new(0.4, Enum.EasingStyle.Cubic, Enum.EasingDirection.In), { Position = UDim2.new(-0.55, 0, 0.015, 0) }):Play() end
        if rightGroup and rightGroup.Parent then TweenService:Create(rightGroup, TweenInfo.new(0.4, Enum.EasingStyle.Cubic, Enum.EasingDirection.In), { Position = UDim2.new(1.55, -650, 0.015, 0) }):Play() end
        if vsGroup and vsGroup.Parent then TweenService:Create(vsGroup, TweenInfo.new(0.4, Enum.EasingStyle.Cubic, Enum.EasingDirection.In), { Position = UDim2.new(0.5, 0, -0.4, 0) }):Play() end
        
        task.wait(0.45)
        if Container and Container.Parent then Container:Destroy() end
    end)
end

local EffectList = { "None", "Pizza Tower", "DOD", "FNF" }

local function GetShadowSound()
    local s = SoundService:FindFirstChild("Doomsense_LMS_Shadow")
    if not s then
        s = Instance.new("Sound")
        s.Name    = "Doomsense_LMS_Shadow"
        s.SoundId = ""
        s.Volume  = 0
        s.Looped  = GlobalConfig.LMS.LoopTrack
        s.Parent  = SoundService
        s.Ended:Connect(function()
            if not GlobalConfig.LMS.LoopTrack then
                GlobalState.LMS.TrackFinished = true
            end
        end)
    end
    return s
end

local function TriggerSteppedStop(shadow)
    local L = GlobalState.LMS
    if not L.IsCapturing then return end
    L.IsCapturing = false

    local fadeTween = TweenService:Create(shadow, TweenInfo.new(1.5, Enum.EasingStyle.Sine, Enum.EasingDirection.Out), { Volume = 0 })
    fadeTween:Play()
    fadeTween.Completed:Once(function()
        if not L.IsCapturing then
            shadow:Stop()
            shadow.SoundId = ""
        end
    end)
end

-- UI Construction for Custom LMS
TabLMS:AddSection("Custom LMS Control")

TabLMS:AddToggle("LMS_MainToggle", {
    Title       = "Enable Custom LMS",
    Description = "Replace boss music with local file",
    Default     = GlobalConfig.LMS.Enabled,
    Callback    = function(v) GlobalConfig.LMS.Enabled = v end
})

TabLMS:AddSlider("LMS_VolumeSlider", {
    Title   = "Music Volume",
    Default = 1.2, Min = 0, Max = 5, Rounding = 1,
    Callback = function(v) GlobalConfig.LMS.Volume = v end
})

TabLMS:AddSlider("LMS_FXVolumeSlider", {
    Title   = "Start Effect Volume",
    Default = 1, Min = 0, Max = 5, Rounding = 1,
    Callback = function(v) GlobalConfig.LMS.EffectVolume = v end
})

TabLMS:AddSlider("LMS_StartDelay", {
    Title       = "LMS Start Delay (s)",
    Description = "Delay before custom music and visual effect starts",
    Default     = 2.3,
    Min         = 0.0,
    Max         = 10.0,
    Rounding    = 1,
    Callback    = function(v) GlobalConfig.LMS.StartDelay = v end
})

TabLMS:AddToggle("LMS_LoopTrack", {
    Title       = "Loop Custom Track",
    Description = "Repeat when finished.",
    Default     = true,
    Callback    = function(v) 
        GlobalConfig.LMS.LoopTrack = v 
        local shadow = SoundService:FindFirstChild("Doomsense_LMS_Shadow")
        if shadow then shadow.Looped = v end
    end
})

TabLMS:AddDropdown("LMS_StartEffect", {
    Title    = "Start Effect",
    Values   = EffectList,
    Default  = "None",
    Callback = function(v) GlobalConfig.LMS.StartEffect = v end
})


TabLMS:AddButton({
    Title       = "Test Effect",
    Description = "Preview selected start effect",
    Callback    = function()
        local fxName = GlobalConfig.LMS.StartEffect
        local fxFunc = LMS_Visuals[fxName]
        if typeof(fxFunc) == "function" then
            Fluent:Notify({ Title = "LMS Test", Content = "Playing: " .. fxName, Duration = 2 })
            task.spawn(fxFunc, true)
        else
            Fluent:Notify({ Title = "LMS Test", Content = "No valid effect selected", Duration = 2 })
        end
    end
})

TabLMS:AddSection("Class Tracks Selection")

local availableTracks = GetFilesList()

local ctrlSurvClass = TabLMS:AddDropdown("LMS_Track_SurvClass", {
    Title    = "Survivor Track",
    Values   = availableTracks,
    Default  = "None",
    Callback = function(v) GlobalConfig.LMS.ClassTracks.Survivor = v end
})

local ctrlEXEClass = TabLMS:AddDropdown("LMS_Track_EXEClass", {
    Title    = "EXE Track",
    Values   = availableTracks,
    Default  = "None",
    Callback = function(v) GlobalConfig.LMS.ClassTracks.EXE = v end
})

TabLMS:AddButton({
    Title    = "Refresh Music Files",
    Callback = function()
        task.spawn(function()
            local list = GetFilesList()
            if ctrlSurvClass then SafeSetDropdownValues(ctrlSurvClass, list) end
            if ctrlEXEClass then SafeSetDropdownValues(ctrlEXEClass, list) end
            Fluent:Notify({ Title = "LMS", Content = "Refreshed Track List", Duration = 1.5 })
        end)
    end
})

-- Mobile Tab
local TabMobile = Tabs.Mobile

local MobileControl = {
    Buttons   = {},
    IsVisible = true,
    EditMode  = false,
}

local ButtonSettings = {
    Menu     = { Size = 50, Transp = 0, Enabled = true },
    HideUI   = { Size = 50, Transp = 0, Enabled = true },
    Fly      = { Size = 50, Transp = 0, Enabled = true },
    Speed    = { Size = 50, Transp = 0, Enabled = true },
    ART      = { Size = 50, Transp = 0, Enabled = true },
    Teleport = { Size = 50, Transp = 0, Enabled = true },
    AH       = { Size = 50, Transp = 0, Enabled = true },
    Anim     = { Size = 50, Transp = 0, Enabled = true },
    Silver   = { Size = 50, Transp = 0, Enabled = true },
}

local MOB_ICONS = {
    Menu     = "rbxassetid://7539983773",
    Fly      = "rbxassetid://13288142767",
    Speed    = "rbxassetid://6684648436",
    Anim     = "rbxassetid://12099513379",
    ART      = "rbxassetid://13145097542",
    EditOff  = "rbxassetid://4772171909",
    EditOn   = "rbxassetid://9735358798",
    TP       = "rbxassetid://12941020168",
    EyeOpen  = "rbxassetid://6473251976",
    EyeClose = "rbxassetid://6473252651",
    AH       = "rbxassetid://10723395457",
    Lock     = "rbxassetid://15117261700",
    Silver   = "rbxassetid://99162408431074",
}

local MobileScreenGui = Instance.new("ScreenGui")
MobileScreenGui.Name             = "Doomsense_Mobile_Overlay"
MobileScreenGui.Parent           = CoreGui
MobileScreenGui.ZIndexBehavior   = Enum.ZIndexBehavior.Sibling
MobileScreenGui.ResetOnSpawn     = false
MobileScreenGui.IgnoreGuiInset   = true
MobileScreenGui.Enabled          = GlobalConfig.ShowMobileBtn

local HttpService = game:GetService("HttpService")
local PosFilePath = "Doomsense/cfg/MobilePositions.json"

function MobileControl:SavePositions()
    local data = {}
    for id, btn in pairs(self.Buttons) do
        if btn.Canvas then
            local pos = btn.Canvas.Position
            data[id] = { XScale = pos.X.Scale, XOffset = pos.X.Offset, YScale = pos.Y.Scale, YOffset = pos.Y.Offset }
        end
    end
    pcall(function() writefile(PosFilePath, HttpService:JSONEncode(data)) end)
end

local function GetSavedPos(id, defaultPos)
    local s, res = pcall(function()
        if isfile(PosFilePath) then return HttpService:JSONDecode(readfile(PosFilePath)) end
    end)
    if s and type(res) == "table" and res[id] then
        return UDim2.new(res[id].XScale, res[id].XOffset, res[id].YScale, res[id].YOffset)
    end
    return defaultPos
end

function MobileControl:GetCurrentColors()
    local themeName = Fluent.Theme or "Dark"
    local colors = {
        Main   = Color3.fromRGB(60, 60, 60),
        Accent = Color3.fromRGB(96, 205, 255),
        Text   = Color3.fromRGB(240, 240, 240),
        Stroke = Color3.fromRGB(90, 90, 90),
    }
    if themeName == "Darker" then
        colors.Accent = Color3.fromRGB(72, 138, 182); colors.Main = Color3.fromRGB(30, 30, 30); colors.Stroke = Color3.fromRGB(60, 60, 60)
    elseif themeName == "Light" then
        colors.Accent = Color3.fromRGB(0, 103, 192); colors.Main = Color3.fromRGB(200, 200, 200); colors.Text = Color3.fromRGB(0, 0, 0); colors.Stroke = Color3.fromRGB(120, 120, 120)
    elseif themeName == "Aqua" then
        colors.Accent = Color3.fromRGB(60, 165, 165); colors.Main = Color3.fromRGB(30, 60, 60)
    elseif themeName == "Amethyst" then
        colors.Accent = Color3.fromRGB(97, 62, 167); colors.Main = Color3.fromRGB(45, 30, 65)
    elseif themeName == "Rose" then
        colors.Accent = Color3.fromRGB(180, 55, 90); colors.Main = Color3.fromRGB(40, 40, 40)
    end
    return colors
end

function MobileControl:GetSafePosition(currentUDim2, currentSizeX, currentSizeY)
    local vp = Camera.ViewportSize
    if vp.X == 0 or vp.Y == 0 then return currentUDim2 end
    local pixelX = (currentUDim2.X.Scale * vp.X) + currentUDim2.X.Offset
    local pixelY = (currentUDim2.Y.Scale * vp.Y) + currentUDim2.Y.Offset
    local TargetX = math.clamp(pixelX, 0, vp.X - currentSizeX)
    local TargetY = math.clamp(pixelY, 0, vp.Y - currentSizeY)
    return UDim2.new(TargetX / vp.X, 0, TargetY / vp.Y, 0)
end

function MobileControl:CreateButton(id, icon, defaultScalePos, callback)
    if self.Buttons[id] and self.Buttons[id].Canvas then self.Buttons[id].Canvas:Destroy() end

    local settings = ButtonSettings[id]
    local sizePx   = settings.Size

    local Canvas = Instance.new("CanvasGroup")
    Canvas.Name     = id
    Canvas.Size     = UDim2.fromOffset(sizePx, sizePx)
    Canvas.Position = self:GetSafePosition(defaultScalePos, sizePx, sizePx)
    Canvas.BackgroundTransparency = 1
    Canvas.GroupTransparency = settings.Transp / 100
    Canvas.Visible  = settings.Enabled
    Canvas.Parent   = MobileScreenGui

    local Rotator = Instance.new("Frame")
    Rotator.Size            = UDim2.new(1, -6, 1, -6)
    Rotator.AnchorPoint     = Vector2.new(0.5, 0.5)
    Rotator.Position        = UDim2.new(0.5, 0, 0.5, 0)
    Rotator.BorderSizePixel = 0
    Rotator.BackgroundTransparency = 0.5
    Rotator.Parent          = Canvas

    local Stroke = Instance.new("UIStroke")
    Stroke.Thickness = 2; Stroke.Parent = Rotator
    Instance.new("UICorner", Rotator).CornerRadius = UDim.new(1, 0)

    local IconImg = Instance.new("ImageLabel")
    IconImg.Size       = UDim2.new(0.6, 0, 0.6, 0)
    IconImg.AnchorPoint = Vector2.new(0.5, 0.5)
    IconImg.Position   = UDim2.new(0.5, 0, 0.5, 0)
    IconImg.BackgroundTransparency = 1
    IconImg.Image      = icon
    IconImg.ZIndex     = 5
    IconImg.Parent     = Canvas

    local LockOverlay = Instance.new("Frame")
    LockOverlay.Size            = UDim2.new(1, -6, 1, -6)
    LockOverlay.AnchorPoint     = Vector2.new(0.5, 0.5)
    LockOverlay.Position        = UDim2.new(0.5, 0, 0.5, 0)
    LockOverlay.BackgroundTransparency = 0.5
    LockOverlay.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
    LockOverlay.Visible         = false
    LockOverlay.ZIndex          = 10
    LockOverlay.Parent          = Canvas
    local LockIcon = Instance.new("ImageLabel")
    LockIcon.Size       = UDim2.new(0.5, 0, 0.5, 0)
    LockIcon.AnchorPoint = Vector2.new(0.5, 0.5)
    LockIcon.Position   = UDim2.new(0.5, 0, 0.5, 0)
    LockIcon.BackgroundTransparency = 1
    LockIcon.Image      = MOB_ICONS.Lock
    LockIcon.ImageColor3 = Color3.new(1, 1, 1)
    LockIcon.Parent     = LockOverlay
    Instance.new("UICorner", LockOverlay).CornerRadius = UDim.new(1, 0)

    local ClickHitbox = Instance.new("TextButton")
    ClickHitbox.Size = UDim2.new(1, 0, 1, 0); ClickHitbox.BackgroundTransparency = 1
    ClickHitbox.Text = ""; ClickHitbox.ZIndex = 20; ClickHitbox.Parent = Canvas

    local DragHitbox = Instance.new("TextButton")
    DragHitbox.Size     = UDim2.new(1.2, 0, 1.2, 0)
    DragHitbox.Position = UDim2.new(-0.1, 0, -0.1, 0)
    DragHitbox.BackgroundColor3 = Color3.fromRGB(255, 215, 0)
    DragHitbox.BackgroundTransparency = 0.7
    DragHitbox.Text    = "DRAG"
    DragHitbox.Visible = self.EditMode
    DragHitbox.ZIndex  = 30
    DragHitbox.Parent  = Canvas
    Instance.new("UICorner", DragHitbox).CornerRadius = UDim.new(1, 0)

    local isActive = false
    local isLocked = false

    local function UpdateVisuals()
        local Theme       = MobileControl:GetCurrentColors()
        local targetColor  = isActive and Theme.Accent or Theme.Main
        local targetStroke = isActive and Theme.Text or Theme.Stroke
        local targetTransp = isActive and 0.2 or 0.5
        local targetRot    = isActive and 45 or 0
        local targetIconCol = Theme.Text
        if id == "ART" or id == "Silver" then targetIconCol = Color3.new(1, 1, 1) end

        TweenService:Create(Rotator, TweenInfo.new(0.3), {
            BackgroundColor3       = targetColor,
            BackgroundTransparency = targetTransp,
            Rotation               = targetRot,
        }):Play()
        Stroke.Color      = targetStroke
        IconImg.ImageColor3 = targetIconCol
        LockOverlay.Visible = isLocked
    end

    ClickHitbox.MouseButton1Click:Connect(function()
        if not self.EditMode and not isLocked and callback then callback() end
    end)

    local dragConn, endConn

    DragHitbox.InputBegan:Connect(function(input)
        if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
            if dragConn then dragConn:Disconnect(); dragConn = nil end
            if endConn  then endConn:Disconnect();  endConn  = nil end

            local dragStart = input.Position
            local startPos  = Canvas.Position

            dragConn = UserInputService.InputChanged:Connect(function(changeInput)
                if changeInput.UserInputType == Enum.UserInputType.MouseMovement or changeInput.UserInputType == Enum.UserInputType.Touch then
                    local delta  = changeInput.Position - dragStart
                    local newPos = UDim2.new(startPos.X.Scale, startPos.X.Offset + delta.X, startPos.Y.Scale, startPos.Y.Offset + delta.Y)
                    Canvas.Position = MobileControl:GetSafePosition(newPos, Canvas.AbsoluteSize.X, Canvas.AbsoluteSize.Y)
                end
            end)

            endConn = UserInputService.InputEnded:Connect(function(endInput)
                if endInput.UserInputType == Enum.UserInputType.MouseButton1 or endInput.UserInputType == Enum.UserInputType.Touch then
                    if dragConn then dragConn:Disconnect(); dragConn = nil end
                    if endConn  then endConn:Disconnect();  endConn  = nil end
                    local s = Canvas.AbsoluteSize
                    Canvas.Position = MobileControl:GetSafePosition(Canvas.Position, s.X, s.Y)
                    MobileControl:SavePositions()
                end
            end)
        end
    end)

    UpdateVisuals()

    self.Buttons[id] = {
        Canvas     = Canvas,
        IconImg    = IconImg,
        DragHitbox = DragHitbox,
        Update     = UpdateVisuals,
        SetState   = function(val) isActive = val; UpdateVisuals() end,
        SetLocked  = function(val) isLocked = val; UpdateVisuals() end,
        ApplySettings = function()
            local s = ButtonSettings[id]
            Canvas.Size = UDim2.fromOffset(s.Size, s.Size)
            Canvas.GroupTransparency = s.Transp / 100
            if id ~= "Menu" and id ~= "HideUI" then
                Canvas.Visible = MobileControl.IsVisible and s.Enabled
            else
                Canvas.Visible = s.Enabled
            end
        end,
    }
end

function MobileControl:UpdateAllThemes()
    for _, btn in pairs(self.Buttons) do if btn.Update then btn.Update() end end
end

function MobileControl:SetEditMode(state)
    self.EditMode = state
    for _, btn in pairs(self.Buttons) do
        if btn.DragHitbox then btn.DragHitbox.Visible = state end
    end
end

function MobileControl:ToggleVisibility()
    self.IsVisible = not self.IsVisible
    for id, btn in pairs(self.Buttons) do
        if id ~= "Menu" and id ~= "HideUI" then
            btn.Canvas.Visible = self.IsVisible and ButtonSettings[id].Enabled
        end
    end
    local eyeBtn = self.Buttons["HideUI"]
    if eyeBtn then
        eyeBtn.IconImg.Image = self.IsVisible and MOB_ICONS.EyeOpen or MOB_ICONS.EyeClose
    end
end

function MobileControl:Lock(id, state)
    if self.Buttons[id] then self.Buttons[id].SetLocked(state) end
end

local function UpdateBtnConfig(id)
    if MobileControl.Buttons[id] then MobileControl.Buttons[id].ApplySettings() end
end

MobileControl:CreateButton("Menu",    MOB_ICONS.Menu,    GetSavedPos("Menu",     UDim2.new(0.9, 0, 0.4, 0)), function()
    if Window then Window:Minimize() end
end)
MobileControl:CreateButton("HideUI",  MOB_ICONS.EyeOpen, GetSavedPos("HideUI",   UDim2.new(0.82, 0, 0.4, 0)), function() MobileControl:ToggleVisibility() end)
MobileControl:CreateButton("Fly",     MOB_ICONS.Fly,     GetSavedPos("Fly",      UDim2.new(0.9, 0, 0.55, 0)), function() if Options.FlyTog   then Options.FlyTog:SetValue(not Options.FlyTog.Value) end end)
MobileControl:CreateButton("Speed",   MOB_ICONS.Speed,   GetSavedPos("Speed",    UDim2.new(0.9, 0, 0.7, 0)),  function() if Options.SpeedTog then Options.SpeedTog:SetValue(not Options.SpeedTog.Value) end end)
MobileControl:CreateButton("ART",     MOB_ICONS.ART,     GetSavedPos("ART",      UDim2.new(0.9, 0, 0.85, 0)), function() if Options.ARTTog   then Options.ARTTog:SetValue(not Options.ARTTog.Value) end end)
MobileControl:CreateButton("Teleport",MOB_ICONS.TP,      GetSavedPos("Teleport", UDim2.new(0.82, 0, 0.85, 0)), function()
    VirtualInputManager:SendKeyEvent(true,  GlobalState.TeleportBind or Enum.KeyCode.V, false, game)
    task.wait(0.05)
    VirtualInputManager:SendKeyEvent(false, GlobalState.TeleportBind or Enum.KeyCode.V, false, game)
end)
MobileControl:CreateButton("AH",      MOB_ICONS.AH,      GetSavedPos("AH",       UDim2.new(0.82, 0, 0.55, 0)), function() if Options.AHTog       then Options.AHTog:SetValue(not Options.AHTog.Value) end end)
MobileControl:CreateButton("Anim",    MOB_ICONS.Anim,    GetSavedPos("Anim",     UDim2.new(0.82, 0, 0.7, 0)),  function() if Options.Anim_PlayTog then Options.Anim_PlayTog:SetValue(not Options.Anim_PlayTog.Value) end end)
MobileControl:CreateButton("Silver",  MOB_ICONS.Silver,  GetSavedPos("Silver",   UDim2.new(0.74, 0, 0.85, 0)), function() if Options.SilverTog   then Options.SilverTog:SetValue(not Options.SilverTog.Value) end end)

GlobalState.UpdateMobileBtn = function(id, state)
    if MobileControl.Buttons[id] then MobileControl.Buttons[id].SetState(state) end
end

TabMobile:AddToggle("Mob_Enable", {
    Title   = "Show Mobile Overlay",
    Default = true,
    Callback = function(v)
        MobileScreenGui.Enabled = v
        GlobalConfig.ShowMobileBtn = v
    end
})

TabMobile:AddToggle("Mob_Edit", {
    Title    = "Edit Mode (Drag Buttons)",
    Default  = false,
    Callback = function(v) MobileControl:SetEditMode(v) end
})

local EdSection = TabMobile:AddSection("Button Editor")

local function AddEditorControls(id, hasToggle)
    EdSection:AddParagraph({ Title = id, Content = "" })
    EdSection:AddSlider("Size_" .. id, {
        Title = "Size (px)", Default = 50, Min = 1, Max = 100, Rounding = 0,
        Callback = function(v) ButtonSettings[id].Size = v; UpdateBtnConfig(id) end
    })
    EdSection:AddSlider("Transp_" .. id, {
        Title = "Transparency %", Default = 0, Min = 0, Max = 100, Rounding = 0,
        Callback = function(v) ButtonSettings[id].Transp = v; UpdateBtnConfig(id) end
    })
    if hasToggle then
        EdSection:AddToggle("Enable_" .. id, {
            Title = "Button Present?", Default = true,
            Callback = function(v) ButtonSettings[id].Enabled = v; UpdateBtnConfig(id) end
        })
    end
end

AddEditorControls("Menu",     false)
AddEditorControls("HideUI",   true)
AddEditorControls("Fly",      true)
AddEditorControls("Speed",    true)
AddEditorControls("ART",      true)
AddEditorControls("Teleport", true)
AddEditorControls("AH",       true)
AddEditorControls("Anim",     true)
AddEditorControls("Silver",   true)

-- UI: Settings Tab
local TabSettings = Tabs.Settings
SaveManager:SetLibrary(Fluent)
InterfaceManager:SetLibrary(Fluent)
SaveManager:IgnoreThemeSettings()
InterfaceManager:SetFolder("Doomsense/cfg")
SaveManager:SetFolder("Doomsense/cfg")
InterfaceManager:BuildInterfaceSection(TabSettings)
SaveManager:BuildConfigSection(TabSettings)
TabSettings:AddButton({
    Title = "REJOIN SERVER",
    Description = "Rejoins the current server",
    Callback = function()
        if #Players:GetPlayers() <= 1 then
            TeleportService:Teleport(game.PlaceId, LocalPlayer)
        else
            TeleportService:TeleportToPlaceInstance(game.PlaceId, game.JobId, LocalPlayer)
        end
    end
})

-- ═══════════════════════════════════════════════════════════════════════════
-- REWORKED SMART NOCLIP
-- ═══════════════════════════════════════════════════════════════════════════
local CachedNoclipRayParams = RaycastParams.new()
CachedNoclipRayParams.FilterType = Enum.RaycastFilterType.Exclude
CachedNoclipRayParams.IgnoreWater = true

local CachedNoclipOverlap = OverlapParams.new()
CachedNoclipOverlap.FilterType = Enum.RaycastFilterType.Exclude

local function HandleSmartNoclip(targetPos)
    local char = LocalPlayer.Character
    if not char then return end
    local root = char:FindFirstChild("HumanoidRootPart") or char.PrimaryPart
    if not root then return end

    local isFlyNoclip = (GlobalConfig.IsFlying and GlobalConfig.Main.NoclipMode == "On")
    local isAHNoclip  = (GlobalConfig.AH.Enabled and GlobalConfig.AH.Noclip)
    local isNoclipActive = isFlyNoclip or isAHNoclip

    local NState = GlobalState.Noclip

    if not isNoclipActive then
        for part, _ in pairs(NState.ActiveObstacles) do
            if part and part.Parent then pcall(function() part.CanCollide = true end) end
        end
        table.clear(NState.ActiveObstacles)
        return
    end

    local currentObstacles = {}
    local playersFolder = Workspace:FindFirstChild("Players")
    local filterList = { char, Camera, playersFolder }

    CachedNoclipRayParams.FilterDescendantsInstances = filterList
    CachedNoclipOverlap.FilterDescendantsInstances = filterList

    if targetPos then
        local dir = (targetPos - root.Position)
        if dir.Magnitude > 0.5 then
            local rayResult = Workspace:Raycast(root.Position, dir, CachedNoclipRayParams)
            if rayResult and rayResult.Instance and rayResult.Instance:IsA("BasePart") then
                local hitPart = rayResult.Instance
                if math.abs(rayResult.Normal.Y) < 0.7 then
                    currentObstacles[hitPart] = true
                end
            end
        end
    end

    local nearParts = Workspace:GetPartBoundsInBox(root.CFrame, Vector3.new(2.5, 4.0, 2.5), CachedNoclipOverlap)
    local feetY = root.Position.Y - 2.0

    for _, part in ipairs(nearParts) do
        if part:IsA("BasePart") then
            local partTopY = part.Position.Y + (part.Size.Y * 0.5)
            if partTopY > feetY + 0.3 then
                currentObstacles[part] = true
            end
        end
    end

    for part, _ in pairs(currentObstacles) do
        if part.CanCollide then
            NState.ActiveObstacles[part] = true
            part.CanCollide = false
        end
    end

    for part, _ in pairs(NState.ActiveObstacles) do
        if part and part.Parent then
            if not currentObstacles[part] then
                part.CanCollide = true
                NState.ActiveObstacles[part] = nil
            end
        else
            NState.ActiveObstacles[part] = nil
        end
    end
end

-- Core Loop Functions
local function DoPhysics()
    if GlobalConfig.AH.Enabled then return end

    local char = LocalPlayer.Character
    if not char then return end
    local root = char:FindFirstChild("HumanoidRootPart") or char.PrimaryPart
    local hum  = char:FindFirstChildOfClass("Humanoid")
    if not root or not hum then return end
    
    HandleSmartNoclip()

    if GlobalConfig.IsFlying and BodyVel and BodyGyro then
        if not root:FindFirstChild("DoomVel") then
            SetFeatureState("FlyTog", true)
            return
        end

        local camCF = Camera.CFrame
        local move  = Vector3.zero

        if UserInputService:IsKeyDown(Enum.KeyCode.W) then move = move + camCF.LookVector end
        if UserInputService:IsKeyDown(Enum.KeyCode.S) then move = move - camCF.LookVector end
        if UserInputService:IsKeyDown(Enum.KeyCode.A) then move = move - camCF.RightVector end
        if UserInputService:IsKeyDown(Enum.KeyCode.D) then move = move + camCF.RightVector end
        
        pcall(function()
            local upKey = GlobalConfig.Main.FlyUpKey or "Space"
            local downKey = GlobalConfig.Main.FlyDownKey or "LeftShift"
            if UserInputService:IsKeyDown(Enum.KeyCode[upKey]) then move = move + Vector3.new(0, 1, 0) end
            if UserInputService:IsKeyDown(Enum.KeyCode[downKey]) then move = move - Vector3.new(0, 1, 0) end
        end)

        if move.Magnitude > 0 then
            BodyVel.Velocity = move.Unit * GlobalConfig.FlySpeed
        else
            BodyVel.Velocity = Vector3.zero
            root.AssemblyLinearVelocity = Vector3.zero
            root.AssemblyAngularVelocity = Vector3.zero
            root.Velocity = Vector3.zero
        end

        BodyGyro.CFrame = camCF

    elseif GlobalConfig.IsSpeeding and not GlobalConfig.IsFlying then
        if hum.MoveDirection.Magnitude > 0 then
            root.Velocity = Vector3.new(
                hum.MoveDirection.X * GlobalConfig.WalkSpeed,
                root.Velocity.Y,
                hum.MoveDirection.Z * GlobalConfig.WalkSpeed
            )
        end
    end
end

local function DoSilverRecord()
    local S = GlobalState.Silver
    if not S.IsRecording or S.IsRewinding then return end

    local char = LocalPlayer.Character
    local root = char and (char:FindFirstChild("HumanoidRootPart") or char.PrimaryPart)
    if not root then return end

    if not S.LastPos then
        S.LastPos = root.Position
        local p = CreateSilverPoint(root.CFrame, true)
        table.insert(S.Points, p)
        return
    end

    if (root.Position - S.LastPos).Magnitude >= S.MinDist then
        S.LastPos = root.Position
        local p = CreateSilverPoint(root.CFrame, false)
        table.insert(S.Points, p)

        if #S.Points > S.MaxPoints then
            local startPoint  = S.Points[1]
            local secondPoint = S.Points[2]
            if startPoint and secondPoint then
                startPoint.CFrame = secondPoint.CFrame
                secondPoint:Destroy()
                table.remove(S.Points, 2)
            end
        end
    end
end

local function UpdateTargetHistory(char, root)
    local H = GlobalState.AH.History
    if not H[char] then H[char] = {} end
    local buffer = H[char]
    
    local hum = char:FindFirstChildOfClass("Humanoid")
    local state = hum and hum:GetState() or Enum.HumanoidStateType.Running
    local currentVel = root.AssemblyLinearVelocity or root.Velocity or Vector3.zero

    table.insert(buffer, {
        Pos   = root.Position,
        Vel   = currentVel,
        State = state,
        Time  = tick()
    })

    if #buffer > 5 then
        table.remove(buffer, 1)
    end
end

local function Calculate3DPrediction(char, root, leadTime)
    local buffer = GlobalState.AH.History[char]
    if not buffer or #buffer < 2 then
        local vel = root.AssemblyLinearVelocity or root.Velocity or Vector3.zero
        return root.Position + (vel * leadTime)
    end

    local first = buffer[1]
    local last  = buffer[#buffer]
    local dt    = math.max(last.Time - first.Time, 0.001)
    
    local avgVel = (last.Pos - first.Pos) / dt
    local accel  = (last.Vel - first.Vel) / dt

    local verticalFactor = 1.0
    if last.State == Enum.HumanoidStateType.Freefall then
        verticalFactor = 1.25
    elseif last.State == Enum.HumanoidStateType.Jumping then
        verticalFactor = 0.85
    end

    local predicted3D = root.Position + (avgVel * leadTime) + (0.5 * accel * (leadTime ^ 2) * Vector3.new(1, verticalFactor, 1))
    return predicted3D
end

local function DoAutoHunt()
    local myChar = LocalPlayer.Character
    local myHum  = myChar and myChar:FindFirstChildOfClass("Humanoid")
    local myRoot = myChar and (myChar:FindFirstChild("HumanoidRootPart") or myChar.PrimaryPart)

    if not GlobalConfig.AH.Enabled then
        GlobalState.AH.LockedRandomTarget = nil
        UpdateAHVisual(nil)
        if myHum and myHum.PlatformStand then
            myHum.PlatformStand = false
        end
        return
    end

    local gs = GetGameState()
    local isLocalEXE = myChar and IsGameEXE(myChar)

    if (gs ~= "ING" and gs ~= "80s") or not isLocalEXE then
        GlobalState.AH.LockedRandomTarget = nil
        UpdateAHVisual(nil)
        if myHum and myHum.PlatformStand then
            myHum.PlatformStand = false
        end
        return
    end

    if myChar then
        local isHardGrabbing = myChar:FindFirstChild("grab") 
            or CollectionService:HasTag(myChar, "Kill") 
            or CollectionService:HasTag(myChar, "Carried")
            or CollectionService:HasTag(myChar, "Grabbed")
        
        if isHardGrabbing then
            if myRoot then
                myRoot.AssemblyLinearVelocity  = Vector3.zero
                myRoot.AssemblyAngularVelocity = Vector3.zero
                myRoot.Velocity                = Vector3.zero
            end
            return
        end
    end

    local target = GetBestTarget()
    if target and myChar and myRoot and myHum then
        local tRoot = target:FindFirstChild("HumanoidRootPart") or target.PrimaryPart

        if tRoot then
            if not myHum.PlatformStand then
                myHum.PlatformStand = true
            end

            local tVel = tRoot.AssemblyLinearVelocity or tRoot.Velocity or Vector3.zero
            local planarVel = Vector3.new(tVel.X, 0, tVel.Z)
            local isTargetMoving = (planarVel.Magnitude > 1.2) or (math.abs(tVel.Y) > 2.0)

            local distToTarget = (myRoot.Position - tRoot.Position).Magnitude
            local maxHitRange  = math.abs(GlobalConfig.AH.Distance) + 6.0
            local isWithinHitRange = (distToTarget <= maxHitRange)

            local shouldHoldPosition = (not isTargetMoving) and isWithinHitRange

            local predictPos = tRoot.Position + (planarVel * 0.08)
            local lookDir = tRoot.CFrame.LookVector
            local baseCFrame = CFrame.lookAt(predictPos, predictPos + lookDir)

            -- Auto-Adaptive Height System
            local targetSize = GetModelStudSize(target)
            local targetHum = target:FindFirstChildOfClass("Humanoid")
            local tState = targetHum and targetHum:GetState()
            
            local autoHeightOffset = (targetSize.Y * 0.15)

            if tState == Enum.HumanoidStateType.Freefall then
                autoHeightOffset = autoHeightOffset - 0.5
            elseif tState == Enum.HumanoidStateType.Jumping then
                autoHeightOffset = autoHeightOffset + 0.8
            elseif IsDowned(target) then
                autoHeightOffset = -1.8
            end

            -- Floor Clamping
            local floorRay = Workspace:Raycast(predictPos, Vector3.new(0, -6, 0), CachedNoclipRayParams)
            if floorRay then
                local floorY = floorRay.Position.Y + 2.3
                if (predictPos.Y + autoHeightOffset + GlobalConfig.AH.Height) < floorY then
                    autoHeightOffset = floorY - predictPos.Y - GlobalConfig.AH.Height
                end
            end

            local finalHeight = GlobalConfig.AH.Height + autoHeightOffset

            local angleRotation = CFrame.Angles(
                math.rad(GlobalConfig.AH.RotX or 0),
                math.rad(GlobalConfig.AH.RotY or 0),
                math.rad(GlobalConfig.AH.RotZ or 0)
            )

            local targetCFrame = baseCFrame * CFrame.new(0, finalHeight, GlobalConfig.AH.Distance) * angleRotation

            HandleSmartNoclip(predictPos)

            if not shouldHoldPosition then
                myRoot.CFrame = targetCFrame
            end

            myRoot.AssemblyLinearVelocity  = Vector3.zero
            myRoot.AssemblyAngularVelocity = Vector3.zero
            myRoot.Velocity                = Vector3.zero

            local attackDelay = math.clamp(tonumber(GlobalConfig.AH.Delay) or 0.05, 0.05, 5)
            local canHit = true
            if GlobalConfig.AH.SmartAttack then
                canHit = isWithinHitRange
            end

            if canHit and (tick() - GlobalState.AH.LastAttack >= attackDelay) then
                GlobalState.AH.LastAttack = tick()
                FastAttackTrigger()
            end

            UpdateAHVisual(tRoot)
        else
            GlobalState.AH.LockedRandomTarget = nil
            UpdateAHVisual(nil)
        end
    else
        GlobalState.AH.LockedRandomTarget = nil
        UpdateAHVisual(nil)
        if myRoot then 
            myRoot.AssemblyLinearVelocity  = Vector3.zero
            myRoot.AssemblyAngularVelocity = Vector3.zero
            myRoot.Velocity                = Vector3.zero 
        end
        if myHum and myHum.PlatformStand then
            myHum.PlatformStand = false
        end
    end
end

local function DoNoCDJump()
    if not GlobalConfig.NoCDJump or not LocalPlayer.Character then return end
    local hum = LocalPlayer.Character:FindFirstChildOfClass("Humanoid")
    if hum then
        hum:SetStateEnabled(Enum.HumanoidStateType.Jumping, true)
        if not hum.Jump and UserInputService:IsKeyDown(Enum.KeyCode.Space) then
            hum.Jump = true
        end
    end
end

local LocalTagGui, LocalTagLabel = nil, nil
local LocAnimTimer = 0
local LocAnimStep  = 1

local function DoLocalTagRender(dt)
    local lCfg = Cfg.Local
    if not lCfg or not lCfg.Tag_Enabled or not LocalPlayer.Character then
        if LocalTagGui then LocalTagGui.Enabled = false end
        return
    end

    local head = LocalPlayer.Character:FindFirstChild("Head") or LocalPlayer.Character.PrimaryPart
    if not head then
        if LocalTagGui then LocalTagGui.Enabled = false end
        return
    end

    if not LocalTagGui or not LocalTagGui.Parent then
        LocalTagGui = Instance.new("BillboardGui")
        LocalTagGui.Name = "Doom_Local_Tag"
        LocalTagGui.Size = UDim2.new(0, 200, 0, 40)
        LocalTagGui.StudsOffset = Vector3.new(0, 3.2, 0)
        LocalTagGui.AlwaysOnTop = true
        LocalTagGui.Parent = Visuals_Folder

        LocalTagLabel = Instance.new("TextLabel", LocalTagGui)
        LocalTagLabel.Size = UDim2.fromScale(1, 1)
        LocalTagLabel.BackgroundTransparency = 1
        LocalTagLabel.Font = Enum.Font.GothamBold
        LocalTagLabel.TextSize = 14
    end

    LocalTagGui.Enabled = true
    LocalTagGui.Adornee = head

    local fullText = (lCfg.Tag_Mode == "DOOMSENSE") and "DOOMSENSE" or (lCfg.Tag_Custom or "DOOMSENSE")
    local displayText = fullText

    if lCfg.Tag_Type == "Anim" then
        LocAnimTimer = LocAnimTimer + dt
        local totalChars = #fullText
        local totalSteps = (totalChars * 2) + 4
        if LocAnimTimer >= 0.333 then
            LocAnimTimer = 0
            LocAnimStep = LocAnimStep + 1
            if LocAnimStep > totalSteps then LocAnimStep = 1 end
        end

        if LocAnimStep <= totalChars then
            displayText = string.sub(fullText, 1, LocAnimStep)
        elseif LocAnimStep <= totalChars + 3 then
            displayText = fullText
        elseif LocAnimStep <= (totalChars * 2) + 3 then
            local rem = totalChars - (LocAnimStep - (totalChars + 3))
            displayText = string.sub(fullText, 1, math.max(0, rem))
        else
            displayText = " "
        end
    end

    LocalTagLabel.Text = displayText
    LocalTagLabel.TextColor3 = lCfg.Tag_FillCol
    LocalTagLabel.TextStrokeColor3 = lCfg.Tag_OutCol
    local t = GetTrans(lCfg.Tag_Limp, true)
    LocalTagLabel.TextTransparency = t
    LocalTagLabel.TextStrokeTransparency = t
end

local function DoVisualsRender()

    local gs = GetGameState()
    local isRoundActive = (gs == "ING" or gs == "80s")

    if not isRoundActive then
        for m, hl in pairs(GlobalState.Vis.HighlightCache) do
            if hl and hl.Parent then hl:Destroy() end
        end
        for m, tags in pairs(GlobalState.Vis.TagCache) do
            if tags and tags.BoxFrame and tags.BoxFrame.Parent then
                tags.BoxFrame:Destroy()
            end
        end
        table.clear(GlobalState.Vis.HighlightCache)
        table.clear(GlobalState.Vis.TagCache)
        return
    end

    -- Cleanup Orphaned Player Visuals
    for m, hl in pairs(GlobalState.Vis.HighlightCache) do
        if not m or not m.Parent or not m:IsDescendantOf(Workspace) then
            if hl and hl.Parent then hl:Destroy() end
            GlobalState.Vis.HighlightCache[m] = nil
        end
    end

    for m, tags in pairs(GlobalState.Vis.TagCache) do
        if not m or not m.Parent or not m:IsDescendantOf(Workspace) then
            if tags and tags.BoxFrame and tags.BoxFrame.Parent then
                tags.BoxFrame:Destroy()
            end
            GlobalState.Vis.TagCache[m] = nil
        end
    end

    for _, p in pairs(Players:GetPlayers()) do
        local char = p.Character
        if char and char:IsDescendantOf(Workspace) then
            local root = char:FindFirstChild("HumanoidRootPart") or char.PrimaryPart or char:FindFirstChild("Torso") or char:FindFirstChild("UpperTorso") or char:FindFirstChild("Head")
            if not root then continue end

            local charAttr = GetCharacterName(char, p)
            local isLocal  = (p == LocalPlayer)

            -- STRICT LOBBY ELIMINATION: Never draw WH or Tags in Lobby!
            if IsInLobbyArea(root.Position) or IsPlayerEscaped(p, char) then
                if GlobalState.Vis.HighlightCache[char] then
                    GlobalState.Vis.HighlightCache[char].Enabled = false
                end
                if GlobalState.Vis.TagCache[char] and GlobalState.Vis.TagCache[char].BoxFrame then
                    GlobalState.Vis.TagCache[char].BoxFrame.Visible = false
                end
                continue
            end

            if isLocal then
                local hl = GetHighlight(char)
                if Cfg.Local and Cfg.Local.Enabled then
                    hl.Enabled = true; hl.Adornee = char
                    hl.FillColor    = Cfg.Local.FillCol
                    hl.OutlineColor = Cfg.Local.OutCol
                    hl.FillTransparency    = GetTrans(Cfg.Local.Limp_Fill, Cfg.Local.Style and Cfg.Local.Style["Fill"])
                    hl.OutlineTransparency = GetTrans(Cfg.Local.Limp_Out, Cfg.Local.Style and Cfg.Local.Style["Outline"])
                else
                    hl.Enabled = false
                end
            else
                local isExe = IsGameEXE(char)
                local hl    = GetHighlight(char)
                local tData = GetTags(char)

                -- 1. Chams
                local isEnabled = false
                if isExe then
                    isEnabled = Cfg.Chams and Cfg.Chams.EXE_Enabled
                else
                    isEnabled = Cfg.Chams and Cfg.Chams.Surv_Enabled
                end

                if isEnabled then
                    hl.Enabled = true; hl.Adornee = char
                    local showFill = false
                    local showOut  = false
                    if isExe then
                        showFill = Cfg.Chams.EXE_Style and Cfg.Chams.EXE_Style["Fill"]
                        showOut  = Cfg.Chams.EXE_Style and Cfg.Chams.EXE_Style["Outline"]
                        hl.FillColor = Cfg.Chams.EXE_FillCol; hl.OutlineColor = Cfg.Chams.EXE_OutCol
                        hl.FillTransparency    = GetTrans(Cfg.Chams.EXE_Limp_Fill, showFill)
                        hl.OutlineTransparency = GetTrans(Cfg.Chams.EXE_Limp_Out, showOut)
                    else
                        showFill = Cfg.Chams.Surv_Style and Cfg.Chams.Surv_Style["Fill"]
                        showOut  = Cfg.Chams.Surv_Style and Cfg.Chams.Surv_Style["Outline"]
                        hl.FillColor = Cfg.Chams.Surv_FillCol; hl.OutlineColor = Cfg.Chams.Surv_OutCol
                        hl.FillTransparency    = GetTrans(Cfg.Chams.Surv_Limp_Fill, showFill)
                        hl.OutlineTransparency = GetTrans(Cfg.Chams.Surv_Limp_Out, showOut)
                    end
                else
                    hl.Enabled = false
                end

                -- 2. 2D Box Calculation via Model Dimensions
                local boxSize3D = GetModelStudSize(char)
                local rootCF    = root.CFrame
                local halfX, halfY, halfZ = boxSize3D.X / 2, boxSize3D.Y / 2, boxSize3D.Z / 2

                local minX, minY = math.huge, math.huge
                local maxX, maxY = -math.huge, -math.huge
                local anyVisible = false

                for sx = -1, 1, 2 do
                    for sy = -1, 1, 2 do
                        for sz = -1, 1, 2 do
                            local cornerPos = rootCF:PointToWorldSpace(Vector3.new(halfX * sx, halfY * sy, halfZ * sz))
                            local screenPos, onScreen = Camera:WorldToViewportPoint(cornerPos)
                            if onScreen then anyVisible = true end
                            if screenPos.X < minX then minX = screenPos.X end
                            if screenPos.Y < minY then minY = screenPos.Y end
                            if screenPos.X > maxX then maxX = screenPos.X end
                            if screenPos.Y > maxY then maxY = screenPos.Y end
                        end
                    end
                end

                local distStuds = (Camera.CFrame.Position - root.Position).Magnitude
                local isDistanceValid = distStuds > 3.57
                
                local wOffset = isExe and (Cfg.TwoD.EXE_Box_WOffset or 0) or (Cfg.TwoD.Surv_Box_WOffset or 0)
                local hOffset = isExe and (Cfg.TwoD.EXE_Box_HOffset or 0) or (Cfg.TwoD.Surv_Box_HOffset or 0)

                minX = minX - wOffset
                maxX = maxX + wOffset
                minY = minY - hOffset
                maxY = maxY + hOffset

                if anyVisible and isDistanceValid and minX < maxX and minY < maxY then
                    tData.BoxFrame.Visible  = true
                    tData.BoxFrame.Position = UDim2.fromOffset(minX, minY)
                    tData.BoxFrame.Size     = UDim2.fromOffset(maxX - minX, maxY - minY)

                    local isBoxOn, boxFillCol, boxOutCol, fillTransp, outTransp
                    if isExe then
                        isBoxOn    = Cfg.TwoD.EXE_Box_Tog
                        boxFillCol = Cfg.TwoD.EXE_Box_Fill
                        boxOutCol  = Cfg.TwoD.EXE_Box_Out
                        fillTransp = GetTrans(Cfg.TwoD.EXE_Box_Limp_Fill, isBoxOn)
                        outTransp  = GetTrans(Cfg.TwoD.EXE_Box_Limp_Out, isBoxOn)
                    else
                        isBoxOn    = Cfg.TwoD.Surv_Box_Tog
                        boxFillCol = Cfg.TwoD.Surv_Box_Fill
                        boxOutCol  = Cfg.TwoD.Surv_Box_Out
                        fillTransp = GetTrans(Cfg.TwoD.Surv_Box_Limp_Fill, isBoxOn)
                        outTransp  = GetTrans(Cfg.TwoD.Surv_Box_Limp_Out, isBoxOn)
                    end

                    tData.BoxFrame.BackgroundColor3       = boxFillCol
                    tData.BoxFrame.BackgroundTransparency = fillTransp
                    tData.BoxStroke.Color                 = boxOutCol
                    tData.BoxStroke.Transparency          = outTransp
                    tData.BoxStroke.Enabled               = isBoxOn

-- 3. Dynamic Isolated Tag Routing
                    local globalTrans = GetTrans(Cfg.TwoD.GlobalLimp, true)

                    local function ProcessTagLabel(lbl, isTog, dir, order, fillCol, outCol, limpVal, textStr)
                        if isTog and textStr and textStr ~= "" then
                            local holderFrame = tData.Holders[dir] or tData.Holders.Top
                            if lbl.Parent ~= holderFrame then
                                lbl.Parent = holderFrame
                            end
                            if lbl.Text ~= textStr then
                                lbl.Text = textStr
                            end
                            
                            if dir == "Left" then
                                lbl.TextXAlignment = Enum.TextXAlignment.Right
                            elseif dir == "Right" then
                                lbl.TextXAlignment = Enum.TextXAlignment.Left
                            else
                                lbl.TextXAlignment = Enum.TextXAlignment.Center
                            end
                    
                            lbl.TextColor3            = fillCol
                            lbl.TextStrokeColor3      = outCol
                            local dT                  = math.max(globalTrans, GetTrans(limpVal, true))
                            lbl.TextTransparency      = dT
                            lbl.TextStrokeTransparency = dT
                            lbl.LayoutOrder           = order
                            lbl.Visible               = true
                        else
                            lbl.Visible = false
                        end
                    end

                    local entInfo       = ResolveEntityInfo(char)
                    local isDeadState   = IsDead(char, p)
                    local isDownedState = IsDowned(char, p)
                    local isLastLife    = IsLastLife(char, p)
                    local distMeters    = math.floor(distStuds / 3.57)

                    if isExe then
                        for _, l in pairs(tData.SURV) do l.Visible = false end

                        local isRage = IsRageCheck(char)
                        local isStunState = IsStunned(char, p)
                        ProcessTagLabel(tData.EXE.Role,     Cfg.TwoD.EXE_Role_Tog,     Cfg.TwoD.EXE_Role_Dir,     Cfg.TwoD.EXE_Role_Order,     Cfg.TwoD.EXE_Role_Fill,     Cfg.TwoD.EXE_Role_Out,     Cfg.TwoD.EXE_Role_Limp,     "EXE")
                        ProcessTagLabel(tData.EXE.Rage,     Cfg.TwoD.EXE_Rage_Tog and isRage, Cfg.TwoD.EXE_Rage_Dir, Cfg.TwoD.EXE_Rage_Order, Cfg.TwoD.EXE_Rage_Fill, Cfg.TwoD.EXE_Rage_Out, Cfg.TwoD.EXE_Rage_Limp, "RAGE")
                        ProcessTagLabel(tData.EXE.Stun,     Cfg.TwoD.EXE_Stun_Tog and isStunState, Cfg.TwoD.EXE_Stun_Dir, Cfg.TwoD.EXE_Stun_Order, Cfg.TwoD.EXE_Stun_Fill, Cfg.TwoD.EXE_Stun_Out, Cfg.TwoD.EXE_Stun_Limp, "STUN")
                        ProcessTagLabel(tData.EXE.Dead,     Cfg.TwoD.EXE_Dead_Tog and isDeadState, Cfg.TwoD.EXE_Dead_Dir, Cfg.TwoD.EXE_Dead_Order, Cfg.TwoD.EXE_Dead_Fill, Cfg.TwoD.EXE_Dead_Out, Cfg.TwoD.EXE_Dead_Limp, "DEAD")
                        ProcessTagLabel(tData.EXE.CharName, Cfg.TwoD.EXE_CharName_Tog, Cfg.TwoD.EXE_CharName_Dir, Cfg.TwoD.EXE_CharName_Order, Cfg.TwoD.EXE_CharName_Fill, Cfg.TwoD.EXE_CharName_Out, Cfg.TwoD.EXE_CharName_Limp, entInfo.CharName)
                        ProcessTagLabel(tData.EXE.UserName, Cfg.TwoD.EXE_UserName_Tog, Cfg.TwoD.EXE_UserName_Dir, Cfg.TwoD.EXE_UserName_Order, Cfg.TwoD.EXE_UserName_Fill, Cfg.TwoD.EXE_UserName_Out, Cfg.TwoD.EXE_UserName_Limp, entInfo.UserName)
                        ProcessTagLabel(tData.EXE.Dist,     Cfg.TwoD.EXE_Dist_Tog,     Cfg.TwoD.EXE_Dist_Dir,     Cfg.TwoD.EXE_Dist_Order,     Cfg.TwoD.EXE_Dist_Fill,     Cfg.TwoD.EXE_Dist_Out,     Cfg.TwoD.EXE_Dist_Limp,     tostring(distMeters) .. "m")
                    else
                        for _, l in pairs(tData.EXE) do l.Visible = false end

                        ProcessTagLabel(tData.SURV.Role,     Cfg.TwoD.Surv_Role_Tog,     Cfg.TwoD.Surv_Role_Dir,     Cfg.TwoD.Surv_Role_Order,     Cfg.TwoD.Surv_Role_Fill,     Cfg.TwoD.Surv_Role_Out,     Cfg.TwoD.Surv_Role_Limp,     "SURV")
                        ProcessTagLabel(tData.SURV.Down,     Cfg.TwoD.Surv_Down_Tog and isDownedState, Cfg.TwoD.Surv_Down_Dir, Cfg.TwoD.Surv_Down_Order, Cfg.TwoD.Surv_Down_Fill, Cfg.TwoD.Surv_Down_Out, Cfg.TwoD.Surv_Down_Limp, "DOWN")
                        ProcessTagLabel(tData.SURV.LastLife, Cfg.TwoD.Surv_LastLife_Tog and isLastLife and not isDownedState and not isDeadState, Cfg.TwoD.Surv_LastLife_Dir, Cfg.TwoD.Surv_LastLife_Order, Cfg.TwoD.Surv_LastLife_Fill, Cfg.TwoD.Surv_LastLife_Out, Cfg.TwoD.Surv_LastLife_Limp, "LAST LIFE")
                        ProcessTagLabel(tData.SURV.Dead,     Cfg.TwoD.Surv_Dead_Tog and isDeadState, Cfg.TwoD.Surv_Dead_Dir, Cfg.TwoD.Surv_Dead_Order, Cfg.TwoD.Surv_Dead_Fill, Cfg.TwoD.Surv_Dead_Out, Cfg.TwoD.Surv_Dead_Limp, "DEAD")
                        ProcessTagLabel(tData.SURV.CharName, Cfg.TwoD.Surv_CharName_Tog, Cfg.TwoD.Surv_CharName_Dir, Cfg.TwoD.Surv_CharName_Order, Cfg.TwoD.Surv_CharName_Fill, Cfg.TwoD.Surv_CharName_Out, Cfg.TwoD.Surv_CharName_Limp, entInfo.CharName)
                        ProcessTagLabel(tData.SURV.UserName, Cfg.TwoD.Surv_UserName_Tog, Cfg.TwoD.Surv_UserName_Dir, Cfg.TwoD.Surv_UserName_Order, Cfg.TwoD.Surv_UserName_Fill, Cfg.TwoD.Surv_UserName_Out, Cfg.TwoD.Surv_UserName_Limp, entInfo.UserName)
                        ProcessTagLabel(tData.SURV.Dist,     Cfg.TwoD.Surv_Dist_Tog,     Cfg.TwoD.Surv_Dist_Dir,     Cfg.TwoD.Surv_Dist_Order,     Cfg.TwoD.Surv_Dist_Fill,     Cfg.TwoD.Surv_Dist_Out,     Cfg.TwoD.Surv_Dist_Limp,     tostring(distMeters) .. "m")
                    end
                else
                    tData.BoxFrame.Visible = false
                end
            end
        end
    end

    if Cfg.Pad and Cfg.Pad.Enabled then
        for obj, hl in pairs(GlobalState.Vis.PadCache) do
            if obj and obj.Parent then
                hl.Enabled          = true
                hl.FillColor        = Cfg.Pad.FillCol
                hl.OutlineColor     = Cfg.Pad.OutCol
                hl.FillTransparency    = GetTrans(Cfg.Pad.Limp_Fill, Cfg.Pad.Style and Cfg.Pad.Style["Fill"])
                hl.OutlineTransparency = GetTrans(Cfg.Pad.Limp_Out, Cfg.Pad.Style and Cfg.Pad.Style["Outline"])
            else
                if hl then hl:Destroy() end
                GlobalState.Vis.PadCache[obj] = nil
            end
        end
    else
        for obj, hl in pairs(GlobalState.Vis.PadCache) do
            if hl then hl.Enabled = false end
        end
    end
end

local function DoTrapRender(dt)
    if not Cfg.Tripwire.Enabled then return end
    
    local now = tick()
    local spd = Cfg.Tripwire.Speed
    
    for obj, data in pairs(GlobalState.Vis.TrapCache) do
        if obj and obj.Parent and data.Proxy and data.Proxy.Parent then
            if Cfg.Tripwire.Direction == "Random" then
                if now >= data.NextSwitch then
                    data.TargetDir = (math.random(1, 2) == 1) and 1 or -1
                    local rMin = math.clamp(Cfg.Tripwire.RandMin, 0.1, 10)
                    local rMax = math.max(rMin, Cfg.Tripwire.RandMax)
                    data.NextSwitch = now + (math.random(rMin * 10, rMax * 10) / 10)
                end
            else
                data.TargetDir = (Cfg.Tripwire.Direction == "Left") and -1 or 1
            end
            
            data.CurrentDir = data.CurrentDir + (data.TargetDir - data.CurrentDir) * (dt * 2)
            data.Angle = data.Angle + (spd * 20 * data.CurrentDir * dt)
            data.Proxy.CFrame = CFrame.new(obj.Position)

            if data.ImgObj and data.BgObj then
                data.ImgObj.Rotation = data.Angle
                data.ImgObj.ImageColor3 = Cfg.Tripwire.FillCol
                data.ImgObj.ImageTransparency = GetTrans(Cfg.Tripwire.LimpFill, true)
                
                local s = Cfg.Tripwire.Size
                if Cfg.Tripwire.ScaleMode == "3D" then
                    data.BgObj.Size = UDim2.new(s, 0, s, 0)
                else
                    local px = s * 20
                    data.BgObj.Size = UDim2.new(0, px, 0, px)
                end
            end
        end
    end
end

local function DoLMSAudio()
    local L = GlobalState.LMS
    local currentState = GetGameState()

    if currentState == "SEC" or currentState == "MS" then
        PreloadAllLMSTracks()
    end

    local shadow = GetShadowSound()

    if currentState == "ING" or currentState == "80s" then
        if not L.RoundActive then
            L.RoundActive     = true
            L.TrackFinished   = false
            L.VisualPlayed    = false
            L.LmsCounter      = 0
            L.StartDelayTimer = nil
            L.Survivor        = nil
            L.Killer          = nil
        end

        if L.StopRoutineRunning then L.StopRoutineRunning = false end

        local activeSurvs, downedSurvs, escapedSurvs, exes = AnalyzeLMSState()
        local original = GetActiveSoloSound()

        local rawLmsCondition = (original ~= nil and (original.IsPlaying or original.Playing or original.TimePosition > 0)) or (
            #escapedSurvs == 0 and 
            #downedSurvs == 0 and 
            #activeSurvs == 1 and 
            #exes >= 1
        )

        if rawLmsCondition then
            L.LmsCounter = (L.LmsCounter or 0) + 1
        else
            L.LmsCounter = 0
        end

        local isTrueLMSVerified = (original ~= nil and (original.IsPlaying or original.Playing or original.TimePosition > 0)) or (L.LmsCounter >= 5)

        if isTrueLMSVerified and GlobalConfig.LMS.Enabled then
            if not L.StartDelayTimer then
                L.StartDelayTimer = tick()
            end

            local delayTime = tonumber(GlobalConfig.LMS.StartDelay) or 0

            if tick() - L.StartDelayTimer >= delayTime then
                L.IsCapturing = true

                if #activeSurvs == 1 then L.Survivor = activeSurvs[1] end
                if #exes >= 1 then L.Killer = exes[1] end

                if not L.VisualPlayed and GlobalConfig.LMS.StartEffect ~= "None" then
                    local fxName = GlobalConfig.LMS.StartEffect
                    local fxFunc = LMS_Visuals[fxName]
                    if typeof(fxFunc) == "function" then
                        L.VisualPlayed = true
                        task.spawn(fxFunc, false)
                        Fluent:Notify({ Title = "Music System", Content = "True LMS Verified - Custom Track Played", Duration = 2 })
                    end
                end

                if original and original.Volume > 0 then 
                    original.Volume = 0 
                end

                local activeTrackName = GetActiveCustomTrack()
                local resolvedAssetID = ResolveAssetPath(activeTrackName)

                if resolvedAssetID and resolvedAssetID ~= "" then
                    if not L.TrackFinished then
                        if shadow.SoundId ~= resolvedAssetID then
                            shadow.SoundId      = resolvedAssetID
                            shadow.TimePosition = original and original.TimePosition or 0
                            shadow:Play()
                        end
                        
                        if not shadow.IsPlaying then shadow:Play() end
                        if original and shadow.PlaybackSpeed ~= original.PlaybackSpeed then 
                            shadow.PlaybackSpeed = original.PlaybackSpeed 
                        end
                        shadow.Volume = GlobalConfig.LMS.Volume
                    else
                        if shadow.IsPlaying then shadow:Stop() end
                        shadow.Volume = 0
                    end
                end
            end
        else
            L.StartDelayTimer = nil
            L.IsCapturing     = false
            L.VisualPlayed    = false
            if shadow.IsPlaying and shadow.Volume > 0 then
                TriggerSteppedStop(shadow)
            end
        end
    else
        L.LmsCounter      = 0
        L.RoundActive     = false
        L.VisualPlayed    = false
        L.TrackFinished   = false
        L.StartDelayTimer = nil
        L.Survivor        = nil
        L.Killer          = nil
        if L.IsCapturing then TriggerSteppedStop(shadow) end
    end
end

local function DoART()
    local A = GlobalState.ART
    local currentState = GetGameState()

    if currentState == "INT" or currentState == "SEC" or currentState == "MS" or currentState == "RE" then
        A.HandledThisRound = false
        A.SavedRingCF = nil
        A.LastTeleportTime = 0
    end

    if not GlobalConfig.AutoRing or A.HandledThisRound then return end

    if currentState == "ING" or currentState == "80s" then
        local timeVal = Workspace:FindFirstChild("GameProperties") and Workspace.GameProperties:FindFirstChild("Time")
        local isTimeCondition = (timeVal and timeVal.Value <= 80 and timeVal.Value > 0)
        local isStateCondition = (currentState == "80s")

        if isStateCondition or isTimeCondition then
            for _, p in pairs(Players:GetPlayers()) do
                if p.Character and IsRageCheck(p.Character) then
                    return
                end
            end

            local char = LocalPlayer.Character
            local root = char and (char:FindFirstChild("HumanoidRootPart") or char.PrimaryPart)
            local hum  = char and char:FindFirstChildOfClass("Humanoid")

            if root and hum and hum.Health > 0 and not IsGameEXE(char) then
                if not A.SavedRingCF then
                    local myPos = root.Position
                    local closestCF = nil
                    local closestDist = 800

                    for _, zonePos in ipairs(CachedEscapeZones) do
                        local d = (zonePos - myPos).Magnitude
                        if d < closestDist and not IsInLobbyArea(zonePos) then
                            closestDist = d
                            closestCF = CFrame.new(zonePos + Vector3.new(0, 3, 0))
                        end
                    end

                    if not closestCF then
                        for _, v in ipairs(Workspace:GetDescendants()) do
                            local isRing = (v:IsA("MeshPart") and v.MeshId == "rbxassetid://106058960373684") 
                                or (v:IsA("BasePart") and (v.Name:find("EscapePart") or v.Name == "Ring"))
                            if isRing then
                                local d = (v.Position - myPos).Magnitude
                                if d < closestDist and not IsInLobbyArea(v.Position) then
                                    closestDist = d
                                    closestCF = v.CFrame + Vector3.new(0, 3, 0)
                                end
                            end
                        end
                    end

                    A.SavedRingCF = closestCF
                end

                if A.SavedRingCF then
                    local now = tick()
                    if not A.HandledThisRound or (now - A.LastTeleportTime >= 1.0) then
                        A.LastTeleportTime = now
                        root.AssemblyLinearVelocity = Vector3.zero
                        root.Velocity = Vector3.zero
                        char:PivotTo(A.SavedRingCF)
                        root.CFrame = A.SavedRingCF

                        if not A.HandledThisRound then
                            A.HandledThisRound = true
                            Fluent:Notify({ Title = "ART Triggered", Content = "Locked to Exit Zone", Duration = 3 })
                        end
                    end
                end
            end
        end
    end
end

local function DoAutoVote()
    local V = GlobalState.Vote
    local gs = GetGameState()

    if gs == "INT" or gs == "RE" then
        V.VotedInRound = false
        V.Timer = 0
        return
    end

    if not GlobalConfig.Vote.Enabled or V.VotedInRound or gs ~= "SEC" then 
        return 
    end

    V.Timer = V.Timer + 0.5
    local targetDelay = tonumber(GlobalConfig.Vote.Delay) or 1
    
    if V.Timer >= targetDelay then
        local remotes = ReplicatedStorage:FindFirstChild("Remotes")
        local voteRemote = remotes and remotes:FindFirstChild("Voted")
        
        if voteRemote then
            local survChar = GlobalConfig.Vote.Randomize and VoteLists.Survivor[math.random(1, #VoteLists.Survivor)] or GlobalConfig.Vote.SurvTarget
            local exeChar = GlobalConfig.Vote.Randomize and VoteLists.EXE[math.random(1, #VoteLists.EXE)] or GlobalConfig.Vote.ExeTarget
            
            voteRemote:FireServer(survChar)
            voteRemote:FireServer(exeChar)
            
            Fluent:Notify({ Title = "Auto Vote", Content = "Voted: " .. survChar .. " & " .. exeChar, Duration = 3 })
        end
        V.VotedInRound = true
    end
end

local TRAP_ASSETS = {
    ["Shockwave"]       = "rbxassetid://12914395250",
    ["Circle Dashed 4"] = "rbxassetid://10382429808",
    ["Shift Lock"]      = "rbxassetid://118624373632520",
}

local function DoTrapScan()
    local Cache = GlobalState.Vis.TrapCache
    if not Cfg.Tripwire.Enabled then return end
    
    local projFolder = Workspace:FindFirstChild("Projectile")
    local trapsFolder = projFolder and projFolder:FindFirstChild("Traps")
    if not trapsFolder then return end

    for _, obj in pairs(trapsFolder:GetChildren()) do
        if obj.Name == "Union" and obj:GetAttribute("Owner") and not Cache[obj] then
            local proxy = Instance.new("Part")
            proxy.Name = "Doom_TrapProxy"
            proxy.Anchored = true
            proxy.CanCollide = false
            proxy.CanQuery = false
            proxy.Transparency = 1
            proxy.Size = Vector3.new(0.1, 0.1, 0.1)
            proxy.CFrame = obj.CFrame
            proxy.Parent = Visuals_Folder
            
            local bg = Instance.new("BillboardGui")
            bg.AlwaysOnTop = true
            bg.Parent = proxy
            
            local img = Instance.new("ImageLabel")
            img.BackgroundTransparency = 1
            img.Size = UDim2.fromScale(1, 1)
            
            local targetID = TRAP_ASSETS[Cfg.Tripwire.Style]
            if Cfg.Tripwire.Style == "Custom" then
                local numID = string.match(Cfg.Tripwire.CustomID, "%d+")
                if numID then targetID = "rbxassetid://" .. numID end
            end
            
            img.Image = targetID or ""
            img.Parent = bg

            Cache[obj] = {
                Proxy = proxy,
                BgObj = bg,
                ImgObj = img,
                Angle = 0,
                CurrentDir = (Cfg.Tripwire.Direction == "Left") and -1 or 1,
                TargetDir = (Cfg.Tripwire.Direction == "Left") and -1 or 1,
                NextSwitch = tick() + math.random(Cfg.Tripwire.RandMin * 10, Cfg.Tripwire.RandMax * 10)/10
            }
        end
    end
    
    for obj, data in pairs(Cache) do
        if not obj.Parent then
            if data.Proxy then data.Proxy:Destroy() end
            Cache[obj] = nil
        end
    end
end

local function DoPadScan()
    local SV = GlobalState.Vis
    local currentState = GetGameState()

    if currentState ~= LastMapScanState then
        LastMapScanState = currentState
        UpdateMapCaches()
    end

    if currentState == "RE" or currentState == "INT" or currentState == "MS" or currentState == "SEC" then
        if SV.HasScannedPads then
            SV.HasScannedPads = false
            for obj, hl in pairs(SV.PadCache) do 
                if hl and hl.Parent then hl:Destroy() end 
            end
            table.clear(SV.PadCache)
        end
    elseif currentState == "ING" or currentState == "80s" then
        if not Cfg.Pad.Enabled then return end
        if not SV.HasScannedPads then
            SV.HasScannedPads = true
            task.spawn(function()
                local maps = Workspace:FindFirstChild("Maps") or Workspace:FindFirstChild("Map")
                local scanFolder = maps or Workspace
                for _, obj in pairs(scanFolder:GetDescendants()) do
                    if obj:IsA("BasePart") and (obj.Name == "Pad" or obj.Name == "PadPart") then
                        if not SV.PadCache[obj] then
                            local hl = Instance.new("Highlight")
                            hl.Name = "Doom_Pad_Highlight"
                            hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
                            hl.Parent    = Visuals_Folder
                            hl.Adornee   = obj
                            hl.FillColor = Cfg.Pad.FillCol
                            hl.OutlineColor = Cfg.Pad.OutCol
                            SV.PadCache[obj] = hl
                        end
                    end
                end
            end)
        end
    end
end

local function DoPingCheck()
    local success, ping = pcall(function()
        return StatsService.Network.ServerStatsItem["Data Ping"]:GetValue()
    end)
    if success then GlobalState.CurrentPing = math.floor(ping) end
end

local function DoAnimDetect()
    if not GlobalConfig.Anim.AutoDetect or not LocalPlayer.Character then return end
    local charName  = LocalPlayer.Character:GetAttribute("Character") or LocalPlayer.Character.Name
    local searchKey = NameToKey[charName] or charName
    local dbKey     = nil
    if AnimDB[searchKey] then dbKey = searchKey end

    if dbKey and dbKey ~= NameToKey[GlobalConfig.Anim.CurrentChar] and dbKey ~= GlobalConfig.Anim.CurrentChar then
        if Options and Options.Anim_Char and typeof(Options.Anim_Char.SetValue) == "function" then
            pcall(function()
                for _, k in pairs(CharList) do
                    if NameToKey[k] == dbKey or k == dbKey then
                        Options.Anim_Char:SetValue(k)
                        GlobalConfig.Anim.CurrentChar = k
                        
                        local list = {}
                        if AnimDB[dbKey] then
                            for _, a in pairs(AnimDB[dbKey]) do table.insert(list, a.Name) end
                        end
                        
                        if AnimNameDropdownControl and typeof(AnimNameDropdownControl.SetValues) == "function" and #list > 0 then
                            AnimNameDropdownControl:SetValues(list)
                            AnimNameDropdownControl:SetValue(list[1])
                            GlobalConfig.Anim.CurrentName = list[1]
                        end
                        break
                    end
                end
            end)
        end
    end
end

local LastViewportCache = Camera.ViewportSize
local function DoViewportCheck()
    local currentVP = Camera.ViewportSize
    if currentVP ~= LastViewportCache and currentVP.X > 0 and currentVP.Y > 0 then
        LastViewportCache = currentVP
        for _, btn in pairs(MobileControl.Buttons) do
            if btn.Canvas and btn.Canvas.Parent then
                local size = btn.Canvas.AbsoluteSize
                if size.X > 0 and size.Y > 0 then
                    btn.Canvas.Position = MobileControl:GetSafePosition(btn.Canvas.Position, size.X, size.Y)
                end
            end
        end
    end
end

-- ═══════════════════════════════════════════════════════════════════════════
-- TIME-SLICED DISPATCHER (25ms Frame Pacing & Command Throttling)
-- ═══════════════════════════════════════════════════════════════════════════
local BudgetPacer = {
    PacingTimer = 0,
    VisualTimer = 0,
    LmsTimer    = 0,
    JumpTimer   = 0,
    SliceStep   = 0
}

RunService.Heartbeat:Connect(function(dt)
    if not GlobalState.ScriptActive then return end

    DoPhysics()
    DoSilverRecord()

    -- AutoHunt - (0.025с)
    BudgetPacer.PacingTimer = BudgetPacer.PacingTimer + dt
    if BudgetPacer.PacingTimer >= 0.025 then
        BudgetPacer.PacingTimer = 0
        DoAutoHunt()
    end

    -- 2D - 30 FPS (0.033с)
    BudgetPacer.VisualTimer = BudgetPacer.VisualTimer + dt
    if BudgetPacer.VisualTimer >= 0.033 then
        BudgetPacer.VisualTimer = 0
        DoTrapRender(0.033)
        DoVisualsRender()
    end

    BudgetPacer.JumpTimer = BudgetPacer.JumpTimer + dt
    if BudgetPacer.JumpTimer >= 0.1 then
        BudgetPacer.JumpTimer = 0
        DoNoCDJump()
    end

    BudgetPacer.LmsTimer = BudgetPacer.LmsTimer + dt
    if BudgetPacer.LmsTimer >= 0.25 then
        BudgetPacer.LmsTimer = 0
        DoLMSAudio()
    end
end)

-- Slow Tick Loop (0.5s)
task.spawn(function()
    local counters = { Ping = 0, AHRefresh = 0, AnimDetect = 0 }

    while GlobalState.ScriptActive do
        task.wait(0.5)
        counters.Ping       = counters.Ping + 1
        counters.AHRefresh  = counters.AHRefresh + 1
        counters.AnimDetect = counters.AnimDetect + 1

        DoART()
        DoAutoVote()
        DoPadScan()
        DoTrapScan()
        DoViewportCheck()

        if counters.Ping >= 2 then
            counters.Ping = 0
            DoPingCheck()
        end

        if counters.AHRefresh >= 4 then
            counters.AHRefresh = 0
            DoAHCharRefresh()
        end

        if counters.AnimDetect >= 2 then
            counters.AnimDetect = 0
            DoAnimDetect()
        end
    end
end)

-- Final Initialization
task.spawn(function()
    task.wait(0.5)
    MobileControl:UpdateAllThemes()
    local vp = Camera.ViewportSize
    if vp.X > 0 and vp.Y > 0 then
        for _, btn in pairs(MobileControl.Buttons) do
            if btn.Canvas then
                local s = btn.Canvas.AbsoluteSize
                btn.Canvas.Position = MobileControl:GetSafePosition(btn.Canvas.Position, s.X, s.Y)
            end
        end
    end
end)

task.delay(1, function()
    if Options and Options.Anim_Char and Options.Anim_Name then
        local list   = {}
        local defKey = "R6"
        if AnimDB[defKey] then
            for _, a in pairs(AnimDB[defKey]) do table.insert(list, a.Name) end
        end
        pcall(function()
            if AnimNameDropdownControl and typeof(AnimNameDropdownControl.SetValues) == "function" then
                AnimNameDropdownControl:SetValues(list)
                if #list > 0 then AnimNameDropdownControl:SetValue(list[1]) end
            end
        end)
    end
end)

Window:SelectTab(1)

-- ═══════════════════════════════════════════════════════════════════════════
-- ANTI-CONSOLE SPAM & ANIMATE FIX
-- ═══════════════════════════════════════════════════════════════════════════
local EmptySignal = { Connect = function() return { Disconnect = function() end } end }
local DummyTrack = setmetatable({
    IsPlaying = false,
    Looped = false,
    Priority = Enum.AnimationPriority.Core,
    Length = 1,
    TimePosition = 0,
    Speed = 1,
    WeightCurrent = 1,
    WeightTarget = 1,
    Stopped = EmptySignal,
    KeyframeReached = EmptySignal,
}, {
    __index = function(self, key)
        if key == "GetMarkerReachedSignal" then
            return function() return EmptySignal end
        end
        return function() end
    end
})

local function PatchCharacterAnimator(char)
    if not char then return end
    local hum = char:WaitForChild("Humanoid", 5)
    if not hum then return end
    local animator = hum:WaitForChild("Animator", 5)
    if not animator then return end

    if not getgenv().AnimatePatched then
        getgenv().AnimatePatched = true
        local oldLoadAnimation
        oldLoadAnimation = hookfunction(animator.LoadAnimation, function(self, anim)
            if not anim then
                return DummyTrack
            end
            local success, track = pcall(oldLoadAnimation, self, anim)
            if success and track then
                return track
            end
            return DummyTrack
        end)
    end
end

if LocalPlayer.Character then
    task.spawn(Pat