skidwtf Semi rage

 Repo = 
 Library = (:(Repo .. ))()
 ThemeManager = (:(Repo .. ))()
 SaveManager = (:(Repo .. ))()

 Workspace = :()
 Players = :()
 RunService = :()
 UserInputService = :()
 Lighting = :()
 Camera = Workspace.CurrentCamera
 LocalPlayer = Players.LocalPlayer

 ColorCorrection = Lighting:()  .()
ColorCorrection.Name = 
ColorCorrection.Parent = Lighting

 activeESPs = {}
 fovCircle = 
 targetLine = .()
targetLine.Visible = 
targetLine.Thickness = 
targetLine.Color = .(, , )

 resolutions = {
    [] = .(, , , , , , , , , , , ),
    [] = .(, , , , , , , , , , , ),
    [] = .(, , , , , , , , , , , ),
    [] = .(, , , , , , , , , , , )
}

 Toggles = {
    EspEnabled = ,
    ShowNames = ,
    ShowHealth = ,
    ShowDistance = ,
    ShowTracers = ,
    TeamCheck = ,
    AimbotEnabled = ,
    ShowFOV = ,
    VisibleCheck = ,
    TargetLines = ,
    SpeedEnabled = ,
    NoCamShake = ,
    NoFog = 
}

 Options = {
    AimbotFOV = ,
    AimbotSmoothness = ,
    AimbotPart = ,
    TargetMode = ,
    MaxEspDistance = ,
    WalkSpeed = ,
    TimeOfDay = ,
    Saturation = ,
    Contrast = ,
    CurrentRes = 
}

  (worldPos)
     stretchCFrame = resolutions[Options.CurrentRes]  resolutions[]
     camCF = Camera.CFrame
     objectSpace = camCF:(worldPos)
     yScale = stretchCFrame.YVector.Y
     stretchedObjectSpace = .(objectSpace.X, objectSpace.Y / yScale, objectSpace.Z)
     correctedWorldPos = camCF:(stretchedObjectSpace)
     Camera:(correctedWorldPos)


  (targetPart)
      Toggles.VisibleCheck    
     origin = Camera.CFrame.Position
     destination = targetPart.Position
     direction = destination - origin
     raycastParams = RaycastParams.()
    raycastParams.FilterDescendantsInstances = {LocalPlayer.Character, Camera}
    raycastParams.FilterType = .RaycastFilterType.Blacklist
     result = Workspace:(origin, direction, raycastParams)
     result   result.Instance:(targetPart.Parent) 
     


  ()
      fovCircle 
        fovCircle = .()
        fovCircle.Thickness = 
        fovCircle.Color = .(, , )
        fovCircle.NumSides = 
        fovCircle.Filled = 
    
    fovCircle.Visible = Toggles.AimbotEnabled  Toggles.ShowFOV
    fovCircle.Radius = Options.AimbotFOV
    fovCircle.Position = Camera.ViewportSize / 


  (model)
     activeESPs[model]   
     drawings = {
        Outline = .(),
        Box = .(),
        NameTag = .(),
        DistanceTag = .(),
        HealthBar = .(),
        HealthOutline = .(),
        Tracer = .()
    }
    
    drawings.Box.Thickness = 
    drawings.Box.Color = .(, , )
    drawings.Box.Filled = 
    drawings.Box.ZIndex = 
    
    drawings.Outline.Thickness = 
    drawings.Outline.Color = .(, , )
    drawings.Outline.Filled = 
    drawings.Outline.ZIndex = 
    
    drawings.NameTag.Center, drawings.NameTag.Outline, drawings.NameTag.Size = , , 
    drawings.NameTag.Color = .(, , )
    
    drawings.DistanceTag.Center, drawings.DistanceTag.Outline, drawings.DistanceTag.Size = , , 
    drawings.DistanceTag.Color = .(, , )
    
    drawings.HealthBar.Filled = 
    drawings.HealthBar.ZIndex = 
    
    drawings.HealthOutline.Filled = 
    drawings.HealthOutline.Color = .(, , )
    drawings.HealthOutline.ZIndex = 
    
    drawings.Tracer.Thickness = 
    drawings.Tracer.Color = .(, , )
    
    activeESPs[model] = drawings


  (model)
     activeESPs[model] 
         _, obj  (activeESPs[model])  obj:() 
        activeESPs[model] = 
    


  (model)
     targetPart = model:(Options.AimbotPart)
     targetPart  model:()  model.PrimaryPart


  ()
     bestTarget = 
     lastMetric = .huge 
     targets = {}
     _, p  (Players:())   p.Character  .(targets, p.Character)  
     _, obj  (Workspace:()) 
         obj:()  obj:()   Players:(obj) 
            .(targets, obj)
        
    

     _, char  (targets) 
         hum = char:()
         player = Players:(char)
         root = char:()
         hum  hum.Health >   char ~= LocalPlayer.Character  root 
             Toggles.TeamCheck  player  player.Team == LocalPlayer.Team   
             part = (char)
              part   
             screenPos, onScreen = (part.Position)
             onScreen  (part) 
                 mouseDist = (.(screenPos.X, screenPos.Y) - Camera.ViewportSize/).Magnitude
                 charDist = (root.Position - LocalPlayer.Character.HumanoidRootPart.Position).Magnitude
                 mouseDist <= Options.AimbotFOV 
                     metric = (Options.TargetMode == )  charDist  hum.Health
                     metric < lastMetric  lastMetric = metric; bestTarget = part 
                
            
        
    
     bestTarget


RunService.RenderStepped:(()
    ()

    Camera.CFrame = Camera.CFrame * (resolutions[Options.CurrentRes]  resolutions[])

    ColorCorrection.Saturation = Options.Saturation
    ColorCorrection.Contrast = Options.Contrast
     Toggles.NoFog 
        Lighting.FogEnd = 
         Lighting:() 
            Lighting:().Density = 
        
    

     Toggles.SpeedEnabled  LocalPlayer.Character  LocalPlayer.Character:() 
        LocalPlayer.Character:().WalkSpeed = Options.WalkSpeed
    

    Lighting.ClockTime = Options.TimeOfDay

     target = ()
     Toggles.AimbotEnabled  target 
         screenPos, onScreen = (target.Position)
         onScreen  Toggles.TargetLines 
            targetLine.Visible = 
            targetLine.From = Camera.ViewportSize / 
            targetLine.To = .(screenPos.X, screenPos.Y)
         targetLine.Visible =  

         UserInputService:(.UserInputType.MouseButton2) 
             mousePos = UserInputService:()
            ((screenPos.X - mousePos.X) * Options.AimbotSmoothness, (screenPos.Y - mousePos.Y) * Options.AimbotSmoothness)
        
     targetLine.Visible =  

     model, drawings  (activeESPs) 
         hum = model:()
         root = model:()  model.PrimaryPart
          model.Parent   hum  hum.Health <=    root 
            (model)
            
        

         distance = (root.Position - Camera.CFrame.Position).Magnitude
         screenPos, onScreen = (root.Position)

         onScreen  Toggles.EspEnabled  distance <= Options.MaxEspDistance 
             headPos = (root.Position + .(, , ))
             legPos = (root.Position - .(, , ))
             height = .(headPos.Y - legPos.Y)
             width = height / 
             boxPos = .(screenPos.X - width/, screenPos.Y - height/)

            drawings.Box.Visible = 
            drawings.Box.Size = .(width, height)
            drawings.Box.Position = boxPos
            
            drawings.Outline.Visible = 
            drawings.Outline.Size = drawings.Box.Size
            drawings.Outline.Position = drawings.Box.Position

             Toggles.ShowNames  
                drawings.NameTag.Visible = 
                drawings.NameTag.Text = model.Name
                drawings.NameTag.Position = .(screenPos.X, boxPos.Y - ) 
             drawings.NameTag.Visible =  
            
             Toggles.ShowDistance  
                drawings.DistanceTag.Visible = 
                drawings.DistanceTag.Text =  .. .(distance) .. 
                drawings.DistanceTag.Position = .(screenPos.X, boxPos.Y + height + ) 
             drawings.DistanceTag.Visible =  

             Toggles.ShowHealth 
                 healthScale = .(hum.Health / hum.MaxHealth, , )
                 barHeight = height * healthScale
                drawings.HealthOutline.Visible = 
                drawings.HealthOutline.Size = .(, height + )
                drawings.HealthOutline.Position = .(boxPos.X - , boxPos.Y - )
                
                drawings.HealthBar.Visible = 
                drawings.HealthBar.Size = .(, barHeight)
                drawings.HealthBar.Position = .(boxPos.X - , boxPos.Y + (height - barHeight))
                drawings.HealthBar.Color = .(, , ):(.(, , ), healthScale)
             drawings.HealthOutline.Visible, drawings.HealthBar.Visible = ,  

             Toggles.ShowTracers 
                drawings.Tracer.Visible = 
                drawings.Tracer.From = .(Camera.ViewportSize.X / , Camera.ViewportSize.Y)
                drawings.Tracer.To = .(screenPos.X, screenPos.Y + (height/))
             drawings.Tracer.Visible =  
        
             _, d  (drawings)  d.Visible =  
        
    

     _, obj  (Workspace:()) 
         obj:()  obj:()  obj ~= LocalPlayer.Character 
              activeESPs[obj]  (obj) 
        
    
)

 Window = Library:({ Title = , Center = , AutoShow =  })
 Tabs = { Main = Window:(), Misc = Window:(), Settings = Window:() }

 EspGroup = Tabs.Main:()
EspGroup:(, { Text = , Default =  }):((v) Toggles.EspEnabled = v )
EspGroup:(, { Text = , Default =  }):((v) Toggles.ShowNames = v )
EspGroup:(, { Text = , Default =  }):((v) Toggles.ShowHealth = v )
EspGroup:(, { Text = , Default =  }):((v) Toggles.ShowDistance = v )
EspGroup:(, { Text = , Default =  }):((v) Toggles.ShowTracers = v )
EspGroup:(, { Text = , Default = , Min = , Max = , Rounding =  }):((v) Options.MaxEspDistance = v )

 AimGroup = Tabs.Main:()
AimGroup:(, { Text = , Default =  }):((v) Toggles.AimbotEnabled = v )
AimGroup:(, { Text = , Default =  }):((v) Toggles.VisibleCheck = v )
AimGroup:(, { Text = , Default =  }):((v) Toggles.TargetLines = v )
AimGroup:(, { Text = , Default =  }):((v) Toggles.ShowFOV = v )
AimGroup:(, { Text = , Default = , Values = {, } }):((v) Options.TargetMode = v )
AimGroup:(, { Text = , Default = , Min = , Max = , Rounding =  }):((v) Options.AimbotFOV = v )
AimGroup:(, { Text = , Default = , Min = , Max = , Rounding =  }):((v) Options.AimbotSmoothness = v )
AimGroup:(, { Text = , Default = , Values = {, } }):((v) Options.AimbotPart = v )

 MiscGroup = Tabs.Misc:()
MiscGroup:(, { Text = , Default =  }):((v) Toggles.SpeedEnabled = v )
MiscGroup:(, { Text = , Default = , Min = , Max = , Rounding =  }):((v) Options.WalkSpeed = v )
MiscGroup:(, { Text = , Default =  }):((v) Toggles.NoCamShake = v )
MiscGroup:(, { Text = , Default =  }):((v) Toggles.NoFog = v )
MiscGroup:(, { Text = , Default = , Min = , Max = , Rounding =  }):((v) Options.TimeOfDay = v )

 VisualGroup = Tabs.Misc:()
VisualGroup:(, { Text = , Default = , Values = {, , , } }):((v) Options.CurrentRes = v )
VisualGroup:(, { Text = , Default = , Min = -, Max = , Rounding =  }):((v) Options.Saturation = v )
VisualGroup:(, { Text = , Default = , Min = -, Max = , Rounding =  }):((v) Options.Contrast = v )

Library:()