Auto puzzles, esps, avoid killer, open source

 Players = :()
 RunService = :()
 UserInputService = :()
 ReplicatedStorage = :()
 Lighting = :()
 VirtualInputManager = :()
 ProximityPromptService = :()
 TeleportService = :()
 CoreGui = :()

 LocalPlayer = Players.LocalPlayer
 Camera = .CurrentCamera

 ().ForsakenCleanup 
    (().ForsakenCleanup)


 Running = 
 Connections = {}
 Highlights = {}
 Billboards = {}
 GeneratorCache = {}
 GearCache = {}
 TrapCache = {}
 ItemCache = {}
 ActivePromptCache = {}

 OriginalLighting = {
    Ambient = Lighting.Ambient,
    OutdoorAmbient = Lighting.OutdoorAmbient,
    Brightness = Lighting.Brightness,
    ClockTime = Lighting.ClockTime,
    FogEnd = Lighting.FogEnd,
    GlobalShadows = Lighting.GlobalShadows,
}

  (conn)
    .(Connections, conn)
     conn


 State = {
    
    AutoSprint = ,
    InfiniteStamina = ,
    ForcedJump = ,
    JumpPower = ,
    InfiniteJump = ,
    AntiSlow = ,

    
    AutoBlock = ,
    AutoBlockRange = ,
    AutoAvoidKiller = ,
    AutoAvoidKillerRange = ,
    AvoidRepelForce = ,
    Triggerbot = ,
    TriggerbotRange = ,
    TriggerbotCooldown = ,

    
    ESPEnabled = ,
    SurvivorsESP = ,
    KillersESP = ,
    GeneratorsESP = ,
    GearsESP = ,
    TrapsESP = ,
    ItemsESP = ,
    ChamsEnabled = ,
    KillerAlert = ,
    KillerAlertDistance = ,
    Fullbright = ,
    CustomFOV = ,
    RemoveVFX = ,

    
    AutoAllPuzzles = ,
    InstantInteract = ,
    AutoProximityInteract = ,
    ProximitySpoofRange = ,
}


 SprintingModule = 
 GeneratorClientBinder = 
 GearClientBinder = 
 LockClientMinigame = 
 FlowClientMinigame = 
 ConnectClientMinigame = 
 GearClientMinigame = 
 MinigameController = 
 FlowBoard = 
 ConnectBoard = 

  ()
    (() SprintingModule = (ReplicatedStorage.Systems.Character.Game.Sprinting) )
    (() GeneratorClientBinder = (ReplicatedStorage.Systems.Player.Game.Generators.GeneratorClientBinder) )
    (() GearClientBinder = (ReplicatedStorage.Systems.Player.Game.Spawners.GearClientBinder) )
    (() LockClientMinigame = (ReplicatedStorage.Systems.Player.Game.Minigames.LockClientMinigame) )
    (() FlowClientMinigame = (ReplicatedStorage.Systems.Player.Game.Minigames.FlowClientMinigame) )
    (() ConnectClientMinigame = (ReplicatedStorage.Systems.Player.Game.Minigames.ConnectClientMinigame) )
    (() GearClientMinigame = (ReplicatedStorage.Systems.Player.Game.Minigames.GearClientMinigame) )
    (() MinigameController = (ReplicatedStorage.Systems.Player.MinigameController) )
    (() FlowBoard = (ReplicatedStorage.Modules.Minigames.FlowBoard) )
    (() ConnectBoard = (ReplicatedStorage.Modules.Minigames.ConnectBoard) )

()

 GeneratorBinderRunning = 
  ()
     GeneratorClientBinder 
         k, v  (GeneratorClientBinder) 
             (k):()  (v) ==  
                GeneratorBinderRunning = v
                
            
        
    

()


 Rayfield = (:())()

  (title, content, duration)
    (()
        Rayfield:({
            Title = title  ,
            Content = content  ,
            Duration = duration  ,
            Image = ,
        })
    )





 GenBarCache = {}
 GenValCache = {}

  (gen)
      gen    

     GeneratorBinderRunning 
         obj = GeneratorBinderRunning[gen]
         obj 
             obj.__getFraction 
                 s, frac = (()  obj:() )
                 s  (frac) ==  
                     .(.(frac * ), , )
                
            
             obj.Network  obj.Network.Properties 
                 props = obj.Network.Properties
                 s1, c = (()  props:() )
                 s2, m = (()  props:() )
                 s1  s2  (c) ==   (m) ==   m >  
                     .(.((c / m) * ), , )
                
            
        
    
        ()
    

     bar = GenBarCache[gen]
     bar ==  
        bar = gen:(, )  
        GenBarCache[gen] = bar
    
     bar  bar:() 
         scale = bar.Size.X.Scale
         scale >   scale <=  
             .(.(scale * ), , )
        
    

     attrVal = gen:()  gen:()  gen:()
     (attrVal) ==  
         attrVal <=    .(.(attrVal * ), , ) 
         .(.(attrVal), , )
    

     pv = GenValCache[gen]
     pv ==  
        pv = gen:()  
        GenValCache[gen] = pv
    
     pv  pv:() 
         v = pv.Value
         v <=   v >    .(.(v * ), , ) 
         .(.(v), , )
    

     


  (inst, part)
      inst   inst.Parent   part   part.Parent 
         
    
      inst:()   part:() 
         
    

     playersFolder = :()
     playersFolder  (inst:(playersFolder)  inst:()) 
         
    

     lobby = :()
     lobby  (inst:(lobby)  part:(lobby)) 
         
    
     waitingRoom = :()
     waitingRoom  (inst:(waitingRoom)  part:(waitingRoom)) 
         
    

     prompt = inst:()  inst:(, )  part:()
     prompt   prompt.Enabled 
         
    

     part:()  part.Transparency <  
         
    
     inst:() 
         _, child  (inst:()) 
             child:()  child.Transparency <  
                 
            
        
    

     


  (inst)
      inst   inst:()   
     n = inst.Name:()
      (n:()  inst:())   

     parent = inst.Parent
     parent  parent:()  (parent.Name:():()  parent:()) 
        
    

     lobby = :()
     lobby  inst:(lobby)   

     main = inst:()  inst.PrimaryPart  inst:()
     main 
         existingGen, existingPart  (GeneratorCache) 
             existingGen == inst  existingPart == main  (existingPart.Position - main.Position).Magnitude <  
                
            
        
        GeneratorCache[inst] = main
    


  (inst)
      inst  ( inst:()   inst:())   
     n = inst.Name:()
     n:()  n:()  n:()  n:()  n:()  n:()  n:() 
        
    

     lobby = :()
     lobby  inst:(lobby)   

     n:()  n:() 
         part = inst:()  inst  (inst.PrimaryPart  inst:())
         part 
            GearCache[inst] = part
        
    


  (inst)
      inst  ( inst:()   inst:())   

     lobby = :()
     lobby  (inst:(lobby)  inst:())   
     waitingRoom = :()
     waitingRoom  (inst:(waitingRoom)  inst:())   

     n = inst.Name:()
     n:()  n:()  n:()  n:()  n:()
        n:()  n:()  n:()  n:()  n:()
        n:()  n:()  n:()  n:()  n:()
        n:()  n:()  n:()  n:()  n:() 
        
    

     isTrap = 
     n:()  n:()  n:()  n:() 
        isTrap = 
     n ==   n:()  n:()  n:()  n:()  n:() 
        isTrap = 
     n:()   n:()   n:()   n:()   n:() 
        isTrap = 
    

     isTrap 
         part = inst:()  inst  (inst:()  inst.PrimaryPart)
         part 
            TrapCache[inst] = part
        
    


  (inst)
      inst  ( inst:()   inst:())   

     playersFolder = :()
     playersFolder  (inst:(playersFolder)  inst:()) 
        
    

     lobby = :()
     lobby  inst:(lobby)   
     waitingRoom = :()
     waitingRoom  inst:(waitingRoom)   

     n = inst.Name:()
     n:()  n:()  n:()  n:()
        n:()  n:()  n:()  n:()  n:()
        n:()  n:()  n:()  n:()  n:()
        n:()  n:()  n:()  n:()  n:()  n:() 
        
    

     n:()  n:()  n:()  n:() 
        
    

     prompt = inst:()  inst:(, )  (inst.Parent  inst.Parent:())
     isRealItem = 
     itemName = inst.Name

     prompt  prompt:() 
         at = (prompt.ActionText  ):()
         ot = (prompt.ObjectText  ):()

         at:()  at:()  at:()  at:()  at:()  at:()  at:() 
              ot:()   ot:()   ot:()   ot:()   ot:() 
                isRealItem = 
                 prompt.ObjectText  prompt.ObjectText ~=  
                    itemName = prompt.ObjectText
                
            
         ot:()  ot:()  ot:()  ot:()  ot:()  ot:() 
            isRealItem = 
            itemName = prompt.ObjectText
        
    

      isRealItem  (inst:()  (inst.Parent  inst.Parent:())) 
        isRealItem = 
        itemName = inst:()  inst.Name  inst.Parent.Name
    

     isRealItem 
         lowerName = itemName:()
         lowerName:()  lowerName:()  lowerName:()  lowerName:() 
            
        

         part = inst:()  inst  (inst.PrimaryPart  inst:())
         part 
            ItemCache[inst] = { Part = part, Name = itemName }
        
    


  (inst)
    GeneratorCache[inst] = 
    GearCache[inst] = 
    TrapCache[inst] = 
    ItemCache[inst] = 
     Billboards[inst] 
         Billboards[inst].Gui  Billboards[inst].Gui.Parent 
            Billboards[inst].Gui:()
        
        Billboards[inst] = 
    
     Highlights[inst] 
         Highlights[inst].Parent 
            Highlights[inst]:()
        
        Highlights[inst] = 
    


(()
     _, child  (:()) 
        (child)
        (child)
        (child)
        (child)
    
)

 MapFolder = :()
 MapFolder 
    (MapFolder.DescendantAdded:((child)
        (child)
        (child)
        (child)
        (child)
    ))
    (MapFolder.DescendantRemoving:((child)
        (child)
    ))


(.DescendantAdded:((child)
    (child)
    (child)
))
(.DescendantRemoving:((child)
     TrapCache[child] 
        (child)
    
))




 AvoidRayParams = RaycastParams.()
AvoidRayParams.FilterType = .RaycastFilterType.Exclude
AvoidRayParams.IgnoreWater = 

  (myHRP, kHRP)
     myPos = myHRP.Position
     kPos = kHRP.Position
     diff = myPos - kPos
     awayFlat = .(diff.X, , diff.Z)
     awayFlat.Magnitude >  
        awayFlat = awayFlat.Unit
    
         look = myHRP.CFrame.LookVector
        awayFlat = .(-look.X, , -look.Z)
        awayFlat = (awayFlat.Magnitude > )  awayFlat.Unit  .(, , )
    

     myChar = LocalPlayer.Character
     filterList = { myChar }
     playersRoot = :()
     playersRoot 
        .(filterList, playersRoot)
    
    AvoidRayParams.FilterDescendantsInstances = filterList

     rayOrigin = myPos + .(, -, )
     maxCheckDist = 

     directRay = :(rayOrigin, awayFlat * maxCheckDist, AvoidRayParams)
      directRay  directRay.Distance >=  
         awayFlat, 
    

     escapeAngles = { , -, , -, , -, , - }
     bestDir = awayFlat
     directDist = directRay  directRay.Distance  maxCheckDist
     bestScore = (directDist * ) + 
     bestDist = directDist

     ax, az = awayFlat.X, awayFlat.Z

     _, deg  (escapeAngles) 
         rad = .(deg)
         cosA, sinA = .(rad), .(rad)
         candDir = .(ax * cosA - az * sinA, , ax * sinA + az * cosA).Unit
         ray = :(rayOrigin, candDir * maxCheckDist, AvoidRayParams)
         dist = ray  ray.Distance  maxCheckDist
         dot = candDir.X * ax + candDir.Z * az

         score = (dist * ) + (dot * )
         dist <  
            score = score - 
        

         score > bestScore 
            bestScore = score
            bestDir = candDir
            bestDist = dist
        
    

     upBoost = (bestDist < )    
     bestDir, upBoost


  ()
     myChar = LocalPlayer.Character
     myHRP = myChar  myChar:()
      myHRP   

     killersFolder = :()  .Players:()
     closestDist, closestKiller = , 
     killersFolder 
         _, k  (killersFolder:()) 
             kHRP = k:()
             kHRP 
                 d = (kHRP.Position - myHRP.Position).Magnitude
                 d < closestDist 
                    closestDist = d
                    closestKiller = kHRP
                
            
        
    

     avoidDir, upBoost
     closestKiller 
        avoidDir, upBoost = (myHRP, closestKiller)
    
         look = myHRP.CFrame.LookVector
         awayFlat = .(-look.X, , -look.Z)
        awayFlat = (awayFlat.Magnitude > )  awayFlat.Unit  .(, , )
         fakeKiller = { Position = myHRP.Position - awayFlat *  }
        avoidDir, upBoost = (myHRP, fakeKiller)
    

    myHRP.AssemblyLinearVelocity = avoidDir * (State.AvoidRepelForce * ) + .(, .(upBoost, ), )
    (, , )





  (prompt)
      prompt   prompt:()   
      prompt:() 
        prompt:(, prompt.HoldDuration)
        prompt:(, prompt.MaxActivationDistance)
        prompt:(, prompt.RequiresLineOfSight)
    

     State.InstantInteract 
        prompt.HoldDuration = 
    
         orig = prompt:()
         orig ~=   prompt.HoldDuration = orig 
    

     State.ProximitySpoofRange 
        prompt.MaxActivationDistance = 
        prompt.RequiresLineOfSight = 
    
         origDist = prompt:()
         origDist ~=   prompt.MaxActivationDistance = origDist 
         origLOS = prompt:()
         origLOS ~=   prompt.RequiresLineOfSight = origLOS 
    


  (prompt)
     prompt:() 
        ActivePromptCache[prompt] = 
        (prompt)
    


  (prompt)
    ActivePromptCache[prompt] = 


  ()
     prompt  (ActivePromptCache) 
         prompt  prompt.Parent 
            (prompt)
        
            ActivePromptCache[prompt] = 
        
    


(.DescendantAdded:((desc)
     desc:() 
        (desc)
    
))

(.DescendantRemoving:((desc)
     desc:() 
        (desc)
    
))

.(()
     _, desc  (:()) 
         desc:() 
            (desc)
        
    
)

(ProximityPromptService.PromptButtonHoldBegan:((prompt)
     State.InstantInteract 
        prompt.HoldDuration = 
          
            (prompt)
        
    
))

  (prompt)
      prompt   prompt:()    
     parent = prompt.Parent
      parent    

     playersFolder = :()
     playersFolder  (parent:(playersFolder)  parent:()) 
         
    

     pn = parent.Name:()
     pn:()  pn:()  pn:()  pn:()  pn:()  pn:()  pn:() 
         
    

     at = (prompt.ActionText  ):()
     ot = (prompt.ObjectText  ):()

     at:()  at:()  at:()  at:()  at:()  at:()  at:()  at:() 
         
    
     ot:()  ot:()  ot:()  ot:()  ot:()  ot:()  ot:()  ot:()  ot:()  ot:()  ot:()  ot:()  ot:() 
         
    
     pn:()  pn:()  pn:()  pn:()  pn:()  pn:()  pn:()  pn:()  pn:()  pn:()  pn:()  pn:() 
         
    

     pParentName = parent.Parent  parent.Parent.Name:()  
     pParentName:()  pParentName:()  pParentName:()  pParentName:()  pParentName:() 
         
    

     GearCache[parent]  ItemCache[parent]  (parent.Parent  (GearCache[parent.Parent]  ItemCache[parent.Parent])) 
         
    

     


.(()
     Running 
        .()
         State.AutoProximityInteract   
             myChar = LocalPlayer.Character
             myHRP = myChar  myChar:()
             myHRP 
                 myPos = myHRP.Position
                 prompt  (ActivePromptCache) 
                     prompt  prompt.Parent  prompt.Enabled 
                         (prompt) 
                             parentPart = prompt.Parent:()  prompt.Parent  prompt.Parent:()
                             parentPart 
                                 dist = (parentPart.Position - myPos).Magnitude
                                 dist <= (prompt.MaxActivationDistance + ) 
                                    (prompt)
                                    .()
                                
                            
                        
                    
                        ActivePromptCache[prompt] = 
                    
                
            
        
    
)




 AlertGui = .()
AlertGui.Name = 
AlertGui.ResetOnSpawn = 
(() AlertGui.Parent = CoreGui )
  AlertGui.Parent  AlertGui.Parent = LocalPlayer:() 

 AlertLabel = .()
AlertLabel.Name = 
AlertLabel.Size = .(, , , )
AlertLabel.Position = .(, -, , )
AlertLabel.BackgroundColor3 = .(, , )
AlertLabel.BackgroundTransparency = 
AlertLabel.TextColor3 = .(, , )
AlertLabel.Font = .Font.GothamBold
AlertLabel.TextSize = 
AlertLabel.Text = 
AlertLabel.Visible = 
AlertLabel.BorderSizePixel = 
AlertLabel.Parent = AlertGui

 AlertCorner = .()
AlertCorner.CornerRadius = .(, )
AlertCorner.Parent = AlertLabel

 AlertStroke = .()
AlertStroke.Color = .(, , )
AlertStroke.Thickness = 
AlertStroke.Transparency = 
AlertStroke.Parent = AlertLabel

 ESPFolder = .()
ESPFolder.Name = 
(() ESPFolder.Parent = CoreGui )
  ESPFolder.Parent  ESPFolder.Parent =  

  (adornee, color)
     hl = .()
    hl.Name =  .. adornee.Name
    hl.Adornee = adornee
    hl.FillColor = color
    hl.FillTransparency = 
    hl.OutlineColor = .(, , )
    hl.OutlineTransparency = 
    hl.DepthMode = .HighlightDepthMode.AlwaysOnTop
    hl.Parent = ESPFolder
     hl


  (adornee, text, color)
     bb = .()
    bb.Name =  .. adornee.Name
    bb.Adornee = adornee
    bb.Size = .(, , , )
    bb.StudsOffset = .(, , )
    bb.AlwaysOnTop = 
    bb.ResetOnSpawn = 
    bb.MaxDistance = 

     label = .()
    label.Name = 
    label.Size = .(, , , )
    label.BackgroundTransparency = 
    label.Font = .Font.GothamBold
    label.TextSize = 
    label.TextColor3 = color
    label.TextStrokeColor3 = .(, , )
    label.TextStrokeTransparency = 
    label.Text = text
    label.Parent = bb

    bb.Parent = ESPFolder
     bb, label


  ()
     _, item  (Highlights) 
         item  item.Parent  item:() 
    
    .(Highlights)

     _, item  (Billboards) 
         item  item.Gui  item.Gui.Parent  item.Gui:() 
    
    .(Billboards)





()._ForsakenCleanOriginals = ()._ForsakenCleanOriginals  {}

  (mod)
      mod    
     k, v  (mod) 
         (k):() 
             v
        
    
     


  (size, pairsList)
     numPairs = #pairsList
     totalCells = size * size

      (cell)
         r = .((cell - ) / size) + 
         c = ((cell - ) % size) + 
         n = {}
         r >   .(n, cell - size) 
         r < size  .(n, cell + size) 
         c >   .(n, cell - ) 
         c < size  .(n, cell + ) 
         n
    

     endpoints = {}
     pIdx, p  (pairsList) 
        endpoints[p[]] = pIdx
        endpoints[p[]] = pIdx
    

     FlowBoardMod = FlowBoard  (ReplicatedStorage.Modules.Minigames.FlowBoard)

     adj = {}
     i = , totalCells  adj[i] = (i) 

     pairOrder = {}
     i = , numPairs  .(pairOrder, i) 
    .(pairOrder, (a, b)
         pa, pb = pairsList[a], pairsList[b]
         ra1, ca1 = .((pa[] - ) / size) + , ((pa[] - ) % size) + 
         ra2, ca2 = .((pa[] - ) / size) + , ((pa[] - ) % size) + 
         rb1, cb1 = .((pb[] - ) / size) + , ((pb[] - ) % size) + 
         rb2, cb2 = .((pb[] - ) / size) + , ((pb[] - ) % size) + 
         da = .(ra1 - ra2) + .(ca1 - ca2)
         db = .(rb1 - rb2) + .(cb1 - cb2)
         da < db
    )

     visited = {}
     dfsPaths = {}

      (startOrderIdx)
         k = startOrderIdx, numPairs 
             pidx = pairOrder[k]
             s, t = pairsList[pidx][], pairsList[pidx][]
             q = { s }
             seen = { [s] =  }
             found = 
             qHead = 
             qHead <= #q 
                 curr = q[qHead]
                qHead = qHead + 
                 curr == t  found =   
                 _, nxt  (adj[curr]) 
                      seen[nxt]  ( visited[nxt]  nxt == t) 
                        seen[nxt] = 
                        .(q, nxt)
                    
                
            
              found    
        
         
    

     maxDfsSteps = 
     dfsStepCount = 

      (orderIdx, curr, target, currentPath)
        dfsStepCount = dfsStepCount + 
         dfsStepCount > maxDfsSteps    

         curr == target 
             copied = {}
             i, v  (currentPath)  copied[i] = v 
            dfsPaths[pairOrder[orderIdx]] = copied
             orderIdx == numPairs    
              (orderIdx + )    
             nextP = pairOrder[orderIdx + ]
             ns, nt = pairsList[nextP][], pairsList[nextP][]
            visited[ns] = 
             ok = (orderIdx + , ns, nt, { ns })
            visited[ns] = 
             ok
        

         tr = .((target - ) / size) + 
         tc = ((target - ) % size) + 

         nbrs = {}
         _, nxt  (adj[curr]) 
             nxt == target 
                .(nbrs, { dist = , cell = nxt })
              visited[nxt]   endpoints[nxt] 
                 nr = .((nxt - ) / size) + 
                 nc = ((nxt - ) % size) + 
                 d = .(nr - tr) + .(nc - tc)
                .(nbrs, { dist = d, cell = nxt })
            
        
        .(nbrs, (a, b)  a.dist < b.dist )

         _, nInfo  (nbrs) 
             nxt = nInfo.cell
            visited[nxt] = 
            .(currentPath, nxt)
             (orderIdx, nxt, target, currentPath)    
            .(currentPath)
            visited[nxt] = 
        
         
    

     firstP = pairOrder[]
     s1, t1 = pairsList[firstP][], pairsList[firstP][]
    visited[s1] = 
     dfsSuccess = (, s1, t1, { s1 })
    visited[s1] = 

     dfsSuccess  FlowBoardMod  FlowBoardMod.Validate 
         valid = FlowBoardMod.(size, pairsList, dfsPaths)
         valid   dfsPaths 
     dfsSuccess 
         dfsPaths
    

     cellOcc = {}
     cellCost = {}
     i = , totalCells 
        cellOcc[i] = 
        cellCost[i] = 
    
     paths = {}

      (pIdx, presMult)
         start = pairsList[pIdx][]
         target = pairsList[pIdx][]
         tr = .((target - ) / size) + 
         tc = ((target - ) % size) + 

         openSet = { start }
         cameFrom = {}
         gScore = { [start] =  }
         fScore = { [start] = .(.((start-)/size)+ - tr) + .(((start-)%size)+ - tc) }
         inOpen = { [start] =  }

         #openSet >  
             bestIdx = 
             i = , #openSet 
                 fScore[openSet[i]] < fScore[openSet[bestIdx]]  bestIdx = i 
            
             current = .(openSet, bestIdx)
            inOpen[current] = 

             current == target 
                 path = {}
                 curr = target
                 curr 
                    .(path, , curr)
                    curr = cameFrom[curr]
                
                 path
            

             _, nxt  ((current)) 
                 ep = endpoints[nxt]
                 ep ==   nxt == target 
                     cong = cellOcc[nxt]
                     stepCost = cellCost[nxt] + (cong * presMult)
                     tentG = gScore[current] + stepCost

                      gScore[nxt]  tentG < gScore[nxt] 
                        cameFrom[nxt] = current
                        gScore[nxt] = tentG
                         nr = .((nxt - ) / size) + 
                         nc = ((nxt - ) % size) + 
                         h = .(nr - tr) + .(nc - tc)
                        fScore[nxt] = tentG + h
                          inOpen[nxt] 
                            .(openSet, nxt)
                            inOpen[nxt] = 
                        
                    
                
            
        
         
    

     pIdx = , numPairs 
         p = (pIdx, )
        paths[pIdx] = p
         p 
             i = , #p -   cellOcc[p[i]] = cellOcc[p[i]] +  
        
    

     presMult = 
     _ = ,  
         conflicts = 
         i = , totalCells 
             cellOcc[i] >  
                conflicts = conflicts + (cellOcc[i] - )
                cellCost[i] = cellCost[i] + (cellOcc[i] * )
            
        
         conflicts ==  
             FlowBoardMod  FlowBoardMod.Validate 
                 valid = FlowBoardMod.(size, pairsList, paths)
                 valid   paths 
            
                 paths
            
        
        presMult = presMult + 
         pIdx = , numPairs 
             p = paths[pIdx]
             hasConflict = 
             p 
                 i = , #p -  
                     cellOcc[p[i]] >   hasConflict =   
                
            
                hasConflict = 
            
             hasConflict 
                 p 
                     i = , #p -   cellOcc[p[i]] = .(, cellOcc[p[i]] - ) 
                
                 np = (pIdx, presMult)
                paths[pIdx] = np
                 np 
                     i = , #np -   cellOcc[np[i]] = cellOcc[np[i]] +  
                
            
        
    

     


 flowCV = (FlowClientMinigame)
 flowCV  flowCV.Start 
      ()._ForsakenCleanOriginals.FlowStart 
        ()._ForsakenCleanOriginals.FlowStart = flowCV.Start
    
     cleanFlowStart = ()._ForsakenCleanOriginals.FlowStart

    flowCV.Start = (self, ...)
        (self, ...)
         State.AutoAllPuzzles  self.Network 
            .(()
                 tStart = .()
                .()

                (()
                     props = self.Network.Properties
                     size = props:()
                     pairsList = props:()
                     size  pairsList 
                         sol = (size, pairsList)
                         sol  #sol == #pairsList 
                             renderer = self.__renderer
                             board = renderer  renderer.Board

                             totalSteps = 
                             _, path  (sol) 
                                totalSteps = totalSteps + .(, #path - )
                            
                             stepDelay = .( / .(, totalSteps), , )

                             pIdx, path  (sol) 
                                  self   self.Network   
                                 board 
                                    board.Paths[pIdx] = { path[] }
                                

                                 step = , #path 
                                      self   self.Network   
                                     board 
                                        .(board.Paths[pIdx], path[step])
                                        (() renderer:() )
                                    
                                    .(stepDelay)
                                

                                 board  renderer 
                                    (() renderer:() )
                                
                            

                             board 
                                (()
                                    board:()
                                     renderer  renderer:() 
                                )
                            

                             elapsed = .() - tStart
                             elapsed <  
                                .( - elapsed)
                            

                             self  self.Network 
                                 self.__input 
                                    (() self.__input:() )
                                
                                self.Network:(, sol)
                                (()
                                     Sounds = (ReplicatedStorage.Modules.Rendering.Sounds)
                                    Sounds:()
                                )
                                (, .(, size, size, #pairsList), )
                            
                        
                    
                )
            )
        
    


 connectCV = (ConnectClientMinigame)
 connectCV  connectCV.Start 
      ()._ForsakenCleanOriginals.ConnectStart 
        ()._ForsakenCleanOriginals.ConnectStart = connectCV.Start
    
     cleanConnectStart = ()._ForsakenCleanOriginals.ConnectStart

    connectCV.Start = (self, ...)
        (self, ...)
         State.AutoAllPuzzles  self.Network 
            .(()
                .(.(, ) / )
                (()
                     props = self.Network.Properties
                     blobs = props:()
                     blobs  ConnectBoard 
                         b = ConnectBoard.(blobs)
                         renderer = self.__renderer

                         i = , #b.Blobs 
                              self   self.Network   
                             mate = b.Mates[i]
                             mate   b.Links[i] 
                                b:(i, mate)
                                 renderer 
                                    (() renderer:() )
                                
                                .(.(, ) / )
                            
                        

                        .(.(, ) / )
                         self  self.Network 
                            self.Network:(, b:())
                            (() self:() )
                            (, , )
                        
                    
                )
            )
        
    


 lockCV = (LockClientMinigame)
 lockCV  lockCV.Start 
      ()._ForsakenCleanOriginals.LockStart 
        ()._ForsakenCleanOriginals.LockStart = lockCV.Start
    
     cleanLockStart = ()._ForsakenCleanOriginals.LockStart

    lockCV.Start = (self, ...)
        (self, ...)
         State.AutoAllPuzzles  self.Network 
            .(()
                .()

                 board = 
                 onPress = 

                 _ = ,  
                     self.__renderer  self.__renderer.Board 
                        board = self.__renderer.Board
                    
                     self.__input  self.__input.Callbacks  self.__input.Callbacks.OnPress 
                        onPress = self.__input.Callbacks.OnPress
                    
                     board   
                    .()
                

                  board  self.__input  self.__input.Board 
                    board = self.__input.Board
                

                 startTime = .()
                 lastPressTime = 

                 self  self.Network  (.() - startTime < ) 
                    RunService.Heartbeat:()
                      self   self.Network   

                     board  board.State  board.State.Remaining  board.State.Remaining <=  
                        
                    
                     board  board.IsBroken  board:() 
                        
                    

                     stNow = :()
                     shouldPress = 

                     board  board.AngleAt  board.State  board.State.Target 
                         currentAngle = board:(stNow)
                         targetAngle = board.State.Target
                         targetSize = (board.Config  board.Config.TargetSize)  
                         diff = .((currentAngle - targetAngle + ) %  - )
                         diff <= (targetSize * ) 
                            shouldPress = 
                        
                     board  board.AngleAt  board.IsOnTarget 
                         currentAngle = board:(stNow)
                         board:(currentAngle) 
                            shouldPress = 
                        
                     self.__renderer  self.__renderer.Line  self.__renderer.__target 
                         lineRot = self.__renderer.Line.Rotation % 
                         targetRot = self.__renderer.__target.Rotation % 
                         diff = .((lineRot - targetRot + ) %  - )
                         diff <=  
                            shouldPress = 
                        
                    

                     shouldPress  (.() - lastPressTime > ) 
                        lastPressTime = .()
                         pressTime = :()
                         onPress 
                            (onPress)
                         self.Network 
                            self.Network:(, pressTime)
                        
                        .()
                    
                

                (, , )
            )
        
    


 gearCV = (GearClientMinigame)
 gearCV  gearCV.Start 
      ()._ForsakenCleanOriginals.GearStart 
        ()._ForsakenCleanOriginals.GearStart = gearCV.Start
    
     cleanGearStart = ()._ForsakenCleanOriginals.GearStart

    gearCV.Start = (self, ...)
        (self, ...)
         State.AutoAllPuzzles  self.Network 
            .(()
                .(.(, ) / )
                (()
                     turns = self.Network.Properties:()  
                     _ = , turns 
                          self   self.Network   
                        .(.(, ) / )
                        self.Network:()
                    
                    .()
                    (, , )
                )
            )
        
    





 CachedIsKiller = 
 LastRoleCheckTime = 

  ()
     now = .()
     CachedIsKiller ~=   (now - LastRoleCheckTime) <  
         CachedIsKiller
    
    LastRoleCheckTime = now

     myChar = LocalPlayer.Character
      myChar 
        CachedIsKiller = 
         
    
     playersRoot = :()
     playersRoot 
         killersFolder = playersRoot:()
         killersFolder  killersFolder:(myChar.Name) 
            CachedIsKiller = 
             
        
    
     role = myChar:()  (LocalPlayer.Team  LocalPlayer.Team.Name)  
     (role):():() 
        CachedIsKiller = 
         
    
    CachedIsKiller = 
     


 LastTriggerbotTime = 
  ()
      State.Triggerbot   ()   

     myChar = LocalPlayer.Character
     myHRP = myChar  myChar:()
      myHRP   

     playersRoot = :()
     survivorsFolder = playersRoot  playersRoot:()
      survivorsFolder   

     myPos = myHRP.Position
     closestDist = 
     closestHRP = 

     _, surv  (survivorsFolder:()) 
         surv:()  surv ~= myChar 
             sHRP = surv:()
             hum = surv:()
             sHRP  ( hum  hum.Health > ) 
                 dist = (sHRP.Position - myPos).Magnitude
                 dist < closestDist 
                    closestDist = dist
                    closestHRP = sHRP
                
            
        
    

     closestHRP 
         flatTarget = .(closestHRP.Position.X, myHRP.Position.Y, closestHRP.Position.Z)
        myHRP.CFrame = .(myHRP.Position, flatTarget)

         now = .()
         closestDist <= State.TriggerbotRange  (now - LastTriggerbotTime) >= State.TriggerbotCooldown 
            LastTriggerbotTime = now
             mouse1click 
                ()
            
                VirtualInputManager:(, , , , , )
                .(, ()
                    VirtualInputManager:(, , , , , )
                )
            
             tool = myChar:()
             tool 
                (() tool:() )
            
        
    





 IsShiftEmulated = 
 LastMoveTime = 
 LastBlockTime = 
 LastAntiSlowCheck = 
 LastVFXCheck = 

(RunService.Stepped:(()
      Running   
     myChar = LocalPlayer.Character
      myChar   

     hum = myChar:()
     hum  State.ForcedJump 
        hum.UseJumpPower = 
        hum.JumpPower = State.JumpPower
        hum.JumpHeight = State.JumpPower / 
        hum:(.HumanoidStateType.Jumping, )
    

     now = .()
     State.AntiSlow  (now - LastAntiSlowCheck) >  
        LastAntiSlowCheck = now
         sm = myChar:()
         sm 
             _, val  (sm:()) 
                 val:()  val.Value <   val.Name ~=  
                    val.Value = 
                
            
        
         scm = myChar:()
         scm 
             _, val  (scm:()) 
                 val:()  val.Value <  
                    val.Value = 
                
            
        
    
))

(RunService.Heartbeat:(()
      Running   
     now = .()
     myChar = LocalPlayer.Character
     hum = myChar  myChar:()
     myHRP = myChar  myChar:()

     State.InfiniteStamina  SprintingModule 
        SprintingModule.StaminaLossDisabled = 
        SprintingModule.Stamina = SprintingModule.MaxStamina  
    

     State.AutoSprint  hum 
         isMoving = hum.MoveDirection.Magnitude > 
         isMoving 
            LastMoveTime = now
        

         (now - LastMoveTime) <  
             SprintingModule 
                SprintingModule.IsSprinting = 
                 SprintingModule.StartSprinting   SprintingModule.IsSprinting 
                    (() SprintingModule:() )
                
            

             targetSpeed = (SprintingModule  SprintingModule.SprintSpeed)  
             hum.WalkSpeed < targetSpeed 
                hum.WalkSpeed = targetSpeed
            

             sm = myChar:()
             sm 
                 spVal = sm:()
                 spVal  spVal:()  spVal.Value <  
                    spVal.Value = 
                
            

              IsShiftEmulated 
                IsShiftEmulated = 
                VirtualInputManager:(, .KeyCode.LeftShift, , )
            
         IsShiftEmulated 
            IsShiftEmulated = 
            VirtualInputManager:(, .KeyCode.LeftShift, , )
             SprintingModule  SprintingModule.StopSprinting 
                (() SprintingModule:() )
            
        
     IsShiftEmulated 
        IsShiftEmulated = 
        VirtualInputManager:(, .KeyCode.LeftShift, , )
    

     State.Fullbright 
        Lighting.Ambient = .(, , )
        Lighting.OutdoorAmbient = .(, , )
        Lighting.Brightness = 
        Lighting.ClockTime = 
        Lighting.FogEnd = 
        Lighting.GlobalShadows = 
    

     Camera  State.CustomFOV ~=   .(Camera.FieldOfView - State.CustomFOV) >  
        Camera.FieldOfView = State.CustomFOV
    

     State.RemoveVFX  (now - LastVFXCheck) >  
        LastVFXCheck = now
         pg = LocalPlayer:()
         mainUI = pg  pg:()
         vig = mainUI  mainUI:()
         vig  vig.Visible  vig.Visible =  
    

     myHRP  (State.AutoBlock  State.AutoAvoidKiller) 
         killersFolder = :()  .Players:()
         killersFolder 
             _, killer  (killersFolder:()) 
                 kHRP = killer:()
                 kHRP 
                     dist = (kHRP.Position - myHRP.Position).Magnitude

                     State.AutoBlock  dist <= State.AutoBlockRange  (now - LastBlockTime) >  
                        LastBlockTime = now
                         flatTarget = .(kHRP.Position.X, myHRP.Position.Y, kHRP.Position.Z)
                        myHRP.CFrame = .(myHRP.Position, flatTarget)
                        VirtualInputManager:(, .KeyCode.Q, , )
                        .(, ()
                            VirtualInputManager:(, .KeyCode.Q, , )
                        )
                    

                     State.AutoAvoidKiller  dist <= State.AutoAvoidKillerRange 
                         avoidDir, upBoost = (myHRP, kHRP)
                         curY = myHRP.AssemblyLinearVelocity.Y
                        myHRP.AssemblyLinearVelocity = .(
                            avoidDir.X * State.AvoidRepelForce,
                            .(curY, upBoost),
                            avoidDir.Z * State.AvoidRepelForce
                        )
                    
                
            
        
    

     State.Triggerbot 
        ()
    
))

(UserInputService.JumpRequest:(()
      Running   
     myChar = LocalPlayer.Character
     hum = myChar  myChar:()
     hrp = myChar  myChar:()

     State.ForcedJump  State.InfiniteJump 
         hum 
            hum:(.HumanoidStateType.Jumping)
        
         hrp  State.InfiniteJump 
            hrp.AssemblyLinearVelocity = .(hrp.AssemblyLinearVelocity.X, State.JumpPower, hrp.AssemblyLinearVelocity.Z)
        
    
))




 MAX_ACTIVE_HIGHLIGHTS = 
 MAX_ESP_DISTANCE = 

  (candidates)
      State.ChamsEnabled 
         _, hl  (Highlights) 
             hl  hl.Parent  hl:() 
        
        .(Highlights)
        
    

    .(candidates, (a, b)  a.Score < b.Score )

     activeSet = {}
     count = 

     _, c  (candidates) 
         c.Dist  c.Dist > MAX_ESP_DISTANCE 
            
        
        count = count + 
         count <= MAX_ACTIVE_HIGHLIGHTS 
            activeSet[c.Object] = 
             hl = Highlights[c.Object]
              hl 
                Highlights[c.Object] = (c.Object, c.Color)
             hl.FillColor ~= c.Color 
                hl.FillColor = c.Color
            
        
            
        
    

     obj, hl  (Highlights) 
          activeSet[obj] 
             hl  hl.Parent  hl:() 
            Highlights[obj] = 
        
    


.(()
     Running 
        .()
          Running   
          State.ESPEnabled 
            ()
            AlertLabel.Visible = 
        
             myChar = LocalPlayer.Character
             myHRP = myChar  myChar:()
             myPos = myHRP  myHRP.Position  Camera.CFrame.Position

             closestKillerDist = 
             closestKillerName = 
             highlightCandidates = {}

             playersRoot = :()
             playersRoot 
                 State.SurvivorsESP 
                     sFolder = playersRoot:()
                     sFolder 
                         _, char  (sFolder:()) 
                             char ~= myChar  char:() 
                                 hrp = char:()
                                 hum = char:()
                                 hrp 
                                     dist = .((hrp.Position - myPos).Magnitude)
                                     dist <= MAX_ESP_DISTANCE 
                                         hp = hum  .(hum.Health)  
                                         rec = Billboards[char]

                                        if not rec then
                                            local role = char:GetAttribute("ActorDisplayName") or char.Name
                                            local user = char:GetAttribute("Username") or ""
                                            local maxHp = hum and math.floor(hum.MaxHealth) or 100
                                            local text = string.format("[SURVIVOR] %s (%s)\nHP: %d/%d | %dm", role, user ~= "" and user or char.Name, hp, maxHp, dist)
                                            local bb, lbl = CreateBillboard(hrp, text, Color3.fromRGB(0, 255, 140))
                                            Billboards[char] = { Gui = bb, Label = lbl, LastDist = dist, LastHp = hp, Role = role, User = user, MaxHp = maxHp }
                                        elseif math.abs((rec.LastDist or 0) - dist) >= 2 or rec.LastHp ~= hp then
                                            rec.LastDist = dist
                                            rec.LastHp = hp
                                            rec.Label.Text = string.format("[SURVIVOR] %s (%s)\nHP: %d/%d | %dm", rec.Role, rec.User ~= "" and rec.User or char.Name, hp, rec.MaxHp, dist)
                                        end

                                        if State.ChamsEnabled then
                                            table.insert(highlightCandidates, { Object = char, Color = Color3.fromRGB(0, 255, 140), Score = dist - 1000, Dist = dist })
                                        end
                                    elseif Billboards[char] then
                                        if Billboards[char].Gui and Billboards[char].Gui.Parent then Billboards[char].Gui:Destroy() end
                                        Billboards[char] = nil
                                    end
                                end
                            end
                        end
                    end
                end

                if State.KillersESP then
                    local kFolder = playersRoot:FindFirstChild("Killers")
                    if kFolder then
                        for _, char in ipairs(kFolder:GetChildren()) do
                            if char ~= myChar and char:IsA("Model") then
                                local hrp = char:FindFirstChild("HumanoidRootPart")
                                local hum = char:FindFirstChildOfClass("Humanoid")
                                if hrp then
                                    local dist = math.floor((hrp.Position - myPos).Magnitude)
                                    local role = char:GetAttribute("ActorDisplayName") or char.Name
                                    local user = char:GetAttribute("Username") or ""

                                    if dist < closestKillerDist then
                                        closestKillerDist = dist
                                        closestKillerName = role ~= "" and role or user
                                    end

                                    if dist <= MAX_ESP_DISTANCE then
                                        local hp = hum and math.floor(hum.Health) or 0
                                        local rec = Billboards[char]
                                        if not rec then
                                            local text = string.format("[KILLER] %s (%s)\nHP: %d | %dm", role, user ~= "" and user or char.Name, hp, dist)
                                            local bb, lbl = CreateBillboard(hrp, text, Color3.fromRGB(255, 45, 45))
                                            Billboards[char] = { Gui = bb, Label = lbl, LastDist = dist, LastHp = hp, Role = role, User = user }
                                        elseif math.abs((rec.LastDist or 0) - dist) >= 2 or rec.LastHp ~= hp then
                                            rec.LastDist = dist
                                            rec.LastHp = hp
                                            rec.Label.Text = string.format("[KILLER] %s (%s)\nHP: %d | %dm", rec.Role, rec.User ~= "" and rec.User or char.Name, hp, dist)
                                        end

                                        if State.ChamsEnabled then
                                            table.insert(highlightCandidates, { Object = char, Color = Color3.fromRGB(255, 45, 45), Score = dist - 2500, Dist = dist })
                                        end
                                    elseif Billboards[char] then
                                        if Billboards[char].Gui and Billboards[char].Gui.Parent then Billboards[char].Gui:Destroy() end
                                        Billboards[char] = nil
                                    end
                                end
                            end
                        end
                    end
                end
            end

            if State.KillerAlert and closestKillerDist <= State.KillerAlertDistance then
                AlertLabel.Text = string.format("[!] KILLER ALERT: %s (%dm) [!]", closestKillerName, closestKillerDist)
                AlertLabel.Visible = true
            else
                AlertLabel.Visible = false
            end

            if State.GeneratorsESP then
                local seenGens = {}
                for gen, mainPart in pairs(GeneratorCache) do
                    if gen and gen.Parent and mainPart and mainPart.Parent and mainPart:IsDescendantOf(workspace) then
                        local posKey = string.format("%d_%d_%d", math.floor(mainPart.Position.X / 6), math.floor(mainPart.Position.Y / 6), math.floor(mainPart.Position.Z / 6))
                        if seenGens[posKey] then
                            if Billboards[gen] then
                                if Billboards[gen].Gui and Billboards[gen].Gui.Parent then Billboards[gen].Gui:Destroy() end
                                Billboards[gen] = nil
                            end
                        else
                            seenGens[posKey] = true
                            local dist = math.floor((mainPart.Position - myPos).Magnitude)
                            if dist <= MAX_ESP_DISTANCE then
                                local prog = GetGeneratorProgress(gen)
                                local isDone = prog >= 100
                                local col = isDone and Color3.fromRGB(110, 255, 130) or Color3.fromRGB(255, 215, 0)
                                local rec = Billboards[gen]

                                if not rec then
                                    local text = string.format("[GEN] %d%% | %dm", prog, dist)
                                    local bb, lbl = CreateBillboard(mainPart, text, col)
                                    Billboards[gen] = { Gui = bb, Label = lbl, LastDist = dist, LastProg = prog }
                                elseif math.abs((rec.LastDist or 0) - dist) >= 2 or rec.LastProg ~= prog then
                                    rec.LastDist = dist
                                    rec.LastProg = prog
                                    rec.Label.Text = string.format("[GEN] %d%% | %dm", prog, dist)
                                    rec.Label.TextColor3 = col
                                end

                                if State.ChamsEnabled then
                                    table.insert(highlightCandidates, { Object = gen, Color = col, Score = dist, Dist = dist })
                                end
                            elseif Billboards[gen] then
                                if Billboards[gen].Gui and Billboards[gen].Gui.Parent then Billboards[gen].Gui:Destroy() end
                                Billboards[gen] = nil
                            end
                        end
                    else
                        UnregisterInstance(gen)
                    end
                end
            end

            if State.GearsESP then
                for gear, part in pairs(GearCache) do
                    if IsObjectPresent(gear, part) then
                        local dist = math.floor((part.Position - myPos).Magnitude)
                        if dist <= MAX_ESP_DISTANCE then
                            local col = Color3.fromRGB(0, 210, 255)
                            local rec = Billboards[gear]
                            if not rec then
                                local text = string.format("[GEAR] %dm", dist)
                                local bb, lbl = CreateBillboard(part, text, col)
                                Billboards[gear] = { Gui = bb, Label = lbl, LastDist = dist }
                            elseif math.abs((rec.LastDist or 0) - dist) >= 2 then
                                rec.LastDist = dist
                                rec.Label.Text = string.format("[GEAR] %dm", dist)
                            end

                            if State.ChamsEnabled then
                                table.insert(highlightCandidates, { Object = gear, Color = col, Score = dist - 200, Dist = dist })
                            end
                        elseif Billboards[gear] then
                            if Billboards[gear].Gui and Billboards[gear].Gui.Parent then Billboards[gear].Gui:Destroy() end
                            Billboards[gear] = nil
                        end
                    else
                        if Billboards[gear] then
                            if Billboards[gear].Gui and Billboards[gear].Gui.Parent then Billboards[gear].Gui:Destroy() end
                            Billboards[gear] = nil
                        end
                        if not gear or not gear.Parent then
                            GearCache[gear] = nil
                        end
                    end
                end
            end

            if State.TrapsESP then
                for trap, part in pairs(TrapCache) do
                    if trap and trap.Parent and part and part.Parent and part:IsDescendantOf(workspace) then
                        local dist = math.floor((part.Position - myPos).Magnitude)
                        if dist <= MAX_ESP_DISTANCE then
                            local col = Color3.fromRGB(255, 120, 0)
                            local trapName = trap.Name or "Trap"
                            local rec = Billboards[trap]
                            if not rec then
                                local text = string.format("[TRAP] %s\n%dm", trapName, dist)
                                local bb, lbl = CreateBillboard(part, text, col)
                                Billboards[trap] = { Gui = bb, Label = lbl, LastDist = dist }
                            elseif math.abs((rec.LastDist or 0) - dist) >= 2 then
                                rec.LastDist = dist
                                rec.Label.Text = string.format("[TRAP] %s\n%dm", trapName, dist)
                            end

                            if State.ChamsEnabled then
                                table.insert(highlightCandidates, { Object = trap, Color = col, Score = dist, Dist = dist })
                            end
                        elseif Billboards[trap] then
                            if Billboards[trap].Gui and Billboards[trap].Gui.Parent then Billboards[trap].Gui:Destroy() end
                            Billboards[trap] = nil
                        end
                    else
                        UnregisterInstance(trap)
                    end
                end
            end

            if State.ItemsESP then
                for item, data in pairs(ItemCache) do
                    local part = data.Part
                    if IsObjectPresent(item, part) then
                        local dist = math.floor((part.Position - myPos).Magnitude)
                        if dist <= MAX_ESP_DISTANCE then
                            local col = Color3.fromRGB(130, 255, 140)
                            local itemName = data.Name or "Item"
                            local rec = Billboards[item]
                            if not rec then
                                local text = string.format("[ITEM] %s\n%dm", itemName, dist)
                                local bb, lbl = CreateBillboard(part, text, col)
                                Billboards[item] = { Gui = bb, Label = lbl, LastDist = dist }
                            elseif math.abs((rec.LastDist or 0) - dist) >= 2 then
                                rec.LastDist = dist
                                rec.Label.Text = string.format("[ITEM] %s\n%dm", itemName, dist)
                            end

                            if State.ChamsEnabled then
                                table.insert(highlightCandidates, { Object = item, Color = col, Score = dist - 150, Dist = dist })
                            end
                        elseif Billboards[item] then
                            if Billboards[item].Gui and Billboards[item].Gui.Parent then Billboards[item].Gui:Destroy() end
                            Billboards[item] = nil
                        end
                    else
                        if Billboards[item] then
                            if Billboards[item].Gui and Billboards[item].Gui.Parent then Billboards[item].Gui:Destroy() end
                            Billboards[item] = nil
                        end
                        if not item or not item.Parent then
                            ItemCache[item] = nil
                        end
                    end
                end
            end

            UpdateHighlightsPriority(highlightCandidates)
        end
    end
end)

-- =========================================================================
-- GLOBAL CLEANUP
-- =========================================================================
getgenv().ForsakenCleanup = function()
    Running = false

    for _, conn in ipairs(Connections) do
        pcall(function() conn:Disconnect() end)
    end
    table.clear(Connections)

    ClearESP()
    table.clear(GeneratorCache)
    table.clear(GearCache)
    table.clear(TrapCache)
    table.clear(ItemCache)
    table.clear(ActivePromptCache)

    if ESPFolder and ESPFolder.Parent then ESPFolder:Destroy() end
    if AlertGui and AlertGui.Parent then AlertGui:Destroy() end

    if IsShiftEmulated then
        VirtualInputManager:SendKeyEvent(false, Enum.KeyCode.LeftShift, false, game)
        IsShiftEmulated = false
    end

    for _, prompt in ipairs(workspace:GetDescendants()) do
        if prompt:IsA("ProximityPrompt") then
            local orig = prompt:GetAttribute("OrigHold")
            if orig ~= nil then prompt.HoldDuration = orig end
            local origDist = prompt:GetAttribute("OrigDist")
            if origDist ~= nil then prompt.MaxActivationDistance = origDist end
            local origLOS = prompt:GetAttribute("OrigLOS")
            if origLOS ~= nil then prompt.RequiresLineOfSight = origLOS end
        end
    end

    Lighting.Ambient = OriginalLighting.Ambient
    Lighting.OutdoorAmbient = OriginalLighting.OutdoorAmbient
    Lighting.Brightness = OriginalLighting.Brightness
    Lighting.ClockTime = OriginalLighting.ClockTime
    Lighting.FogEnd = OriginalLighting.FogEnd
    Lighting.GlobalShadows = OriginalLighting.GlobalShadows

    if SprintingModule then
        SprintingModule.StaminaLossDisabled = false
        SprintingModule.SprintSpeed = 28
    end

    if getgenv()._ForsakenCleanOriginals then
        if flowCV and getgenv()._ForsakenCleanOriginals.FlowStart then
            flowCV.Start = getgenv()._ForsakenCleanOriginals.FlowStart
        end
        if connectCV and getgenv()._ForsakenCleanOriginals.ConnectStart then
            connectCV.Start = getgenv()._ForsakenCleanOriginals.ConnectStart
        end
        if lockCV and getgenv()._ForsakenCleanOriginals.LockStart then
            lockCV.Start = getgenv()._ForsakenCleanOriginals.LockStart
        end
        if gearCV and getgenv()._ForsakenCleanOriginals.GearStart then
            gearCV.Start = getgenv()._ForsakenCleanOriginals.GearStart
        end
    end

    pcall(function() Rayfield:Destroy() end)
end

-- =========================================================================
-- RAYFIELD UI WINDOW & TABS
-- =========================================================================
local Window = Rayfield:CreateWindow({
    Name = "Forsaken",
    Icon = 0,
    LoadingTitle = "Forsaken",
    LoadingSubtitle = "Loading script...",
    Theme = "Default",
    DisableRayfieldPrompts = true,
    DisableBuildWarnings = true,
    ConfigurationSaving = {
        Enabled = false,
    },
    KeySystem = false,
    ToggleUIKeybind = "F1",
})

-- 1. MOVEMENT
local TabMovement = Window:CreateTab("Movement", "footprints")
TabMovement:CreateSection("Jump & Movement")

TabMovement:CreateToggle({
    Name = "Forced Jump (Разблокировать прыжок)",
    CurrentValue = State.ForcedJump,
    Flag = "ForcedJump",
    Callback = function(val)
        State.ForcedJump = val
        local myChar = LocalPlayer.Character
        local hum = myChar and myChar:FindFirstChildOfClass("Humanoid")
        if hum then
            hum.UseJumpPower = true
            hum.JumpPower = val and State.JumpPower or 0
            hum.JumpHeight = val and (State.JumpPower / 7) or 0
            hum:SetStateEnabled(Enum.HumanoidStateType.Jumping, val)
        end
    end,
})

TabMovement:CreateToggle({
    Name = "Infinite Stamina (Бесконечная выносливость)",
    CurrentValue = State.InfiniteStamina,
    Flag = "InfiniteStamina",
    Callback = function(val)
        State.InfiniteStamina = val
        if SprintingModule then
            SprintingModule.StaminaLossDisabled = val
            if val then SprintingModule.Stamina = SprintingModule.MaxStamina or 110 end
        end
    end,
})

TabMovement:CreateToggle({
    Name = "Infinite Jump (Бесконечный прыжок)",
    CurrentValue = State.InfiniteJump,
    Flag = "InfiniteJump",
    Callback = function(val)
        State.InfiniteJump = val
    end,
})

TabMovement:CreateToggle({
    Name = "Anti-Slow (Снятие замедлений)",
    CurrentValue = State.AntiSlow,
    Flag = "AntiSlow",
    Callback = function(val)
        State.AntiSlow = val
    end,
})

TabMovement:CreateToggle({
    Name = "Auto-Sprint (Бег без Shift)",
    CurrentValue = State.AutoSprint,
    Flag = "AutoSprint",
    Callback = function(val)
        State.AutoSprint = val
    end,
})

TabMovement:CreateSection("Values")

TabMovement:CreateSlider({
    Name = "Jump Power",
    Range = { 20, 120 },
    Increment = 5,
    CurrentValue = State.JumpPower,
    Flag = "JumpPower",
    Callback = function(val)
        State.JumpPower = val
        local myChar = LocalPlayer.Character
        local hum = myChar and myChar:FindFirstChildOfClass("Humanoid")
        if hum and State.ForcedJump then
            hum.UseJumpPower = true
            hum.JumpPower = val
            hum.JumpHeight = val / 7
        end
    end,
})

-- 2. COMBAT
local TabCombat = Window:CreateTab("Combat", "sword")
TabCombat:CreateSection("Auto Defense")

TabCombat:CreateToggle({
    Name = "Auto-Block (Парирование Q)",
    CurrentValue = State.AutoBlock,
    Flag = "AutoBlock",
    Callback = function(val)
        State.AutoBlock = val
    end,
})

TabCombat:CreateToggle({
    Name = "Auto-Avoid Killer (Авто-отталкивание)",
    CurrentValue = State.AutoAvoidKiller,
    Flag = "AutoAvoidKiller",
    Callback = function(val)
        State.AutoAvoidKiller = val
    end,
})

TabCombat:CreateSlider({
    Name = "Auto-Block Distance",
    Range = { 8, 22 },
    Increment = 1,
    Suffix = "m",
    CurrentValue = State.AutoBlockRange,
    Flag = "AutoBlockRange",
    Callback = function(val)
        State.AutoBlockRange = val
    end,
})

TabCombat:CreateSlider({
    Name = "Avoid Distance",
    Range = { 8, 30 },
    Increment = 1,
    Suffix = "m",
    CurrentValue = State.AutoAvoidKillerRange,
    Flag = "AutoAvoidKillerRange",
    Callback = function(val)
        State.AutoAvoidKillerRange = val
    end,
})

TabCombat:CreateSlider({
    Name = "Repel Force (Сила отталкивания)",
    Range = { 30, 140 },
    Increment = 5,
    CurrentValue = State.AvoidRepelForce,
    Flag = "AvoidRepelForce",
    Callback = function(val)
        State.AvoidRepelForce = val
    end,
})

TabCombat:CreateSection("Manual Avoid")

TabCombat:CreateKeybind({
    Name = "Avoid Impulse Keybind",
    CurrentKeybind = "V",
    HoldToInteract = false,
    Flag = "AvoidKeybind",
    Callback = function()
        ExecuteAvoidImpulse()
    end,
})

TabCombat:CreateButton({
    Name = "Manual Avoid Impulse (Рывок от маньяка)",
    Callback = function()
        ExecuteAvoidImpulse()
    end,
})

TabCombat:CreateSection("Triggerbot (Killer)")

TabCombat:CreateToggle({
    Name = "Triggerbot (Авто-аим и M1 маньяка)",
    CurrentValue = State.Triggerbot,
    Flag = "Triggerbot",
    Callback = function(val)
        State.Triggerbot = val
    end,
})

TabCombat:CreateSlider({
    Name = "Triggerbot Range",
    Range = { 6, 25 },
    Increment = 1,
    Suffix = "m",
    CurrentValue = State.TriggerbotRange,
    Flag = "TriggerbotRange",
    Callback = function(val)
        State.TriggerbotRange = val
    end,
})

TabCombat:CreateSlider({
    Name = "Triggerbot Cooldown",
    Range = { 0.1, 1.0 },
    Increment = 0.05,
    Suffix = "s",
    CurrentValue = State.TriggerbotCooldown,
    Flag = "TriggerbotCooldown",
    Callback = function(val)
        State.TriggerbotCooldown = val
    end,
})

-- 3. VISUALS
local TabVisuals = Window:CreateTab("Visuals", "eye")
TabVisuals:CreateSection("ESP")

TabVisuals:CreateToggle({
    Name = "Master ESP",
    CurrentValue = State.ESPEnabled,
    Flag = "ESPEnabled",
    Callback = function(val) State.ESPEnabled = val end,
})

TabVisuals:CreateToggle({
    Name = "Generators ESP",
    CurrentValue = State.GeneratorsESP,
    Flag = "GeneratorsESP",
    Callback = function(val) State.GeneratorsESP = val end,
})

TabVisuals:CreateToggle({
    Name = "Gears ESP",
    CurrentValue = State.GearsESP,
    Flag = "GearsESP",
    Callback = function(val) State.GearsESP = val end,
})

TabVisuals:CreateToggle({
    Name = "Traps ESP",
    CurrentValue = State.TrapsESP,
    Flag = "TrapsESP",
    Callback = function(val) State.TrapsESP = val end,
})

TabVisuals:CreateToggle({
    Name = "Items ESP",
    CurrentValue = State.ItemsESP,
    Flag = "ItemsESP",
    Callback = function(val) State.ItemsESP = val end,
})

TabVisuals:CreateToggle({
    Name = "Survivors ESP",
    CurrentValue = State.SurvivorsESP,
    Flag = "SurvivorsESP",
    Callback = function(val) State.SurvivorsESP = val end,
})

TabVisuals:CreateToggle({
    Name = "Killers ESP",
    CurrentValue = State.KillersESP,
    Flag = "KillersESP",
    Callback = function(val) State.KillersESP = val end,
})

TabVisuals:CreateToggle({
    Name = "Chams (Highlight)",
    CurrentValue = State.ChamsEnabled,
    Flag = "ChamsEnabled",
    Callback = function(val) State.ChamsEnabled = val end,
})

TabVisuals:CreateSection("Alerts & Camera")

TabVisuals:CreateToggle({
    Name = "Killer Proximity Alert",
    CurrentValue = State.KillerAlert,
    Flag = "KillerAlert",
    Callback = function(val) State.KillerAlert = val end,
})

TabVisuals:CreateSlider({
    Name = "Alert Distance",
    Range = { 30, 150 },
    Increment = 5,
    Suffix = "m",
    CurrentValue = State.KillerAlertDistance,
    Flag = "KillerAlertDistance",
    Callback = function(val) State.KillerAlertDistance = val end,
})

TabVisuals:CreateToggle({
    Name = "Fullbright & Anti-Fog",
    CurrentValue = State.Fullbright,
    Flag = "Fullbright",
    Callback = function(val)
        State.Fullbright = val
        if not val then
            Lighting.Ambient = OriginalLighting.Ambient
            Lighting.OutdoorAmbient = OriginalLighting.OutdoorAmbient
            Lighting.Brightness = OriginalLighting.Brightness
            Lighting.ClockTime = OriginalLighting.ClockTime
            Lighting.FogEnd = OriginalLighting.FogEnd
            Lighting.GlobalShadows = OriginalLighting.GlobalShadows
        end
    end,
})

TabVisuals:CreateToggle({
    Name = "Remove Dark Screen VFX",
    CurrentValue = State.RemoveVFX,
    Flag = "RemoveVFX",
    Callback = function(val) State.RemoveVFX = val end,
})

TabVisuals:CreateSlider({
    Name = "Field Of View (FOV)",
    Range = { 70, 120 },
    Increment = 1,
    CurrentValue = State.CustomFOV,
    Flag = "CustomFOV",
    Callback = function(val)
        State.CustomFOV = val
        if Camera then Camera.FieldOfView = val end
    end,
})

-- 4. PUZZLES & INTERACT
local TabPuzzles = Window:CreateTab("Puzzles", "puzzle")
TabPuzzles:CreateSection("Automation & Interact")

TabPuzzles:CreateToggle({
    Name = "Auto-Puzzle Solver (Все миниигры)",
    CurrentValue = State.AutoAllPuzzles,
    Flag = "AutoAllPuzzles",
    Callback = function(val) State.AutoAllPuzzles = val end,
})

TabPuzzles:CreateToggle({
    Name = "Instant Interact (0s Hold)",
    CurrentValue = State.InstantInteract,
    Flag = "InstantInteract",
    Callback = function(val)
        State.InstantInteract = val
        UpdateAllPrompts()
    end,
})

TabPuzzles:CreateToggle({
    Name = "Auto-Collect Items & Gears",
    CurrentValue = State.AutoProximityInteract,
    Flag = "AutoProximityInteract",
    Callback = function(val) State.AutoProximityInteract = val end,
})

TabPuzzles:CreateToggle({
    Name = "Proximity Range Spoof (30m)",
    CurrentValue = State.ProximitySpoofRange,
    Flag = "ProximitySpoofRange",
    Callback = function(val)
        State.ProximitySpoofRange = val
        UpdateAllPrompts()
    end,
})

TabPuzzles:CreateSection("Objective Teleports")

TabPuzzles:CreateButton({
    Name = "Teleport to Unfinished Generator",
    Callback = function()
        local myChar = LocalPlayer.Character
        local myHRP = myChar and myChar:FindFirstChild("HumanoidRootPart")
        if not myHRP then return end

        local bestPart, minDist = nil, 999999
        local myPos = myHRP.Position

        for gen, part in pairs(GeneratorCache) do
            if gen and gen.Parent and part and part.Parent then
                if GetGeneratorProgress(gen) < 100 then
                    local dist = (part.Position - myPos).Magnitude
                    if dist < minDist then
                        minDist = dist
                        bestPart = part
                    end
                end
            end
        end

        if bestPart then
            myChar:PivotTo(bestPart.CFrame + Vector3.new(0, 3, 0))
            Notify("Generator", string.format("Телепортирован к генератору (%dм)", math.floor(minDist)), 2.5)
        else
            Notify("Generator", "Незавершенных генераторов поблизости нет.", 2.5)
        end
    end,
})

TabPuzzles:CreateButton({
    Name = "Teleport to Nearest Gear",
    Callback = function()
        local myChar = LocalPlayer.Character
        local myHRP = myChar and myChar:FindFirstChild("HumanoidRootPart")
        if not myHRP then return end

        local bestPart, minDist = nil, 999999
        local myPos = myHRP.Position

        for gear, part in pairs(GearCache) do
            if gear and gear.Parent and part and part.Parent then
                local dist = (part.Position - myPos).Magnitude
                if dist < minDist then
                    minDist = dist
                    bestPart = part
                end
            end
        end

        if bestPart then
            myChar:PivotTo(bestPart.CFrame + Vector3.new(0, 3, 0))
            Notify("Gear", string.format("Телепортирован к гиру (%dм)", math.floor(minDist)), 2.5)
        else
            Notify("Gear", "Шестерёнки не найдены на текущей карте.", 2.5)
        end
    end,
})

-- 5. TELEPORT
local TabTeleport = Window:CreateTab("Teleport", "navigation")
TabTeleport:CreateSection("Players & Lobby")

TabTeleport:CreateButton({
    Name = "Teleport Behind Killer",
    Callback = function()
        local myChar = LocalPlayer.Character
        local myHRP = myChar and myChar:FindFirstChild("HumanoidRootPart")
        if not myHRP then return end

        local killersFolder = workspace:FindFirstChild("Players") and workspace.Players:FindFirstChild("Killers")
        if killersFolder and #killersFolder:GetChildren() > 0 then
            local killer = killersFolder:GetChildren()[1]
            local hrp = killer:FindFirstChild("HumanoidRootPart")
            if hrp then
                myChar:PivotTo(hrp.CFrame * CFrame.new(0, 0, 5))
                Notify("Teleport", "Телепортирован к Killer: " .. killer.Name, 2.5)
                return
            end
        end
        Notify("Teleport", "Маньяк не найден.", 2.5)
    end,
})

TabTeleport:CreateButton({
    Name = "Teleport to Random Survivor",
    Callback = function()
        local myChar = LocalPlayer.Character
        local myHRP = myChar and myChar:FindFirstChild("HumanoidRootPart")
        if not myHRP then return end

        local survivorsFolder = workspace:FindFirstChild("Players") and workspace.Players:FindFirstChild("Survivors")
        if survivorsFolder then
            local list = {}
            for _, s in ipairs(survivorsFolder:GetChildren()) do
                if s ~= myChar and s:FindFirstChild("HumanoidRootPart") then
                    table.insert(list, s)
                end
            end
            if #list > 0 then
                local chosen = list[math.random(1, #list)]
                myChar:PivotTo(chosen.HumanoidRootPart.CFrame * CFrame.new(0, 0, 4))
                Notify("Teleport", "Телепортирован к Survivor: " .. chosen.Name, 2.5)
                return
            end
        end
        Notify("Teleport", "Живых выживших не найдено.", 2.5)
    end,
})

TabTeleport:CreateButton({
    Name = "Teleport to Lobby Spawn",
    Callback = function()
        local myChar = LocalPlayer.Character
        if not myChar then return end

        local spawnLoc = workspace:FindFirstChild("Map") and workspace.Map:FindFirstChild("Lobby") and workspace.Map.Lobby:FindFirstChild("Spawn")
        if spawnLoc then
            myChar:PivotTo(spawnLoc.CFrame + Vector3.new(0, 4, 0))
        else
            myChar:PivotTo(CFrame.new(-5742, 305, -2130))
        end
        Notify("Teleport", "Телепортирован в лобби.", 2.5)
    end,
})

-- 6. SETTINGS
local TabSettings = Window:CreateTab("Settings", "settings")
TabSettings:CreateSection("Script Actions")

TabSettings:CreateButton({
    Name = "Rejoin Server",
    Callback = function()
        TeleportService:TeleportToPlaceInstance(game.PlaceId, game.JobId, LocalPlayer)
    end,
})

TabSettings:CreateButton({
    Name = "Unload Script",
    Callback = function()
        if getgenv().ForsakenCleanup then
            getgenv().ForsakenCleanup()
        end
    end,
})

Notify("Forsaken Loaded", "Нажми F1 чтобы скрыть/открыть меню", 4.0)