Universal silent aim for mobile

  :()  
    .Loaded:()


     protectgui 
    ().protectgui = () 


 bypass_adonis 
    .(()
         g = getinfo  debug.getinfo
         d = 
         h = {}

         x, y

        ()

         i, v  () 
             (v) ==  
                 a = (v, )
                 b = (v, )
            
                 (a) ==    x 
                    x = a
                     o; o = (x, (c, f, n)
                         c ~=  
                             d 
                                ()
                            
                        
                        
                         
                    )
                    .(h, x)
                

                 (v, )  (v, )  (b) ==    y 
                    y = b
                     o; o = (y, (f)
                         d 
                            ()
                        
                    )
                    .(h, y)
                
            
        

         o; o = (().debug.info, ((...)
             a, f = ...

             x  a == x 
                 d 
                    ()
                

                 .(.())
            
            
             (...)
        ))

        ()
    )


 SilentAimSettings = {
    Enabled = ,
    
    ClassName = ,
    ToggleKey = ,
    
    TeamCheck = ,
    TargetPart = ,
    SilentAimMethod = ,
    
    FOVRadius = ,
    ShowSilentAimTarget = , 
    HitChance = 
}

 Camera = .CurrentCamera
 Players = :()
 RunService = :()
 GuiService = :()
 UserInputService = :()
 HttpService = :()

 LocalPlayer = Players.LocalPlayer
 Mouse = LocalPlayer:()

 GetChildren = .GetChildren
 GetPlayers = Players.GetPlayers
 WorldToScreen = Camera.WorldToScreenPoint
 WorldToViewportPoint = Camera.WorldToViewportPoint
 GetPartsObscuringTarget = Camera.GetPartsObscuringTarget
 FindFirstChild = .FindFirstChild
 RenderStepped = RunService.RenderStepped
 GuiInset = GuiService.GetGuiInset
 GetMouseLocation = UserInputService.GetMouseLocation

 resume = .resume 
 create = .create

 ValidTargetParts = {, }
 PredictionAmount = 

 ScreenGui = .()
ScreenGui.ResetOnSpawn = 
ScreenGui.Parent = .CoreGui

 fov_circle = .()
fov_circle.Thickness = 
fov_circle.NumSides = 
fov_circle.Radius = 
fov_circle.Filled = 
fov_circle.Visible = 
fov_circle.ZIndex = 
fov_circle.Transparency = 
fov_circle.Color = .(, , )

 ExpectedArguments = {
    ViewportPointToRay = {
        ArgCountRequired = ,
        Args = { ,  }
    },
    ScreenPointToRay = {
        ArgCountRequired = ,
        Args = { ,  }
    },
    Raycast = {
        ArgCountRequired = ,
        Args = { , , ,  }
    },
    FindPartOnRay = {
        ArgCountRequired = ,
        Args = { , , ,  }
    },
    FindPartOnRayWithIgnoreList = {
        ArgCountRequired = ,
        Args = { , , ,  }
    },
    FindPartOnRayWithWhitelist = { 
        ArgCountRequired = ,
        Args = { , ,  }
    }
}

 (Percentage)

    Percentage = .(Percentage)


     chance = .(Random.().(Random.(), , ) * ) / 


     chance <= Percentage / 



  (Vector)
     Vec3, OnScreen = (Camera, Vector)
     .(Vec3.X, Vec3.Y), OnScreen


  (Args, RayMethod)
     Matches = 
     #Args < RayMethod.ArgCountRequired 
         
    

     Pos, Argument  , Args 
         Expected = RayMethod.Args[Pos]
          Expected 
            
        

         IsOptional = Expected:(-) == 
         BaseType = IsOptional  Expected:(, -)  Expected

         (Argument) == BaseType 
            Matches = Matches + 
         IsOptional  Argument ==  
            Matches = Matches + 
        
    

     Matches >= RayMethod.ArgCountRequired


  (Origin, Position)
     (Position - Origin).Unit * 


  ()
     (UserInputService)


  (Player)
    
      Player   Player.Character   LocalPlayer.Character 
         
    

    
     targetPartName = (Options  Options.TargetPart  Options.TargetPart.Value)  SilentAimSettings.TargetPart  
     TargetPart = (Player.Character, targetPartName)  (Player.Character, )
      TargetPart 
         
    

    
     castPoints = {
        TargetPart.Position,
        TargetPart.Position + .(, , ),
        TargetPart.Position + .(, -, )
    }

    
     ignoreList = { LocalPlayer.Character, Player.Character }

    
     obscuring = (Camera, castPoints, ignoreList)

     (#obscuring == )


  ()
      Options.TargetPart.Value   
     Camera = .CurrentCamera
     Closest
     DistanceToMouse
     center = .(Camera.ViewportSize.X/, Camera.ViewportSize.Y/)
     ignoredPlayers = Options.PlayerDropdown.Value 

     _, Player  , (Players) 
         Player == LocalPlayer   
         ignoredPlayers  ignoredPlayers[Player.Name]   
         Toggles.TeamCheck.Value  Player.Team == LocalPlayer.Team   

         Character = Player.Character
          Character   

         HumanoidRootPart = (Character, )
         Humanoid = (Character, )
          HumanoidRootPart   Humanoid  Humanoid  Humanoid.Health <=    

         ScreenPosition, OnScreen = (HumanoidRootPart.Position)
          OnScreen   

        
          (Player)   

         Distance = (center - ScreenPosition).Magnitude
         Distance <= (DistanceToMouse  Options.Radius.Value  ) 
            Closest = ((Options.TargetPart.Value ==   Character[ValidTargetParts[.(, #ValidTargetParts)]])  Character[Options.TargetPart.Value])
            DistanceToMouse = Distance
        
    
     Closest


RunService.RenderStepped:(()
     aimLockEnabled  lockEnabled  isLockedOn  targetPlayer  targetPlayer.Character 
         partName = (targetPlayer.Character, bodyPartSelected)
         part = targetPlayer.Character:(partName)

         part  targetPlayer.Character:().Health >  
             predictedPosition = part.Position + (part.AssemblyLinearVelocity * predictionFactor)
             currentCameraPosition = Camera.CFrame.Position

            Camera.CFrame = .(currentCameraPosition, predictedPosition) * .(, , smoothingFactor)
        
            isLockedOn = 
            targetPlayer = 
        
    
)

 Library = (:())()
 ThemeManager = (:())()
 SaveManager = (:())()

 Window = Library:({
    Title = ,
    Center = ,
    AutoShow = ,  
    TabPadding = ,
    MenuFadeTime = 
})

 GeneralTab = Window:()
 aimbox = GeneralTab:()
 velbox = GeneralTab:()
 frabox = GeneralTab:()
 ExploitTab = Window:()
 WarTycoonBox = ExploitTab:()
 ACSEngineBox = ExploitTab:()
 VisualsTab = Window:()
 settingsTab = Window:()
 MenuGroup = settingsTab:()
MenuGroup:(, () Library:() )
ThemeManager:(Library)
SaveManager:(Library)
ThemeManager:(settingsTab)
SaveManager:(settingsTab)

 ScreenGui = .()
 OpenButton = .()
ScreenGui.Parent = .CoreGui
ScreenGui.ZIndexBehavior = .ZIndexBehavior.Sibling

OpenButton.Parent = ScreenGui
OpenButton.BackgroundColor3 = .(, , )
OpenButton.Size = .(, , , )
OpenButton.Position = .(, -, , -)
OpenButton.Text = 
OpenButton.TextColor3 = .(, , )
OpenButton.Font = .Font.Code
OpenButton.TextSize = 
OpenButton.BorderSizePixel = 
OpenButton.Active = 

 UIStroke = .()
UIStroke.Thickness = 
UIStroke.Color = .(, , )
UIStroke.ApplyStrokeMode = .ApplyStrokeMode.Border
UIStroke.Parent = OpenButton

OpenButton.MouseButton1Click:(()
    Library:()
)

 dragging, dragInput, dragStart, startPos
  (input)
     delta = input.Position - dragStart
    OpenButton.Position = .(
        startPos.X.Scale,
        startPos.X.Offset + delta.X,
        startPos.Y.Scale,
        startPos.Y.Offset + delta.Y
    )


OpenButton.InputBegan:((input)
     input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
        dragging = 
        dragStart = input.Position
        startPos = OpenButton.Position

        input.Changed:(()
             input.UserInputState == .UserInputState.End 
                dragging = 
            
        )
    
)

OpenButton.InputChanged:((input)
     input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch 
        dragInput = input
    
)

:().InputChanged:((input)
     input == dragInput  dragging 
        (input)
    
)

aimbox:(, {
    Text = ,
    Default = ,
    Tooltip = ,
    Callback = (value)
        aimLockEnabled = value
          aimLockEnabled 
            lockEnabled = 
            isLockedOn = 
            targetPlayer = 
        
    
})

aimbox:(, {
    Text = ,
    Default = ,
    Tooltip = ,
    Callback = (value)
        lockEnabled = value
          lockEnabled 
            isLockedOn = 
            targetPlayer = 
        
    ,
}):(, {
    Default = , 
    SyncToggleState = ,
    Mode = ,
    Text = ,
    Tooltip = ,
    Callback = ()
        ()
    ,
})

aimbox:(, {
    Text = ,
    Default = ,
    Min = ,
    Max = ,
    Rounding = ,
    Tooltip = ,
    Callback = (value)
        smoothingFactor = value
    ,
})


aimbox:(, {
    Text = ,
    Default = ,
    Min = ,
    Max = ,
    Rounding = ,
    Tooltip = ,
    Callback = (value)
        predictionFactor = value
    ,
})

aimbox:(, {
    Values = {, , , , , },
    Default = ,
    Multi = ,
    Text = ,
    Tooltip = ,
    Callback = (value)
        bodyPartSelected = value
    ,
})


 reverseResolveIntensity = 
().Desync = 
().DesyncEnabled =   


:().Heartbeat:(()
     ().DesyncEnabled   
         ().Desync 
             player = .Players.LocalPlayer
             character = player.Character
              character    

             humanoidRootPart = character:()
              humanoidRootPart   

             originalVelocity = humanoidRootPart.Velocity

             randomOffset = .(
                .(-, ) * reverseResolveIntensity * ,
                .(-, ) * reverseResolveIntensity * ,
                .(-, ) * reverseResolveIntensity * 
            )

            humanoidRootPart.Velocity = randomOffset
            humanoidRootPart.CFrame = humanoidRootPart.CFrame * .(
                ,
                .(-, ) * reverseResolveIntensity * ,
                
            )

            :().RenderStepped:()

            humanoidRootPart.Velocity = originalVelocity
        
    
)

velbox:(, {
    Text = ,
    Default = ,
    Tooltip = ,
    Callback = (value)
        ().DesyncEnabled = value  
    
})


velbox:(, {
    Text = ,
    Default = ,
    Tooltip = ,
    Callback = (value)
        ().Desync = value
    
}):(, {
    Default = , 
    SyncToggleState = ,
    Mode = ,
    Text = ,
    Tooltip = ,
    Callback = (value)
        ().Desync = value
    
})


velbox:(, {
    Text = ,
    Default = ,
    Min = ,
    Max = ,
    Rounding = ,
    Tooltip = ,
    Callback = (value)
        reverseResolveIntensity = value
    
})



 antiLockEnabled = 
 resolverIntensity = 
 resolverMethod = 


RunService.RenderStepped:(()
     aimLockEnabled  isLockedOn  targetPlayer  targetPlayer.Character 
         partName = (targetPlayer.Character, bodyPartSelected)
         part = targetPlayer.Character:(partName)

         part  targetPlayer.Character:().Health >  
             predictedPosition = part.Position + (part.AssemblyLinearVelocity * predictionFactor)

             antiLockEnabled 
                 resolverMethod ==  

                    predictedPosition = predictedPosition + (part.AssemblyLinearVelocity * resolverIntensity)
                 resolverMethod ==  

                    predictedPosition = predictedPosition + .(
                        .() * resolverIntensity - (resolverIntensity / ),
                        .() * resolverIntensity - (resolverIntensity / ),
                        .() * resolverIntensity - (resolverIntensity / )
                    )
                 resolverMethod ==  

                    predictedPosition = predictedPosition - (part.AssemblyLinearVelocity * resolverIntensity * )
                
            

             currentCameraPosition = Camera.CFrame.Position
            Camera.CFrame = .(currentCameraPosition, predictedPosition) * .(, , smoothingFactor)
        
            isLockedOn = 
            targetPlayer = 
        
    
)

aimbox:(, {
    Text = ,
    Default = ,
    Tooltip = ,
    Callback = (value)
        antiLockEnabled = value
    ,
})

aimbox:(, {
    Text = ,
    Default = ,
    Min = ,
    Max = ,
    Rounding = ,
    Tooltip = ,
    Callback = (value)
        resolverIntensity = value
    ,
})

aimbox:(, {
    Values = {, , },
    Default = , 
    Multi = ,
    Text = ,
    Tooltip = ,
    Callback = (value)
        resolverMethod = value
    ,
})


 MainBOX = GeneralTab:()
 Main = MainBOX:()

SilentAimSettings.BulletTP = 


Main:(, {Text = })
    :(, {
        Default = , 
        SyncToggleState = , 
        Mode = , 
        Text = , 
        NoUI = 
    })

Options.aim_Enabled_KeyPicker:(()
    SilentAimSettings.Enabled =  SilentAimSettings.Enabled
    Toggles.aim_Enabled.Value = SilentAimSettings.Enabled
    Toggles.aim_Enabled:(SilentAimSettings.Enabled)
    mouse_box.Visible = SilentAimSettings.Enabled
)


Main:(, {
    Text = , 
    Default = SilentAimSettings.TeamCheck
}):(()
    SilentAimSettings.TeamCheck = Toggles.TeamCheck.Value
)

Main:(, {
    Text = ,
    Default = SilentAimSettings.BulletTP,
    Tooltip = 
}):(()
    SilentAimSettings.BulletTP = Toggles.BulletTP.Value
)

Main:(, {
    AllowNull = , 
    Text = , 
    Default = SilentAimSettings.TargetPart, 
    Values = {, , }
}):(()
    SilentAimSettings.TargetPart = Options.TargetPart.Value
)

Main:(, {
    AllowNull = ,
    Text = ,
    Default = SilentAimSettings.SilentAimMethod,
    Values = {
        ,
        ,
        ,
        ,
        ,
        
    }
}):(() 
    SilentAimSettings.SilentAimMethod = Options.Method.Value 
)

  SilentAimSettings.BlockedMethods 
    SilentAimSettings.BlockedMethods = {}


Main:(, {
    AllowNull = ,
    Multi = ,
    Text = ,
    Default = SilentAimSettings.BlockedMethods,
    Values = {
        ,
        ,
        ,
        ,
        
    }
}):(()
    SilentAimSettings.BlockedMethods = Options[].Value
)

Main:(, {
    AllowNull = ,
    Multi = ,
    Text = ,
    Default = SilentAimSettings.Include  {},
    Values = {, },
    Tooltip = 
}):(()
    SilentAimSettings.Include = Options.Include.Value
)

Main:(, {
    AllowNull = ,
    Multi = ,
    Text = ,
    Default = SilentAimSettings.Origin  ,
    Values = {, },
    Tooltip = 
}):(()
    SilentAimSettings.Origin = Options.Origin.Value
)

Main:(, {
    Text = ,
    Default = ,
    Min = ,
    Max = ,
    Rounding = ,
    Compact = ,
    Tooltip = 
}):(()
    SilentAimSettings.MultiplyUnitBy = Options.MultiplyUnitBy.Value
)

Main:(, {
    Text = ,
    Default = ,
    Min = ,
    Max = ,
    Rounding = ,
    Compact = ,
}):(()
    SilentAimSettings.HitChance = Options.HitChance.Value
)


 FieldOfViewBOX = GeneralTab:() 
     Main = FieldOfViewBOX:()

    Main:(, {Text = })
        :(, {Default = .(, , )})
        :(()
            fov_circle.Visible = Toggles.Visible.Value
            SilentAimSettings.FOVVisible = Toggles.Visible.Value
        )

    Main:(, {
        Text = , 
        Min = , 
        Max = , 
        Default = , 
        Rounding = 
    }):(()
        fov_circle.Radius = Options.Radius.Value
        SilentAimSettings.FOVRadius = Options.Radius.Value
    )

    Main:(, {Text = })
        :(, {Default = .(, , )})
        :(()
            SilentAimSettings.ShowSilentAimTarget = Toggles.MousePosition.Value
        )

    Main:(, {
        SpecialType = ,
        Text = ,
        Tooltip = ,
        Multi = 
    })


 previousHighlight = 
  ()
     previousHighlight 
        previousHighlight:()
        previousHighlight = 
    


.(()
    RenderStepped:(()
         Toggles.MousePosition.Value 
             closestPlayer = ()
             closestPlayer  
                 char = closestPlayer.Parent
                 char  char:()  char:() 
                     Toggles.TeamCheck.Value  closestPlayer:()  closestPlayer.Team == LocalPlayer.Team 
                        ()
                        
                    
                     Root = char.PrimaryPart  char:()
                     Root 
                         RootToViewportPoint, IsOnScreen = (Camera, Root.Position)
                        ()
                         IsOnScreen 
                             highlight = char:()
                              highlight 
                                highlight = .()
                                highlight.Parent = char
                                highlight.Adornee = char
                            
                            highlight.FillColor = Options.MouseVisualizeColor.Value
                            highlight.FillTransparency = 
                            highlight.OutlineColor = Options.MouseVisualizeColor.Value
                            highlight.OutlineTransparency = 
                            previousHighlight = highlight
                        
                    
                
             
                ()
            
        
         Toggles.Visible.Value  
            fov_circle.Visible = Toggles.Visible.Value
            fov_circle.Color = Options.Color.Value
            fov_circle.Position = .(Camera.ViewportSize.X/, Camera.ViewportSize.Y/)
        
    )
)


 Players = :()
 LocalPlayer = Players.LocalPlayer
 SoundService = :()

 sounds = {
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
}

 hitSound = .()
hitSound.Volume = 
hitSound.Parent = SoundService

 HitSoundBox = GeneralTab:() 
     Main = HitSoundBox:()

    Main:(, {Text = , Default = })

    Main:(, {
        Values = {,,,,,,,},
        Default = ,
        Text = ,
        Tooltip = 
    }):(()
         id = sounds[Options.HitSoundSelect.Value]
         id 
            hitSound.SoundId = id
        
    )


hitSound.SoundId = sounds[Options.HitSoundSelect.Value]

 soundPool = {}
 soundIndex = 

  ()
     soundIndex > #soundPool 
         s = hitSound:()
        s.Parent = 
        s.Looped = 
        .(soundPool, s)
    
     s = soundPool[soundIndex]
    soundIndex = soundIndex + 
     s


  ()
     s = ()
    s:()
    s:()


  (plr)
     plr == LocalPlayer   

    plr.CharacterAdded:((char)
         hum = char:(, )
          hum   

         lastHealth = hum.Health

        hum.HealthChanged:((newHp)
             Toggles.HitSoundEnabled.Value 
                 closest = ()
                 closest  closest.Parent == char 
                     newHp < lastHealth 
                        ()
                    
                     lastHealth >   newHp <=  
                        ()
                    
                
            
            lastHealth = newHp
        )
    )


 _, plr  (Players:()) 
    (plr)

Players.PlayerAdded:(trackPlayer)

 oldNamecall
oldNamecall = (, , ((...)
     Method, Arguments = (), {...}
     self, chance = Arguments[], (SilentAimSettings.HitChance)

     BlockedMethods = SilentAimSettings.BlockedMethods  {}
     Method ==   self == Client 
        
    
     .(BlockedMethods, Method) 
        
    

     CanContinue = 
     SilentAimSettings.CheckForFireFunc  (Method ==   Method ==   Method ==   Method ==   Method ==   Method == ) 
         Traceback = (debug.()):()
         Traceback:()  Traceback:()  Traceback:() 
            CanContinue = 
        
             (...)
        
    

     Toggles.aim_Enabled  Toggles.aim_Enabled.Value  self ==    ()  chance 
         HitPart = ()
         HitPart 
              (Origin)
                 SilentAimSettings.BulletTP 
                    Origin = (HitPart.CFrame * .(, , )).p
                
                 Origin, (Origin, HitPart.Position)
            
             Method ==   SilentAimSettings.SilentAimMethod == Method 
                 (Arguments, ExpectedArguments.FindPartOnRayWithIgnoreList) 
                     Origin, Direction = (Arguments[].Origin)
                    Arguments[] = Ray.(Origin, Direction * SilentAimSettings.MultiplyUnitBy)
                     ((Arguments))
                
             Method ==   SilentAimSettings.SilentAimMethod == Method 
                 (Arguments, ExpectedArguments.FindPartOnRayWithWhitelist) 
                     Origin, Direction = (Arguments[].Origin)
                    Arguments[] = Ray.(Origin, Direction * SilentAimSettings.MultiplyUnitBy)
                     ((Arguments))
                
             (Method ==   Method == )  SilentAimSettings.SilentAimMethod:() == Method:() 
                 (Arguments, ExpectedArguments.FindPartOnRay) 
                     Origin, Direction = (Arguments[].Origin)
                    Arguments[] = Ray.(Origin, Direction * SilentAimSettings.MultiplyUnitBy)
                     ((Arguments))
                
             Method ==   SilentAimSettings.SilentAimMethod == Method 
                 (Arguments, ExpectedArguments.Raycast) 
                     Origin, Direction = (Arguments[])
                    Arguments[], Arguments[] = Origin, Direction * SilentAimSettings.MultiplyUnitBy
                     ((Arguments))
                
             Method ==   SilentAimSettings.SilentAimMethod == Method 
                 (Arguments, ExpectedArguments.ViewportPointToRay) 
                     Origin = Camera.CFrame.p
                     SilentAimSettings.BulletTP 
                        Origin = (HitPart.CFrame * .(, , )).p
                    
                    Arguments[] = Camera:(HitPart.Position)
                     Ray.(Origin, (HitPart.Position - Origin).Unit * SilentAimSettings.MultiplyUnitBy)
                
             Method ==   SilentAimSettings.SilentAimMethod == Method 
                 (Arguments, ExpectedArguments.ScreenPointToRay) 
                     Origin = Camera.CFrame.p
                     SilentAimSettings.BulletTP 
                        Origin = (HitPart.CFrame * .(, , )).p
                    
                    Arguments[] = Camera:(HitPart.Position)
                     Ray.(Origin, (HitPart.Position - Origin).Unit * SilentAimSettings.MultiplyUnitBy)
                
             Method ==   SilentAimSettings.SilentAimMethod ==  
                 Origin, Direction = (Arguments[].Origin)
                Arguments[] = Ray.(Origin, Direction * SilentAimSettings.MultiplyUnitBy)
                 ((Arguments))
            
        
    

     (...)
))

 VisualsEx = VisualsTab:()

  .ExunysESPLoaded 
    (:())()


 ESP = ().ExunysDeveloperESP
  ESP    

ESP.Settings = ESP.Settings  {}
ESP.Settings.Enabled = 
ESP.Properties = ESP.Properties  {}

 queuedToggles = {
    NameTag = ,
    Box = ,
    Tracer = ,
    HeadDot = ,
    HealthBar = ,
}

  ()
      ESP.Settings.Enabled   ESP.Properties   

     ESP.Properties.ESP  ESP.Properties.ESP.DisplayName = queuedToggles.NameTag 
     ESP.Properties.Box  ESP.Properties.Box.Enabled = queuedToggles.Box 
     ESP.Properties.Tracer  ESP.Properties.Tracer.Enabled = queuedToggles.Tracer 
     ESP.Properties.HeadDot  ESP.Properties.HeadDot.Enabled = queuedToggles.HeadDot 
     ESP.Properties.HealthBar  ESP.Properties.HealthBar.Enabled = queuedToggles.HealthBar 


  (name, value)
    queuedToggles[name] = value
    ()


  (path, value)
     ref = ESP
     i = , #path- 
         ref  ref[path[i]] 
            ref = ref[path[i]]
        
            
        
    
     ref  path[#path] 
        ref[path[#path]] = value
    


VisualsEx:(, {
    Text = ,
    Default = ,
    Callback = (value)
         value   ESP.Loaded 
            ESP:()
        
        ESP.Settings.Enabled = value
        ()
    
})

 TeamCheck = 

  (player)
      TeamCheck 
         
    
     player.Team ~= LocalPlayer.Team


VisualsEx:(, {
    Text = ,
    Default = ESP.Settings.TeamCheck,
    Callback = (value)
        ESP.Settings.TeamCheck = value
        ()
    
})

 espElements = {
    {Name = , Path = {, , }, Type = },
    {Name = , Path = {, , }, Type = },
    {Name = , Path = {, , }, Type = },
    {Name = , Path = {, , }, Type = },
    {Name = , Path = {, , }, Type = },
    {Name = , Path = {, , }, Type = },
    {Name = , Path = {, , }, Type = , Min = , Max = , Default = ESP.Properties.HeadDot.NumSides},
    {Name = , Path = {, , }, Type = },
}

 _, element  (espElements) 
     element.Type ==  
        VisualsEx:(element.Name, {
            Text = element.Name,
            Default = ,
            Callback = (val)
                (element.Name, val)
            
        })
     element.Type ==  
        VisualsEx:(element.Name):(element.Name.., {
            Default = setProperty  ESP[element.Path[]][element.Path[]][element.Path[]]  .(,,),
            Callback = (val)
                (element.Path, val)
            
        })
     element.Type ==  
        VisualsEx:(element.Name, {
            Text = element.Name,
            Min = element.Min,
            Max = element.Max,
            Default = element.Default,
            Rounding = ,
            Callback = (val)
                (element.Path, val)
            
        })
    


 Players = :()
 RunService = :()
 LocalPlayer = Players.LocalPlayer

 SelfChamsEnabled = 
 RainbowChamsEnabled = 
 SelfChamsColor = .(, , )
 originalProperties = {}

  (h, s, v)
     c = v * s
     x = c * ( - .((h / ) %  - ))
     m = v - c
     r, g, b = , , 

     h <   r, g, b = c, x, 
     h <   r, g, b = x, c, 
     h <   r, g, b = , c, x
     h <   r, g, b = , x, c
     h <   r, g, b = x, , c
     r, g, b = c, , x 

     .(r + m, g + m, b + m)


  (char)
      char   
    originalProperties = {}
     _, part  (char:()) 
         part:()  part.Name ~=  
            originalProperties[part] = {
                Color = part.Color,
                Material = part.Material
            }
            part.Material = .Material.ForceField
            part.Color = SelfChamsColor
        
    


  ()
     part, props  (originalProperties) 
         part  part.Parent 
            part.Color = props.Color
            part.Material = props.Material
        
    
    originalProperties = {}


  ()
      SelfChamsEnabled   
     part, _  (originalProperties) 
         part  part.Parent 
             RainbowChamsEnabled 
                 hue = (() * ) % 
                part.Color = (hue, , )
            
                part.Color = SelfChamsColor
            
        
    


RunService.RenderStepped:(updateChams)

LocalPlayer.CharacterAdded:((char)
     SelfChamsEnabled 
        .()
        (char)
    
)

VisualsEx:(, {
    Text = ,
    Default = ,
    Callback = (val)
        SelfChamsEnabled = val
         val 
             LocalPlayer.Character 
                (LocalPlayer.Character)
            
        
            ()
        
    
})

VisualsEx:(, {
    Text = ,
    Default = ,
    Callback = (val)
        RainbowChamsEnabled = val
    
})

VisualsEx:():(, {
    Default = SelfChamsColor,
    Callback = (val)
        SelfChamsColor = val
    
})

 Players = :()
 LocalPlayer = Players.LocalPlayer
 RunService = :()

 ChamsEnabled = 
 ChamsOccludedColor = {.(, , ), }
 ChamsVisibleColor = {.(, , ), }

 AdornmentsCache = {}
 IgnoreNames = {[] = }

  (part, isHead, vis)
     adorn
     isHead 
        adorn = .()
        adorn.Height = vis ==     
        adorn.Radius = vis ==     
    
        adorn = .()
         offset = vis ==   -  
        adorn.Size = part.Size + .(offset, offset, offset)
    
    adorn.Adornee = part
    adorn.Parent = part
    adorn.ZIndex = vis ==     
    adorn.AlwaysOnTop = vis == 
    adorn.Visible = 
     adorn


  (player)
     ESP  ESP.Settings  ESP.Settings.TeamCheck 
         player.Team ~= LocalPlayer.Team
    
     


  (player)
     player ~= LocalPlayer  player.Character 
         _, part  (player.Character:()) 
             part:()   IgnoreNames[part.Name] 
                  AdornmentsCache[part] 
                    AdornmentsCache[part] = {
                        (part, part.Name==, ),
                        (part, part.Name==, )
                    }
                
                 ad = AdornmentsCache[part]
                 visible = ChamsEnabled  (player)

                ad[].Visible = visible
                ad[].Color3 = ChamsOccludedColor[]
                ad[].Transparency = ChamsOccludedColor[]

                ad[].Visible = visible
                ad[].AlwaysOnTop = 
                ad[].ZIndex = 
                ad[].Color3 = ChamsVisibleColor[]
                ad[].Transparency = ChamsVisibleColor[]
            
        
    


  ()
     _, player  (Players:()) 
        (player)
    


  (player)
    player:():(()
         AdornmentsCache[player] 
             _, ad  (AdornmentsCache[player]) 
                ad.Visible = ChamsEnabled  (player)
            
        
    )


Players.PlayerAdded:(TrackPlayer)
 _, plr  (Players:()) 
     plr ~= LocalPlayer 
        (plr)
    


RunService.RenderStepped:(UpdateAllChams)

VisualsEx:(, {
    Text = ,
    Default = ChamsEnabled,
    Callback = (val)
        ChamsEnabled = val
         part, ad  (AdornmentsCache) 
            ad[].Visible = val
            ad[].Visible = val
        
    
})

VisualsEx:():(, {
    Default = ChamsOccludedColor[],
    Callback = (val)
        ChamsOccludedColor[] = val
    
})

VisualsEx:():(, {
    Default = ChamsVisibleColor[],
    Callback = (val)
        ChamsVisibleColor[] = val
    
})

VisualsEx:(, {
    Text = ,
    Default = ChamsOccludedColor[],
    Min = ,
    Max = ,
    Rounding = ,
    Callback = (val)
        ChamsOccludedColor[] = val
    
})

VisualsEx:(, {
    Text = ,
    Default = ChamsVisibleColor[],
    Min = ,
    Max = ,
    Rounding = ,
    Callback = (val)
        ChamsVisibleColor[] = val
    
})

 worldbox = VisualsTab:()
 lighting = :()
 camera = .Workspace.CurrentCamera
 lockedTime, fovValue, nebulaEnabled = , , 
 originalAmbient, originalOutdoorAmbient = lighting.Ambient, lighting.OutdoorAmbient
 originalFogStart, originalFogEnd, originalFogColor = lighting.FogStart, lighting.FogEnd, lighting.FogColor
 nebulaThemeColor = .(, , )

worldbox:(, {
    Text = , Default = , Min = , Max = , Rounding = ,
    Callback = (v) lockedTime = v lighting.ClockTime = v ,
})

 oldNewIndex
oldNewIndex = (, , (self, property, value)
      ()  self == lighting 
         property ==   value = lockedTime 
    
     (self, property, value)
)

worldbox:(, {
    Text = , Default = , Min = , Max = , Rounding = ,
    Callback = (v) fovValue = v ,
})

 fovEnabled = 

worldbox:(, {
    Text = , Default = ,
    Callback = (state) fovEnabled = state ,
})

:().RenderStepped:(() 
     fovEnabled 
        camera.FieldOfView = fovValue 
    
)

worldbox:(, {
    Text = , Default = ,
    Callback = (state)
        nebulaEnabled = state
         state 
             b = .(, lighting) b.Intensity, b.Size, b.Threshold, b.Name = , , , 
             c = .(, lighting) c.Saturation, c.Contrast, c.TintColor, c.Name = , , nebulaThemeColor, 
             a = .(, lighting) a.Density, a.Offset, a.Glare, a.Haze, a.Color, a.Decay, a.Name = , , , , nebulaThemeColor, .(, , ), 
            lighting.Ambient, lighting.OutdoorAmbient = nebulaThemeColor, nebulaThemeColor
            lighting.FogStart, lighting.FogEnd = , 
            lighting.FogColor = nebulaThemeColor
        
             _, v  ({, , }) 
                 obj = lighting:(v)  obj  obj:() 
            
            lighting.Ambient, lighting.OutdoorAmbient = originalAmbient, originalOutdoorAmbient
            lighting.FogStart, lighting.FogEnd = originalFogStart, originalFogEnd
            lighting.FogColor = originalFogColor
        
    ,
}):(, {
    Text = , Default = .(, , ),
    Callback = (c)
        nebulaThemeColor = c
         nebulaEnabled 
             nc = lighting:()  nc  nc.TintColor = c 
             na = lighting:()  na  na.Color = c 
            lighting.Ambient, lighting.OutdoorAmbient = c, c
            lighting.FogColor = c
        
    ,
})


 Lighting = :()
 Visuals = {}
 Skyboxes = {}

 Visuals:(Data)
     Name = Data.Name
    Skyboxes[Name] = {
        SkyboxBk = Data.SkyboxBk,
        SkyboxDn = Data.SkyboxDn,
        SkyboxFt = Data.SkyboxFt,
        SkyboxLf = Data.SkyboxLf,
        SkyboxRt = Data.SkyboxRt,
        SkyboxUp = Data.SkyboxUp,
        MoonTextureId = Data.Moon  ,
        SunTextureId = Data.Sun  
    }


 Visuals:(Name)
     OldSky = Lighting:()
     OldSky  OldSky:() 

     Sky = .(, Lighting)
     Index, Value  (Skyboxes[Name]) 
        Sky[Index] = Value
    


 Lighting:() 
     OldSky = Lighting:()
    Visuals:({
        Name = ,
        SkyboxBk = OldSky.SkyboxBk,
        SkyboxDn = OldSky.SkyboxDn,
        SkyboxFt = OldSky.SkyboxFt,
        SkyboxLf = OldSky.SkyboxLf,
        SkyboxRt = OldSky.SkyboxRt,
        SkyboxUp = OldSky.SkyboxUp
    })


Visuals:({
    Name = ,
    SkyboxBk = ,
    SkyboxDn = ,
    SkyboxFt = ,
    SkyboxLf = ,
    SkyboxRt = ,
    SkyboxUp = 
})

Visuals:({
    Name = ,
    SkyboxBk = ,
    SkyboxDn = ,
    SkyboxFt = ,
    SkyboxLf = ,
    SkyboxRt = ,
    SkyboxUp = 
})

Visuals:({
    Name = ,
    SkyboxBk = ,
    SkyboxDn = ,
    SkyboxFt = ,
    SkyboxLf = ,
    SkyboxRt = ,
    SkyboxUp = 
})

Visuals:({
    Name = ,
    SkyboxBk = ,
    SkyboxDn = ,
    SkyboxFt = ,
    SkyboxLf = ,
    SkyboxRt = ,
    SkyboxUp = 
})

Visuals:({
    Name = , 
    SkyboxBk = ;
    SkyboxDn = ;
    SkyboxFt = ;
    SkyboxLf = ;
    SkyboxRt = ;
    SkyboxUp = ;
})

Visuals:({
    Name = , 
    SkyboxBk = ;
    SkyboxDn = ;
    SkyboxFt = ;
    SkyboxLf = ;
    SkyboxRt = ;
    SkyboxUp = ;
})

Visuals:({
    Name = , 
    SkyboxBk = ;
    SkyboxDn = ;
    SkyboxFt = ;
    SkyboxLf = ;
    SkyboxRt = ;
    SkyboxUp = ;
})

Visuals:({
    Name = , 
    SkyboxBk = ;
    SkyboxDn = ;
    SkyboxFt = ;
    SkyboxLf = ;
    SkyboxRt = ;
    SkyboxUp = ;
})

Visuals:({
    Name = , 
    SkyboxBk = ;
    SkyboxDn = ;
    SkyboxFt = ;
    SkyboxLf = ;
    SkyboxRt = ;
    SkyboxUp = ;
})

Visuals:({
    Name = , 
    SkyboxBk = ;
    SkyboxDn = ;
    SkyboxFt = ;
    SkyboxLf = ;
    SkyboxRt = ;
    SkyboxUp = ;
})

Visuals:({
    Name = , 
    SkyboxBk = ;
    SkyboxDn = ;
    SkyboxFt = ;
    SkyboxLf = ;
    SkyboxRt = ;
    SkyboxUp = ;
})

Visuals:({
    Name = , 
    SkyboxBk = ;
    SkyboxDn = ;
    SkyboxFt = ;
    SkyboxLf = ;
    SkyboxRt = ;
    SkyboxUp = ;
})

Visuals:({
    Name = , 
    SkyboxBk = ;
    SkyboxDn = ;
    SkyboxFt = ;
    SkyboxLf = ;
    SkyboxRt = ;
    SkyboxUp = ;
})

 SkyboxNames = {}
 Name, _  (Skyboxes) 
    .(SkyboxNames, Name)


 worldbox = VisualsTab:()
 SkyboxDropdown = worldbox:(, {
    AllowNull = ,
    Text = ,
    Default = ,
    Values = SkyboxNames
}):((SelectedSkybox)
     Skyboxes[SelectedSkybox] 
        Visuals:(SelectedSkybox)
    
)

 localPlayer = :().LocalPlayer
 Cmultiplier =   
 isSpeedActive = 
 isFlyActive = 
 isNoClipActive = 
 isFunctionalityEnabled =   
 flySpeed = 
 camera = .CurrentCamera
 humanoid = 

frabox:(, {
    Text = ,
    Default = ,
    Tooltip = ,
    Callback = (value)
        isFunctionalityEnabled = value
    
})

frabox:(, {
    Text = ,
    Default = ,
    Tooltip = ,
    Callback = (value)
        isSpeedActive = value
    
}):(, {
    Default = ,  
    SyncToggleState = ,
    Mode = ,
    Text = ,
    Tooltip = ,
    Callback = (value)
        isSpeedActive = value
    
})

frabox:(, {
    Text = ,
    Default = ,
    Min = ,
    Max = ,
    Rounding = ,
    Tooltip = ,
    Callback = (value)
        Cmultiplier = value
    ,
})

frabox:(, {
    Text = ,
    Default = ,
    Tooltip = ,
    Callback = (value)
        isFlyActive = value
    
}):(, {
    Default = ,  
    SyncToggleState = ,
    Mode = ,
    Text = ,
    Tooltip = ,
    Callback = (value)
        isFlyActive = value
    
})

frabox:(, {
    Text = ,
    Default = ,
    Min = ,
    Max = ,
    Rounding = ,
    Tooltip = ,
    Callback = (value)
        flySpeed = value
    ,
})

frabox:(, {
    Text = ,
    Default = ,
    Tooltip = ,
    Callback = (value)
        isNoClipActive = value
    
}):(, {
    Default = ,
    SyncToggleState = ,
    Mode = ,
    Text = ,
    Tooltip = ,
    Callback = (value)
        isNoClipActive = value
    
})

 masterToggle = 

  (value)
    masterToggle = value


WarTycoonBox:(, {
    Text = ,
    Default = ,
    Tooltip = ,
    Callback = enableMasterToggle
})

  (property, value)
      (parent)
         _, child  (parent:()) 
             child:() 
                 success, module = (()  (child) )
                 success  module[property] ~=  
                     module
                
            
             found = (child)
             found 
                 found
            
        
         
    

     player = :().LocalPlayer
     backpack = player:()
     character = player.Character  player.CharacterAdded:()
     foundModules = {}


      (item)
         weaponName = item.Name
         settingsModule = :():():():(weaponName)
         settingsModule 
             settingsModule:()
        
         
    

     ().WarTycoon 
         ().WeaponOnHands 
             toolInHand = character:()
             toolInHand 
                 settingsModule = (toolInHand)
                 settingsModule 
                     success, module = (()  (settingsModule) )
                     success  module[property] ~=  
                        module[property] = value
                    
                
            
        
             _, item  (backpack:()) 
                 settingsModule = (item)
                 settingsModule 
                     success, module = (()  (settingsModule) )
                     success  module[property] ~=  
                        module[property] = value
                    
                
            
        
    
         ().WeaponOnHands 
             toolInHand = character:()
             toolInHand 
                 settingsModule = (toolInHand)
                 settingsModule 
                     success, module = (()  (settingsModule) )
                     success  module[property] ~=  
                        module[property] = value
                    
                
            
        
             _, item  (backpack:()) 
                 settingsModule = (item)
                 settingsModule 
                     success, module = (()  (settingsModule) )
                     success  module[property] ~=  
                        module[property] = value
                    
                
            
        
    


ACSEngineBox:(, {
    Text = ,
    Default = ,
    Tooltip = ,
    Callback = (value)
        ().WarTycoon = value
    
})

ACSEngineBox:(, {
    Text = ,
    Default = ,
    Tooltip = ,
    Callback = (value)
        ().WeaponOnHands = value
    
})

ACSEngineBox:(, ()
    (, .huge)
)

ACSEngineBox:(, ()
    (, {, })
    (, {, })
    (, )
    (, )
    (, )
    (, )
)

ACSEngineBox:(, ()
    (, )
)

ACSEngineBox:AddInput("BulletSpeedInput", {
    Text = "Bullet Speed",
    Default = "10000",
    Tooltip = "Set the bullet speed",
    Callback = function(value)
        getgenv().bulletSpeedValue = tonumber(value) or 10000
    end
})

ACSEngineBox:AddButton('CHANGE BULLET SPEED', function()
    modifyWeaponSettings("BSpeed", getgenv().bulletSpeedValue or 10000)
    modifyWeaponSettings("MuzzleVelocity", getgenv().bulletSpeedValue or 10000)
end)

local fireRateInput
fireRateInput = ACSEngineBox:AddInput('FireRateInput', {
    Text = 'Enter Fire Rate',
    Default = '8888',
    Tooltip = 'Type the fire rate value you want to apply.',
})

ACSEngineBox:AddButton('CHANGE FIRE RATE', function()
    modifyWeaponSettings("FireRate", tonumber(fireRateInput.Value) or 8888)
    modifyWeaponSettings("ShootRate", tonumber(fireRateInput.Value) or 8888)
end)

local bulletsInput = ACSEngineBox:AddInput('BulletsInput', {
    Text = 'Enter Bullets',
    Default = '50',
    Tooltip = 'Type the number of bullets you want to apply.',
    Numeric = true
})

ACSEngineBox:AddButton('MULTI BULLETS', function()
    local bulletsValue = tonumber(Options.BulletsInput.Value) or 50
    modifyWeaponSettings("Bullets", bulletsValue)
end)

local inputField
inputField = ACSEngineBox:AddInput('FireModeInput', {
    Text = 'Enter Fire Mode',
    Default = 'Auto',
    Tooltip = 'Type the fire mode you want to apply.',
})

ACSEngineBox:AddButton('CHANGE FIRE MODE', function()
    modifyWeaponSettings("Mode", inputField.Value or 'Auto')
end)

--not final code need optimize FindFirstChild... Cuz can make FinFirstChilde true withous find 1 and find 2 only find 1
local Players = game:GetService("Players")
local LocalPlayer = Players.LocalPlayer
local RunService = game:GetService("RunService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Workspace = game:GetService("Workspace")

local isTankSpamEnabled = false
local spamSpeed = 1
local shellsToFire = 1
local shellNumber = 1

local FireTurret, RegisterTurretHit


local function getTank()
    if not masterToggle then return end
    local tankWorkspace = Workspace:FindFirstChild("Game Systems") 
        and Workspace["Game Systems"]:FindFirstChild("Tank Workspace")
    if not tankWorkspace then return nil end

    local closestTank = nil
    local shortestDistance = math.huge

    for _, tank in pairs(tankWorkspace:GetChildren()) do
        if tank:FindFirstChild("Misc") and tank.Misc:FindFirstChild("Turrets") then
            local tankPos = (tank.PrimaryPart and tank.PrimaryPart.Position) or Vector3.new()
            local playerPos = (LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart") and LocalPlayer.Character.HumanoidRootPart.Position) or Vector3.new()
            local distance = (tankPos - playerPos).Magnitude
            if distance < shortestDistance then
                shortestDistance = distance
                closestTank = tank
            end
        end
    end

    return closestTank
end

local function getTurretSmokeAndSettings(tank)
    if not masterToggle then return end
    if not tank:FindFirstChild("Misc") or not tank.Misc:FindFirstChild("Turrets") then return nil, nil, nil end
    local turretsFolder = tank.Misc.Turrets

    for _, turretGroup in pairs(turretsFolder:GetChildren()) do
        if turretGroup:IsA("Folder") or turretGroup:IsA("Model") then
            for _, turret in pairs(turretGroup:GetChildren()) do
                if turret:IsA("BasePart") or turret:IsA("Model") then
                    local smoke = turret:FindFirstChild("SmokePart")
                    local module = turret:FindFirstChildOfClass("ModuleScript")
                    if smoke and module then
                        local settings = require(module)
                        return turret, smoke, settings
                    end
                end
            end
        end
    end

    return nil, nil, nil
end

local function startTankSpam()
    if not masterToggle then return end
    if not FireTurret or not RegisterTurretHit then
        FireTurret = ReplicatedStorage.BulletFireSystem:WaitForChild("FireTurret")
        RegisterTurretHit = ReplicatedStorage.BulletFireSystem:WaitForChild("RegisterTurretHit")
    end

    local tank = getTank()
    if not tank then return end

    local turret, smoke, settings = getTurretSmokeAndSettings(tank)
    if not turret or not smoke or not settings then return end

    for i = 1, shellsToFire do
        if not isTankSpamEnabled then return end

        local targetHead = getClosestPlayer()
        if not targetHead then return end

        local origin = smoke.Position
        local targetPos = targetHead.Position
        local direction = (targetPos - origin).Unit

        FireTurret:FireServer(
            tank,
            turret,
            nil,
            nil,
            nil,
            nil,
            { {Workspace[LocalPlayer.Name], turret, Workspace.LocalPartStorage} },
            true
        )

        RegisterTurretHit:FireServer(
            turret,
            smoke,
            tank,
            {
                normal = Vector3.new(0, 1, 0),
                hitPart = targetHead,
                origin = origin,
                hitPoint = targetPos,
                direction = direction
            },
            {
                OverheatCount = settings.OverheatCount or 1,
                CooldownTime = settings.CooldownTime or 10,
                BulletSpread = settings.BulletSpread or 0.05,
                FireRate = settings.FireRate or 18
            }
        )

        shellNumber += 1
    end
end

WarTycoonBox:AddToggle("Tank Spam", {
    Text = "Toggle Tank Spam",
    Default = false,
    Tooltip = "using silent aim fov",
    Callback = function(value)
        isTankSpamEnabled = value
    end,
})
:AddKeyPicker("Tank Spam Key", {
    Default = "Q",
    SyncToggleState = true,
    Mode = "Toggle",
    Text = "Tank Spam Key",
    Tooltip = "Toggle Tank Spam",
    Callback = function()
        if isTankSpamEnabled then
            startTankSpam()
        end
    end,
})

WarTycoonBox:AddSlider("Shell Count", {
    Text = "Shells per Spam",
    Default = 1,
    Min = 1,
    Max = 500,
    Rounding = 0,
    Tooltip = "Adjust how many shells to fire at once.",
    Callback = function(value)
        shellsToFire = math.floor(value)
    end,
})

WarTycoonBox:AddSlider("Spam Speed", {
    Text = "Spam Speed",
    Default = 1,
    Min = 0.01,
    Max = 5,
    Rounding = 2,
    Tooltip = "Adjust the speed of Tank spam.",
    Callback = function(value)
        spamSpeed = value
    end,
})

RunService.Heartbeat:Connect(function()
    if isTankSpamEnabled then
        task.wait(math.max(0.01, 1 / spamSpeed))
        startTankSpam()
    end
end)

local WarTycoonDead = ExploitTab:AddLeftGroupbox("Tank/Vehicle modifier")
local properties = {"FireRate","OverHeatCount","ColdownTime","DepleteDelay","OverheatIncrement","BulletSpeed"}

local selectedProperty = properties[1]
local propertyValue = 0

local propertyDropdown = WarTycoonDead:AddDropdown("PropertyDropdown", {
    Values = properties,
    Default = selectedProperty,
    Multi = false,
    Text = "Select Property"
})
propertyDropdown:OnChanged(function(value)
    selectedProperty = value
end)

local valueInput = WarTycoonDead:AddInput('ValueInput', {
    Text='Value',
    Default="0",
    Tooltip='Enter value'
})
valueInput:OnChanged(function(value)
    local num = tonumber(value)
    if num then
        propertyValue = num
    end
end)

function getNearestVehicle()
    if not (LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart")) then return nil end
    local playerPos = LocalPlayer.Character.HumanoidRootPart.Position
    local vehicleWorkspaces = {
        Workspace["Game Systems"]:FindFirstChild("Vehicle Workspace"),
        Workspace["Game Systems"]:FindFirstChild("Tank Workspace"),
		workspace["Game Systems"]:FindFirstChild("Plane Workspace")
    }
    local shortestDist = math.huge
    local nearest = nil
    for _, ws in pairs(vehicleWorkspaces) do
        if ws then
            for _, v in pairs(ws:GetChildren()) do
                if v:IsA("Model") then
                    local posPart = v:FindFirstChildWhichIsA("BasePart")
                    if posPart then
                        local dist = (posPart.Position - playerPos).Magnitude
                        if dist < shortestDist then
                            shortestDist = dist
                            nearest = v
                        end
                    end
                end
            end
        end
    end
    return nearest
end

function findAllSettingsModules(vehicle)
    local settingsModules = {}
    if not vehicle then return settingsModules end
    
    local function searchForSettingsModules(object)
        if object:IsA("ModuleScript") and object.Name == "Settings" then
            table.insert(settingsModules, object)
        end
        for _, child in pairs(object:GetChildren()) do
            searchForSettingsModules(child)
        end
    end
    
    searchForSettingsModules(vehicle)
    return settingsModules
end

function modifyAllVehicleSettings()
    local vehicle = getNearestVehicle()
    if not vehicle then return end
    
    local settingsModules = findAllSettingsModules(vehicle)
    if #settingsModules == 0 then return end
    
    for _, settingsModule in pairs(settingsModules) do
        pcall(function()
            local settingsTable = require(settingsModule)
            if type(settingsTable) == "table" and settingsTable[selectedProperty] ~= nil then
                settingsTable[selectedProperty] = propertyValue
            end
        end)
    end
end

WarTycoonDead:AddButton('APPLY PROPERTY', modifyAllVehicleSettings)

local targetStrafe = GeneralTab:AddLeftGroupbox("Target Strafe")
local strafeEnabled = false
local strafeAllowed = true
local strafeSpeed, strafeRadius = 50, 5
local strafeMode, targetPlayer = "Horizontal", nil
local originalCameraMode = nil

local function startTargetStrafe()
    if not strafeAllowed then return end
    targetPlayer = getClosestPlayer()
    if targetPlayer and targetPlayer.Parent then
        originalCameraMode = game:GetService("Players").LocalPlayer.CameraMode
        game:GetService("Players").LocalPlayer.CameraMode = Enum.CameraMode.Classic
        local targetPos = targetPlayer.Position
        LocalPlayer.Character:SetPrimaryPartCFrame(CFrame.new(targetPos))
        Camera.CameraSubject = targetPlayer.Parent:FindFirstChild("Humanoid")
    end
end

local function strafeAroundTarget()
    if not (strafeAllowed and targetPlayer and targetPlayer.Parent) then return end
    local targetPos = targetPlayer.Position
    local angle = tick() * (strafeSpeed / 10)
    local offset = strafeMode == "Horizontal"
        and Vector3.new(math.cos(angle) * strafeRadius, 0, math.sin(angle) * strafeRadius)
        or Vector3.new(math.cos(angle) * strafeRadius, strafeRadius, math.sin(angle) * strafeRadius)
    LocalPlayer.Character:SetPrimaryPartCFrame(CFrame.new(targetPos + offset))
    LocalPlayer.Character.HumanoidRootPart.CFrame = CFrame.new(LocalPlayer.Character.HumanoidRootPart.Position, targetPos)
end

local function stopTargetStrafe()
    game:GetService("Players").LocalPlayer.CameraMode = originalCameraMode or Enum.CameraMode.Classic
    Camera.CameraSubject = LocalPlayer.Character.Humanoid
    strafeEnabled, targetPlayer = false, nil
end


targetStrafe:AddToggle("strafeControlToggle", {
    Text = "Enable/Disable",
    Default = true,
    Tooltip = "Enable or disable the ability to use Target Strafe.",
    Callback = function(value)
        strafeAllowed = value
        if not strafeAllowed and strafeEnabled then
            stopTargetStrafe()
        end
    end
})

targetStrafe:AddToggle("strafeToggle", {
    Text = "Enable Target Strafe",
    Default = false,
    Tooltip = "Enable or disable Target Strafe.",
    Callback = function(value)
        if strafeAllowed then
            strafeEnabled = value
            if strafeEnabled then startTargetStrafe() else stopTargetStrafe() end
        end
    end
}):AddKeyPicker("strafeToggleKey", {
    Default = "L",
    SyncToggleState = true,
    Mode = "Toggle",
    Text = "Target Strafe Toggle Key",
    Tooltip = "Key to toggle Target Strafe",
    Callback = function(value)
        if strafeAllowed then
            strafeEnabled = value
            if strafeEnabled then startTargetStrafe() else stopTargetStrafe() end
        end
    end
})

targetStrafe:AddDropdown("strafeModeDropdown", {
    AllowNull = false,
    Text = "Target Strafe Mode",
    Default = "Horizontal",
    Values = {"Horizontal", "UP"},
    Tooltip = "Select the strafing mode.",
    Callback = function(value) strafeMode = value end
})

targetStrafe:AddSlider("strafeRadiusSlider", {
    Text = "Strafe Radius",
    Default = 5,
    Min = 1,
    Max = 20,
    Rounding = 1,
    Tooltip = "Set the radius of movement around the target.",
    Callback = function(value) strafeRadius = value end
})

targetStrafe:AddSlider("strafeSpeedSlider", {
    Text = "Strafe Speed",
    Default = 50,
    Min = 10,
    Max = 200,
    Rounding = 1,
    Tooltip = "Set the speed of strafing around the target.",
    Callback = function(value) strafeSpeed = value end
})

game:GetService("RunService").RenderStepped:Connect(function()
    if strafeEnabled and strafeAllowed then strafeAroundTarget() end
end)

while true do
    task.wait()

    if isFunctionalityEnabled then
        if localPlayer.Character and localPlayer.Character:FindFirstChild("HumanoidRootPart") then
            humanoid = localPlayer.Character:FindFirstChild("Humanoid")
            
            if isSpeedActive and humanoid and humanoid.MoveDirection.Magnitude > 0 then
                local moveDirection = humanoid.MoveDirection.Unit
                localPlayer.Character.HumanoidRootPart.CFrame = localPlayer.Character.HumanoidRootPart.CFrame + moveDirection * Cmultiplier
            end

            if isFlyActive then
                local flyDirection = Vector3.zero

                if game:GetService("UserInputService"):IsKeyDown(Enum.KeyCode.W) then
                    flyDirection = flyDirection + camera.CFrame.LookVector
                end
                if game:GetService("UserInputService"):IsKeyDown(Enum.KeyCode.S) then
                    flyDirection = flyDirection - camera.CFrame.LookVector
                end
                if game:GetService("UserInputService"):IsKeyDown(Enum.KeyCode.A) then
                    flyDirection = flyDirection - camera.CFrame.RightVector
                end
                if game:GetService("UserInputService"):IsKeyDown(Enum.KeyCode.D) then
                    flyDirection = flyDirection + camera.CFrame.RightVector
                end

                if flyDirection.Magnitude > 0 then
                    flyDirection = flyDirection.Unit
                end

                local newPosition = localPlayer.Character.HumanoidRootPart.Position + flyDirection * flySpeed
                localPlayer.Character.HumanoidRootPart.CFrame = CFrame.new(newPosition)
                localPlayer.Character.HumanoidRootPart.Velocity = Vector3.new(0, 0, 0)
            end

            if isNoClipActive then
                for _, v in pairs(localPlayer.Character:GetDescendants()) do
                    if v:IsA("BasePart") and v.CanCollide then
                        v.CanCollide = false
                    end
                end
            end
        end
    end
end

ThemeManager:LoadDefaultTheme()