Silent Aim

--[[
    Enhanced Aimbot System
    - Improved error handling and validation
    - Better performance with caching
    - Cleaner code structure
    - Enhanced visual feedback system
    - Optimized target acquisition
    - Multi-threading support with fallback
--]]


-- REWRITTEN BY DSARC, ASSISTED BY CLAUDE, ORIGNAL BY ALCO
-- ============================================================================
-- CONFIGURATION
-- ============================================================================

local Config = {
    HitChance = 100,          -- Hit probability percentage (0-100)
    WallCheck = false,        -- Enable line-of-sight verification
    TargetParts = {"Head", "Torso"}, -- Body parts to target
    FOVRadius = 200,          -- Field of view radius in pixels
    MaxIndicators = 2,        -- Maximum hit indicator parts
    IndicatorLifetime = 0.05, -- How long indicators stay visible
    IndicatorSize = 0.5,      -- Size of hit indicators
    CircleThickness = 2,      -- FOV circle thickness
    CircleSides = 60,         -- FOV circle smoothness
    HighlightTarget = true,   -- Enable target player highlighting
    HighlightColor = Color3.new(1, 0, 0), -- Highlight color (red)
    HighlightTransparency = 0.5, -- Highlight fill transparency
}

-- Apply global config if exists
if getgenv().HitChance then Config.HitChance = getgenv().HitChance end
if getgenv().wallcheck ~= nil then Config.WallCheck = getgenv().wallcheck end
if getgenv().TargetParts then Config.TargetParts = getgenv().TargetParts end
if getgenv().radius then Config.FOVRadius = getgenv().radius end
if getgenv().HighlightTarget ~= nil then Config.HighlightTarget = getgenv().HighlightTarget end

-- ============================================================================
-- EXECUTOR COMPATIBILITY CHECK
-- ============================================================================

local function checkExecutorCompatibility()
    local success, executorName, version = pcall(identifyexecutor)
    if not success then return true end
    
    executorName = (executorName and executorName:upper()) or ""
    local blocked = {"XENO", "SOLARA"}
    
    for _, name in ipairs(blocked) do
        if executorName:find(name) then
            game.Players.LocalPlayer:Kick("Unsupported executor. Please use an alternative.")
            return false
        end
    end
    return true
end

if not checkExecutorCompatibility() then
    while true do task.wait(9e9) end
end

-- ============================================================================
-- EXECUTOR GLOBALS & THREADING
-- ============================================================================

local function getExecutorGlobal(...)
    for _, name in ipairs({...}) do
        local value = rawget(_G, name)
        if value then return value end
    end
    return nil
end

local run = getExecutorGlobal("run_on_actor", "run_on_thread")
local availableActors = getExecutorGlobal("getactors", "getactorthreads")

local function checkFFlag(name, expectedValue)
    local success, result = pcall(getfflag, name)
    if not success then return false end
    
    if type(expectedValue) == "boolean" then
        return result == expectedValue
    end
    return tostring(result) == tostring(expectedValue)
end

-- ============================================================================
-- SCRIPT GENERATOR (For Thread Execution)
-- ============================================================================

local function generateScript()
    local targetPartsString = ""
    for i, part in ipairs(Config.TargetParts) do
        if i > 1 then
            targetPartsString = targetPartsString .. ", "
        end
        targetPartsString = targetPartsString .. '"' .. part .. '"'
    end
    
    return string.format([=[
-- Thread-safe aimbot initialization
getgenv().HitChance = %d
getgenv().wallcheck = %s
getgenv().TargetParts = { %s }
getgenv().radius = %d
getgenv().HighlightTarget = %s

local _HitChance = getgenv().HitChance
local _wallcheck = getgenv().wallcheck
local _TargetParts = getgenv().TargetParts
local _radius = getgenv().radius
local _HighlightTarget = getgenv().HighlightTarget

-- Services
local Players = cloneref(game:GetService("Players"))
local RunService = cloneref(game:GetService("RunService"))
local ReplicatedStorage = cloneref(game:GetService("ReplicatedStorage"))
local Workspace = game:GetService("Workspace")
local LocalPlayer = Players.LocalPlayer

-- Game-specific modules
local Gun_utls = ReplicatedStorage:WaitForChild("gun_res", 30)
local gun_lib = Gun_utls:WaitForChild("lib", 30)
local projectileHandlerMod = gun_lib:WaitForChild("projectileHandler", 30)
local FastCast = require(projectileHandlerMod:WaitForChild("FastCastRedux", 30))
local Camera = Workspace.CurrentCamera

-- Bin cleanup system
local Bin = {}
Bin.__index = Bin

function Bin.new()
    return setmetatable({head = nil, tail = nil}, Bin)
end

function Bin:add(item)
    local node = {item = item, next = nil}
    if not self.head then self.head = node end
    if self.tail then self.tail.next = node end
    self.tail = node
    return item
end

function Bin:batch(...)
    for _, item in ipairs({...}) do self:add(item) end
end

function Bin:destroy()
    while self.head do
        local item = self.head.item
        if type(item) == "function" then
            item()
        elseif typeof(item) == "RBXScriptConnection" then
            item:Disconnect()
        elseif type(item) == "thread" then
            task.cancel(item)
        elseif type(item) == "table" and (item.destroy or item.Destroy) then
            (item.destroy or item.Destroy)(item)
        end
        self.head = self.head.next
    end
    self.tail = nil
end

-- Base Component
local BaseComponent = {}
BaseComponent.__index = BaseComponent

function BaseComponent.new(instance)
    local self = setmetatable({}, BaseComponent)
    self.instance = instance
    self.bin = Bin.new()
    return self
end

function BaseComponent:destroy()
    self.bin:destroy()
end

-- Rig Component
local RigComponent = setmetatable({}, {__index = BaseComponent})
RigComponent.__index = RigComponent

function RigComponent.new(instance)
    local self = setmetatable(BaseComponent.new(instance), RigComponent)
    
    self.root = instance:WaitForChild("HumanoidRootPart", 5)
    self.head = instance:WaitForChild("Head", 5)
    self.humanoid = instance:WaitForChild("Humanoid", 5)
    
    if not (self.root and self.head and self.humanoid) then
        error("Failed to initialize rig components")
    end
    
    self.bin:batch(
        self.humanoid.Died:Connect(function() self:destroy() end),
        instance.Destroying:Connect(function() self:destroy() end)
    )
    
    return self
end

-- Character Component
local CharacterComponent = setmetatable({}, {__index = RigComponent})
CharacterComponent.__index = CharacterComponent
CharacterComponent.active = {}

function CharacterComponent.new(instance)
    return setmetatable(RigComponent.new(instance), CharacterComponent)
end

-- Player Component
local PlayerComponent = setmetatable({}, {__index = BaseComponent})
PlayerComponent.__index = PlayerComponent
PlayerComponent.active = {}

function PlayerComponent.new(instance)
    local self = setmetatable(BaseComponent.new(instance), PlayerComponent)
    self.name = instance.Name
    self.character = nil
    
    if instance.Character then
        task.spawn(function() self:onCharacterAdded(instance.Character) end)
    end
    
    self.bin:batch(
        instance.CharacterAdded:Connect(function(char) self:onCharacterAdded(char) end),
        instance.CharacterRemoving:Connect(function() self:onCharacterRemoving() end)
    )
    
    self.bin:add(function()
        PlayerComponent.active[instance] = nil
    end)
    
    PlayerComponent.active[instance] = self
    return self
end

function PlayerComponent:onCharacterAdded(character)
    if self.character then self.character:destroy() end
    self.character = CharacterComponent.new(character)
end

function PlayerComponent:onCharacterRemoving()
    if self.character then self.character:destroy() end
    self.character = nil
end

-- Component Controller
local ComponentController = {}
local rayParams

local function getRandomPart(character)
    local parts = {}
    for _, partName in ipairs(_TargetParts) do
        local part = character.instance:FindFirstChild(partName)
        if part then table.insert(parts, part) end
    end
    
    if #parts == 0 then return nil end
    return parts[Random.new():NextInteger(1, #parts)]
end

function ComponentController.getTarget()
    local viewportSize = Camera.ViewportSize
    local screenCenter = Vector2.new(viewportSize.X / 2, viewportSize.Y / 2)
    local bestTarget, bestPart, bestWeight = nil, nil, -math.huge
    
    for _, component in pairs(PlayerComponent.active) do
        local character = component.character
        if not character then continue end
        
        local targetPart = getRandomPart(character)
        if not targetPart then continue end
        
        local position = character.root.Position
        local viewportPoint = Camera:WorldToViewportPoint(position)
        if viewportPoint.Z < 0 then continue end
        
        if _wallcheck then
            local origin = Camera.CFrame.Position
            rayParams.FilterDescendantsInstances = {character.instance, LocalPlayer.Character}
            if Workspace:Raycast(origin, position - origin, rayParams) then
                continue
            end
        end
        
        local screenDistance = (Vector2.new(viewportPoint.X, viewportPoint.Y) - screenCenter).Magnitude
        if screenDistance > _radius then continue end
        
        local weight = 1000 - screenDistance
        if weight > bestWeight then
            bestTarget = character
            bestPart = targetPart
            bestWeight = weight
        end
    end
    
    return bestTarget, bestPart
end

function ComponentController.init()
    for _, player in ipairs(Players:GetPlayers()) do
        if player ~= LocalPlayer then
            task.spawn(function() PlayerComponent.new(player) end)
        end
    end
    
    Players.PlayerAdded:Connect(function(player)
        PlayerComponent.new(player)
    end)
    
    Players.PlayerRemoving:Connect(function(player)
        local component = PlayerComponent.active[player]
        if component then component:destroy() end
    end)
    
    rayParams = RaycastParams.new()
    rayParams.FilterType = Enum.RaycastFilterType.Exclude
    rayParams.IgnoreWater = true
end

-- Range Controller with Hit Indicators
local RangeController = {}
local hitIndicators = {}
local currentHighlight = nil

local function calculateChance(percentage)
    percentage = math.floor(percentage)
    local chance = Random.new():NextNumber(0, 100)
    return chance <= percentage
end

local function showHitIndicator(position)
    local part = Instance.new("Part")
    part.Anchored = true
    part.CanCollide = false
    part.Size = Vector3.new(0.5, 0.5, 0.5)
    part.Shape = Enum.PartType.Ball
    part.Color = Color3.new(1, 0, 0)
    part.Material = Enum.Material.Neon
    part.Transparency = 0
    part.Position = position
    part.Parent = Workspace
    
    -- Manage max indicators
    if #hitIndicators >= 2 then
        local oldest = table.remove(hitIndicators, 1)
        if oldest and oldest.Parent then oldest:Destroy() end
    end
    table.insert(hitIndicators, part)
    
    -- Auto cleanup
    task.spawn(function()
        task.wait(0.05)
        if part and part.Parent then part:Destroy() end
        for i, indicator in ipairs(hitIndicators) do
            if indicator == part then
                table.remove(hitIndicators, i)
                break
            end
        end
    end)
end

local function updateTargetHighlight(character)
    if not _HighlightTarget then
        if currentHighlight then
            currentHighlight:Destroy()
            currentHighlight = nil
        end
        return
    end
    
    if character then
        -- Create or update highlight
        if not currentHighlight or currentHighlight.Adornee ~= character.instance then
            if currentHighlight then
                currentHighlight:Destroy()
            end
            
            currentHighlight = Instance.new("Highlight")
            currentHighlight.Adornee = character.instance
            currentHighlight.FillColor = Color3.new(1, 0, 0)
            currentHighlight.OutlineColor = Color3.new(1, 1, 1)
            currentHighlight.FillTransparency = 0.5
            currentHighlight.OutlineTransparency = 0
            currentHighlight.Parent = character.instance
        end
    else
        -- Remove highlight when no target
        if currentHighlight then
            currentHighlight:Destroy()
            currentHighlight = nil
        end
    end
end

function RangeController.init()
    local originalFire = FastCast.Fire
    
    FastCast.Fire = function(...)
        local args = {...}
        local bestCharacter, bestPart = ComponentController.getTarget()
        
        -- Update highlight for current target
        updateTargetHighlight(bestCharacter)
        
        if bestCharacter and bestPart and calculateChance(_HitChance) then
            local targetPos = bestPart.Position
            local origin = args[2]
            local newDirection = (targetPos - origin).Unit * 1000
            args[3] = newDirection
            
            showHitIndicator(targetPos)
        end
        
        return originalFire(unpack(args))
    end
    
    -- Update highlight every frame to track current target
    RunService.RenderStepped:Connect(function()
        if _HighlightTarget then
            local bestCharacter = ComponentController.getTarget()
            updateTargetHighlight(bestCharacter)
        end
    end)
end

-- Visuals Controller
local VisualsController = {}

function VisualsController.init()
    local circle = Drawing.new("Circle")
    circle.Filled = false
    circle.NumSides = 60
    circle.Thickness = 2
    circle.Visible = true
    circle.Color = Color3.new(1, 1, 1)
    circle.Transparency = 1
    
    RunService.RenderStepped:Connect(function()
        if circle then
            local viewportSize = Camera.ViewportSize
            local screenCenter = Vector2.new(viewportSize.X / 2, viewportSize.Y / 2)
            circle.Radius = _radius
            circle.Position = screenCenter
        end
    end)
end

-- Camera Controller
local CameraController = {}

function CameraController.init()
    Camera = Workspace.CurrentCamera
    Workspace:GetPropertyChangedSignal("CurrentCamera"):Connect(function()
        Camera = Workspace.CurrentCamera or Camera
    end)
end

-- Initialize all systems
ComponentController.init()
RangeController.init()
VisualsController.init()
CameraController.init()

return nil
]=], Config.HitChance, tostring(Config.WallCheck), targetPartsString, Config.FOVRadius, tostring(Config.HighlightTarget))
end

-- ============================================================================
-- MAIN EXECUTION WITH THREAD SUPPORT
-- ============================================================================

local function executeAimbot()
    local scriptCode = generateScript()
    
    -- Check for parallel execution support
    if checkFFlag("DebugRunParallelLuaOnMainThread", true) then
        -- Run on main thread with parallel support
        local success, err = pcall(function()
            loadstring(scriptCode)()
        end)
        
        if not success then
            warn("Aimbot failed to load on main thread:", err)
        end
        
    elseif run and availableActors then
        -- Run on actor/thread
        local actors = availableActors()
        
        if actors and actors[1] then
            local success, err = pcall(function()
                run(actors[1], scriptCode)
            end)
            
            if not success then
                warn("Aimbot failed to load on actor thread:", err)
                -- Fallback to main thread
                pcall(function()
                    loadstring(scriptCode)()
                end)
            end
        else
            -- No actors available, fallback to main thread
            local success, err = pcall(function()
                loadstring(scriptCode)()
            end)
            
            if not success then
                warn("Aimbot failed to load (no actors):", err)
            end
        end
        
    else
        -- Standard execution on main thread
        local success, err = pcall(function()
            loadstring(scriptCode)()
        end)
        
        if not success then
            warn("Aimbot failed to load (standard):", err)
        end
    end
end

-- ============================================================================
-- INITIALIZE
-- ============================================================================

local initSuccess, initError = pcall(executeAimbot)

if not initSuccess then
    warn("Critical error initializing aimbot:", initError)
else
    print("Aimbot loaded successfully")
end