[keyless] rainbow aimbot

-- 🌈 RAINBOW AIMBOT

-- Load Rayfield UI Library
local Rayfield = loadstring(game:HttpGet('https://sirius.menu/rayfield'))()

-- Services
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local Workspace = game:GetService("Workspace")

-- Variables
local LocalPlayer = Players.LocalPlayer
local Mouse = LocalPlayer:GetMouse()
local Camera = Workspace.CurrentCamera

-- Aimbot Settings
local Settings = {
    -- Main
    Enabled = false,
    TargetPart = "Head",
    VisibilityCheck = true,
    
    -- ESP
    ESPEnabled = false,
    ESPBoxes = true,
    ESPNames = true,
    ESPDistance = true,
    ESPHealth = true,
    ESPColor = Color3.fromRGB(255, 255, 255),
    ESPTeamColor = false,
    
    -- FOV
    FOV = 300,
    ShowFOV = true,
    RainbowFOV = true,
    FOVColor = Color3.fromRGB(255, 0, 0),
    RainbowSpeed = 5,
    
    -- Smoothness & Power
    Smoothness = 0.7,
    InstantLock = false,
    PredictMovement = true,
    PredictionStrength = 0.15,
    
    -- Sticky Aim
    StickyAim = true,
    StickyStrength = 0.3,
    
    -- Trigger Bot
    TriggerBot = false,
    TriggerDelay = 0,
    
    -- Aim Key
    AimKey = Enum.KeyCode.Q, -- Q button to aim
    
    -- Advanced
    IgnoreDistance = false,
    MaxDistance = 1000,
    AutoShoot = false,
    ShootDelay = 0.1,
}

-- Target Management
local CurrentTarget = nil
local LastTargetTime = 0
local TargetLockDuration = 2

-- Rainbow Variables
local RainbowHue = 0

-- ESP Storage
local ESPObjects = {}

-- FOV Circle
local FOVCircle = Drawing.new("Circle")
FOVCircle.Thickness = 2
FOVCircle.NumSides = 100
FOVCircle.Radius = Settings.FOV
FOVCircle.Filled = false
FOVCircle.Visible = Settings.ShowFOV
FOVCircle.Color = Color3.fromRGB(255, 0, 0)
FOVCircle.Transparency = 1
FOVCircle.ZIndex = 999

-- Target Indicator
local TargetIndicator = Drawing.new("Circle")
TargetIndicator.Thickness = 3
TargetIndicator.NumSides = 50
TargetIndicator.Radius = 10
TargetIndicator.Filled = false
TargetIndicator.Visible = false
TargetIndicator.Color = Color3.fromRGB(0, 255, 0)
TargetIndicator.Transparency = 1
TargetIndicator.ZIndex = 1000

-- Rainbow Color Function
local function GetRainbowColor()
    RainbowHue = RainbowHue + (Settings.RainbowSpeed * 0.001)
    if RainbowHue >= 1 then
        RainbowHue = 0
    end
    return Color3.fromHSV(RainbowHue, 1, 1)
end

-- Create Rayfield Window
local Window = Rayfield:CreateWindow({
    Name = "🌈 RAINBOW AIMBOT",
    LoadingTitle = "Loading Rainbow Aimbot",
    LoadingSubtitle = "by Claude",
    ConfigurationSaving = {
        Enabled = true,
        FolderName = nil,
        FileName = "RainbowAimbotConfig"
    },
    Discord = {
        Enabled = false,
    },
    KeySystem = false
})

-- Main Tab
local MainTab = Window:CreateTab("Main", 4483362458)

-- Main Section
MainTab:CreateSection("Main Settings")

local EnableToggle = MainTab:CreateToggle({
    Name = "Enable Aimbot",
    CurrentValue = false,
    Flag = "AimbotEnabled",
    Callback = function(Value)
        Settings.Enabled = Value
        Rayfield:Notify({
            Title = "Aimbot",
            Content = Value and "🎯 AIMBOT ACTIVATED" or "Aimbot Disabled",
            Duration = 2,
            Image = 4483362458,
        })
    end,
})

local TargetDropdown = MainTab:CreateDropdown({
    Name = "Target Part",
    Options = {"Head", "HumanoidRootPart", "Torso", "UpperTorso", "LowerTorso"},
    CurrentOption = {"Head"},
    MultipleOptions = false,
    Flag = "TargetPart",
    Callback = function(Option)
        Settings.TargetPart = Option[1]
    end,
})

local InstantLockToggle = MainTab:CreateToggle({
    Name = "Instant Lock (No Smoothing)",
    CurrentValue = false,
    Flag = "InstantLock",
    Callback = function(Value)
        Settings.InstantLock = Value
        Settings.Smoothness = Value and 1 or 0.7
    end,
})

local VisibilityToggle = MainTab:CreateToggle({
    Name = "Visibility Check (Only Visible Players)",
    CurrentValue = true,
    Flag = "VisibilityCheck",
    Callback = function(Value)
        Settings.VisibilityCheck = Value
    end,
})

MainTab:CreateSection("Controls")

MainTab:CreateParagraph({
    Title = "Aim Key",
    Content = "Press Q to toggle aimbot ON/OFF"
})

-- ESP Tab
local ESPTab = Window:CreateTab("ESP", 4483362458)

ESPTab:CreateSection("ESP Settings")

local ESPToggle = ESPTab:CreateToggle({
    Name = "Enable ESP",
    CurrentValue = false,
    Flag = "ESPEnabled",
    Callback = function(Value)
        Settings.ESPEnabled = Value
        if not Value then
            -- Clear all ESP
            for _, espData in pairs(ESPObjects) do
                if espData.Box then espData.Box:Remove() end
                if espData.Name then espData.Name:Remove() end
                if espData.Distance then espData.Distance:Remove() end
                if espData.Health then espData.Health:Remove() end
                if espData.HealthBar then espData.HealthBar:Remove() end
                if espData.HealthBarOutline then espData.HealthBarOutline:Remove() end
            end
            ESPObjects = {}
        end
    end,
})

local ESPBoxToggle = ESPTab:CreateToggle({
    Name = "Show Boxes",
    CurrentValue = true,
    Flag = "ESPBoxes",
    Callback = function(Value)
        Settings.ESPBoxes = Value
    end,
})

local ESPNameToggle = ESPTab:CreateToggle({
    Name = "Show Names",
    CurrentValue = true,
    Flag = "ESPNames",
    Callback = function(Value)
        Settings.ESPNames = Value
    end,
})

local ESPDistanceToggle = ESPTab:CreateToggle({
    Name = "Show Distance",
    CurrentValue = true,
    Flag = "ESPDistance",
    Callback = function(Value)
        Settings.ESPDistance = Value
    end,
})

local ESPHealthToggle = ESPTab:CreateToggle({
    Name = "Show Health Bar",
    CurrentValue = true,
    Flag = "ESPHealth",
    Callback = function(Value)
        Settings.ESPHealth = Value
    end,
})

local ESPTeamColorToggle = ESPTab:CreateToggle({
    Name = "Team Color ESP",
    CurrentValue = false,
    Flag = "ESPTeamColor",
    Callback = function(Value)
        Settings.ESPTeamColor = Value
    end,
})

local ESPColorPicker = ESPTab:CreateColorPicker({
    Name = "ESP Color",
    Color = Color3.fromRGB(255, 255, 255),
    Flag = "ESPColor",
    Callback = function(Value)
        Settings.ESPColor = Value
    end
})

-- Trigger Bot Tab
local TriggerTab = Window:CreateTab("Auto Features", 4483362458)

TriggerTab:CreateSection("Trigger Bot")

local TriggerBotToggle = TriggerTab:CreateToggle({
    Name = "Enable Trigger Bot",
    CurrentValue = false,
    Flag = "TriggerBot",
    Callback = function(Value)
        Settings.TriggerBot = Value
    end,
})

local TriggerDelaySlider = TriggerTab:CreateSlider({
    Name = "Trigger Delay",
    Range = {0, 500},
    Increment = 10,
    Suffix = "ms",
    CurrentValue = 0,
    Flag = "TriggerDelay",
    Callback = function(Value)
        Settings.TriggerDelay = Value / 1000
    end,
})

TriggerTab:CreateSection("Auto Shoot")

local AutoShootToggle = TriggerTab:CreateToggle({
    Name = "Auto Shoot When Locked",
    CurrentValue = false,
    Flag = "AutoShoot",
    Callback = function(Value)
        Settings.AutoShoot = Value
    end,
})

local ShootDelaySlider = TriggerTab:CreateSlider({
    Name = "Shoot Delay",
    Range = {0, 1000},
    Increment = 10,
    Suffix = "ms",
    CurrentValue = 100,
    Flag = "ShootDelay",
    Callback = function(Value)
        Settings.ShootDelay = Value / 1000
    end,
})

-- Visual Tab
local VisualTab = Window:CreateTab("Visuals", 4483362458)

VisualTab:CreateSection("FOV Circle")

local ShowFOVToggle = VisualTab:CreateToggle({
    Name = "Show FOV Circle",
    CurrentValue = true,
    Flag = "ShowFOV",
    Callback = function(Value)
        Settings.ShowFOV = Value
        FOVCircle.Visible = Value
    end,
})

local RainbowFOVToggle = VisualTab:CreateToggle({
    Name = "🌈 Rainbow FOV Circle",
    CurrentValue = true,
    Flag = "RainbowFOV",
    Callback = function(Value)
        Settings.RainbowFOV = Value
        if not Value then
            FOVCircle.Color = Settings.FOVColor
        end
    end,
})

local RainbowSpeedSlider = VisualTab:CreateSlider({
    Name = "Rainbow Speed",
    Range = {0.1, 5},
    Increment = 0.1,
    Suffix = "x",
    CurrentValue = 5,
    Flag = "RainbowSpeed",
    Callback = function(Value)
        Settings.RainbowSpeed = Value
    end,
})

local FOVColorPicker = VisualTab:CreateColorPicker({
    Name = "FOV Circle Color (Non-Rainbow)",
    Color = Color3.fromRGB(255, 0, 0),
    Flag = "FOVColor",
    Callback = function(Value)
        Settings.FOVColor = Value
        if not Settings.RainbowFOV then
            FOVCircle.Color = Value
        end
    end
})

VisualTab:CreateSection("Target Indicator")

VisualTab:CreateParagraph({
    Title = "Rainbow Target Indicator",
    Content = "The circle that appears on locked targets also has rainbow effect!"
})

-- Info Tab
local InfoTab = Window:CreateTab("Info", 4483362458)

InfoTab:CreateSection("How to Use")

InfoTab:CreateParagraph({
    Title = "Instructions",
    Content = "1. Press Q to toggle aimbot ON/OFF\n2. Only locks on VISIBLE players (no walls!)\n3. Enable ESP in the ESP tab\n4. Use Instant Lock for instant snap\n5. Rivals-style magnetic aim assist!\n6. Works in Shift Lock & First Person!"
})

InfoTab:CreateParagraph({
    Title = "Features",
    Content = "• Rivals-Style Magnetic Aim (Stronger!)\n• Visibility Check = Only visible targets\n• Instant Lock = Pure instant snap\n• Trigger Bot = Auto shoots when aimed\n• Auto Shoot = Shoots when locked on\n• ESP = See all players through walls\n• 🌈 RAINBOW FOV = Epic visual style!"
})

-- Helper Functions
local function GetCharacter(player)
    return player and player.Character
end

local function GetHumanoid(character)
    return character and character:FindFirstChildOfClass("Humanoid")
end

local function GetRootPart(character)
    return character and character:FindFirstChild("HumanoidRootPart")
end

local function GetTargetPart(character)
    if not character then return nil end
    
    local part = character:FindFirstChild(Settings.TargetPart)
    
    if not part then
        part = character:FindFirstChild("HumanoidRootPart")
    end
    
    if not part then
        part = character:FindFirstChild("Head")
    end
    
    return part
end

local function IsAlive(player)
    local character = GetCharacter(player)
    if not character then return false end
    
    local humanoid = GetHumanoid(character)
    if not humanoid then return false end
    
    return humanoid.Health > 0
end

local function IsValidTarget(player)
    if player == LocalPlayer then
        return false
    end
    
    if not IsAlive(player) then
        return false
    end
    
    return true
end

local function GetDistance(part1, part2)
    return (part1.Position - part2.Position).Magnitude
end

local function IsVisible(targetPart)
    if not Settings.VisibilityCheck then
        return true
    end
    
    if not targetPart then
        return false
    end
    
    local character = GetCharacter(LocalPlayer)
    if not character then return false end
    
    local head = character:FindFirstChild("Head")
    if not head then return false end
    
    local origin = Camera.CFrame.Position
    local direction = (targetPart.Position - origin)
    
    local raycastParams = RaycastParams.new()
    raycastParams.FilterType = Enum.RaycastFilterType.Exclude
    raycastParams.FilterDescendantsInstances = {character}
    raycastParams.IgnoreWater = true
    
    local result = Workspace:Raycast(origin, direction, raycastParams)
    
    if result then
        local hitPart = result.Instance
        if hitPart:IsDescendantOf(targetPart.Parent) then
            return true
        end
        return false
    end
    
    return true
end

local function PredictPosition(targetPart)
    if not Settings.PredictMovement then
        return targetPart.Position
    end
    
    local velocity = targetPart.AssemblyLinearVelocity or targetPart.Velocity or Vector3.new(0, 0, 0)
    local prediction = targetPart.Position + (velocity * Settings.PredictionStrength)
    
    return prediction
end

local function GetClosestPlayerToCursor()
    local closestPlayer = nil
    local shortestDistance = Settings.FOV
    
    -- Get mouse/camera center position
    local mousePos
    if UserInputService.MouseBehavior == Enum.MouseBehavior.LockCenter then
        -- Shift lock or first person - use screen center
        local viewportSize = Camera.ViewportSize
        mousePos = Vector2.new(viewportSize.X / 2, viewportSize.Y / 2)
    else
        -- Normal mode - use mouse location
        mousePos = UserInputService:GetMouseLocation()
    end
    
    for _, player in pairs(Players:GetPlayers()) do
        if IsValidTarget(player) then
            local character = GetCharacter(player)
            local targetPart = GetTargetPart(character)
            
            if targetPart then
                -- Distance check
                if not Settings.IgnoreDistance then
                    local localChar = GetCharacter(LocalPlayer)
                    if localChar then
                        local localRoot = GetRootPart(localChar)
                        if localRoot then
                            local distance = GetDistance(localRoot, targetPart)
                            if distance > Settings.MaxDistance then
                                continue
                            end
                        end
                    end
                end
                
                local screenPoint, onScreen = Camera:WorldToViewportPoint(targetPart.Position)
                
                if onScreen then
                    local distance = (mousePos - Vector2.new(screenPoint.X, screenPoint.Y)).Magnitude
                    
                    if distance < shortestDistance then
                        -- Check if player is visible
                        if IsVisible(targetPart) then
                            shortestDistance = distance
                            closestPlayer = player
                        end
                    end
                end
            end
        end
    end
    
    return closestPlayer
end

local function IsAimbotActive()
    return Settings.Enabled
end

-- ESP Functions
local function CreateESP(player)
    if ESPObjects[player] then return end
    
    local espData = {}
    
    -- Box
    espData.Box = Drawing.new("Square")
    espData.Box.Visible = false
    espData.Box.Color = Settings.ESPColor
    espData.Box.Thickness = 2
    espData.Box.Transparency = 1
    espData.Box.Filled = false
    
    -- Name
    espData.Name = Drawing.new("Text")
    espData.Name.Visible = false
    espData.Name.Color = Settings.ESPColor
    espData.Name.Size = 16
    espData.Name.Center = true
    espData.Name.Outline = true
    espData.Name.Text = player.Name
    
    -- Distance
    espData.Distance = Drawing.new("Text")
    espData.Distance.Visible = false
    espData.Distance.Color = Settings.ESPColor
    espData.Distance.Size = 14
    espData.Distance.Center = true
    espData.Distance.Outline = true
    
    -- Health Bar Outline
    espData.HealthBarOutline = Drawing.new("Square")
    espData.HealthBarOutline.Visible = false
    espData.HealthBarOutline.Color = Color3.fromRGB(0, 0, 0)
    espData.HealthBarOutline.Thickness = 1
    espData.HealthBarOutline.Filled = true
    
    -- Health Bar
    espData.HealthBar = Drawing.new("Square")
    espData.HealthBar.Visible = false
    espData.HealthBar.Color = Color3.fromRGB(0, 255, 0)
    espData.HealthBar.Thickness = 1
    espData.HealthBar.Filled = true
    
    ESPObjects[player] = espData
end

local function UpdateESP(player)
    if not Settings.ESPEnabled then return end
    
    local character = GetCharacter(player)
    if not character then return end
    
    local rootPart = GetRootPart(character)
    local humanoid = GetHumanoid(character)
    
    if not rootPart or not humanoid then return end
    
    local espData = ESPObjects[player]
    if not espData then
        CreateESP(player)
        espData = ESPObjects[player]
    end
    
    local screenPos, onScreen = Camera:WorldToViewportPoint(rootPart.Position)
    
    if onScreen and humanoid.Health > 0 then
        local headPos = Camera:WorldToViewportPoint(character:FindFirstChild("Head").Position + Vector3.new(0, 0.5, 0))
        local legPos = Camera:WorldToViewportPoint(rootPart.Position - Vector3.new(0, 3, 0))
        
        local height = math.abs(headPos.Y - legPos.Y)
        local width = height / 2
        
        -- Determine color
        local espColor = Settings.ESPColor
        if Settings.ESPTeamColor and player.Team then
            espColor = player.Team.TeamColor.Color
        end
        
        -- Box
        if Settings.ESPBoxes then
            espData.Box.Size = Vector2.new(width, height)
            espData.Box.Position = Vector2.new(screenPos.X - width / 2, screenPos.Y - height / 2)
            espData.Box.Color = espColor
            espData.Box.Visible = true
        else
            espData.Box.Visible = false
        end
        
        -- Name
        if Settings.ESPNames then
            espData.Name.Position = Vector2.new(screenPos.X, headPos.Y - 20)
            espData.Name.Color = espColor
            espData.Name.Text = player.Name
            espData.Name.Visible = true
        else
            espData.Name.Visible = false
        end
        
        -- Distance
        if Settings.ESPDistance then
            local localChar = GetCharacter(LocalPlayer)
            if localChar then
                local localRoot = GetRootPart(localChar)
                if localRoot then
                    local distance = math.floor(GetDistance(localRoot, rootPart))
                    espData.Distance.Position = Vector2.new(screenPos.X, legPos.Y + 5)
                    espData.Distance.Color = espColor
                    espData.Distance.Text = tostring(distance) .. " studs"
                    espData.Distance.Visible = true
                end
            end
        else
            espData.Distance.Visible = false
        end
        
        -- Health Bar
        if Settings.ESPHealth then
            local healthPercent = humanoid.Health / humanoid.MaxHealth
            local barWidth = 4
            local barHeight = height
            
            espData.HealthBarOutline.Size = Vector2.new(barWidth + 2, barHeight + 2)
            espData.HealthBarOutline.Position = Vector2.new(screenPos.X - width / 2 - barWidth - 4, screenPos.Y - height / 2 - 1)
            espData.HealthBarOutline.Visible = true
            
            espData.HealthBar.Size = Vector2.new(barWidth, barHeight * healthPercent)
            espData.HealthBar.Position = Vector2.new(screenPos.X - width / 2 - barWidth - 3, screenPos.Y - height / 2 + (barHeight * (1 - healthPercent)))
            espData.HealthBar.Color = Color3.fromRGB(255 * (1 - healthPercent), 255 * healthPercent, 0)
            espData.HealthBar.Visible = true
        else
            espData.HealthBarOutline.Visible = false
            espData.HealthBar.Visible = false
        end
    else
        -- Hide ESP
        espData.Box.Visible = false
        espData.Name.Visible = false
        espData.Distance.Visible = false
        espData.HealthBar.Visible = false
        espData.HealthBarOutline.Visible = false
    end
end

local function RemoveESP(player)
    local espData = ESPObjects[player]
    if espData then
        if espData.Box then espData.Box:Remove() end
        if espData.Name then espData.Name:Remove() end
        if espData.Distance then espData.Distance:Remove() end
        if espData.Health then espData.Health:Remove() end
        if espData.HealthBar then espData.HealthBar:Remove() end
        if espData.HealthBarOutline then espData.HealthBarOutline:Remove() end
        ESPObjects[player] = nil
    end
end

-- Player Events
Players.PlayerAdded:Connect(function(player)
    if Settings.ESPEnabled then
        CreateESP(player)
    end
end)

Players.PlayerRemoving:Connect(function(player)
    RemoveESP(player)
end)

-- Q Key Toggle
UserInputService.InputBegan:Connect(function(input, gameProcessed)
    if gameProcessed then return end
    
    if input.KeyCode == Enum.KeyCode.Q then
        Settings.Enabled = not Settings.Enabled
        
        Rayfield:Notify({
            Title = "🌈 Rainbow Aimbot",
            Content = Settings.Enabled and "🎯 AIMBOT ON" or "❌ AIMBOT OFF",
            Duration = 2,
            Image = 4483362458,
        })
        
        -- Update toggle in UI
        EnableToggle:Set(Settings.Enabled)
    end
end)

local lastShootTime = 0

-- Main Aimbot Loop
local Connection
Connection = RunService.RenderStepped:Connect(function()
    local currentTime = tick()
    
    -- Update Rainbow Color
    if Settings.RainbowFOV then
        local rainbowColor = GetRainbowColor()
        FOVCircle.Color = rainbowColor
        TargetIndicator.Color = rainbowColor
    else
        FOVCircle.Color = Settings.FOVColor
        TargetIndicator.Color = Color3.fromRGB(0, 255, 0)
    end
    
    -- Update FOV Circle position
    local fovPosition
    if UserInputService.MouseBehavior == Enum.MouseBehavior.LockCenter then
        -- Shift lock or first person - center of screen
        local viewportSize = Camera.ViewportSize
        fovPosition = Vector2.new(viewportSize.X / 2, viewportSize.Y / 2)
    else
        -- Normal mode - follow mouse
        fovPosition = UserInputService:GetMouseLocation()
    end
    FOVCircle.Position = fovPosition
    FOVCircle.Visible = Settings.ShowFOV
    
    -- Update ESP
    if Settings.ESPEnabled then
        for _, player in pairs(Players:GetPlayers()) do
            if player ~= LocalPlayer then
                UpdateESP(player)
            end
        end
    end
    
    -- Aimbot Logic
    if IsAimbotActive() then
        local targetPlayer = nil
        
        -- Sticky aim
        if Settings.StickyAim and CurrentTarget and IsValidTarget(CurrentTarget) then
            if (currentTime - LastTargetTime) < TargetLockDuration then
                targetPlayer = CurrentTarget
            else
                CurrentTarget = nil
            end
        end
        
        -- Find new target
        if not targetPlayer then
            targetPlayer = GetClosestPlayerToCursor()
            if targetPlayer then
                CurrentTarget = targetPlayer
                LastTargetTime = currentTime
            end
        end
        
        if targetPlayer then
            local character = GetCharacter(targetPlayer)
            local targetPart = GetTargetPart(character)
            
            if targetPart then
                -- Predict position
                local targetPos = PredictPosition(targetPart)
                
                -- Show target indicator
                local screenPoint, onScreen = Camera:WorldToViewportPoint(targetPos)
                if onScreen then
                    TargetIndicator.Position = Vector2.new(screenPoint.X, screenPoint.Y)
                    TargetIndicator.Visible = true
                else
                    TargetIndicator.Visible = false
                end
                
                -- Rivals-style aim assist (STRONG magnetic pull)
                local cameraCFrame = Camera.CFrame
                
                -- Calculate the direction to target
                local directionToTarget = (targetPos - cameraCFrame.Position).Unit
                local currentLookVector = cameraCFrame.LookVector
                
                -- STRONG magnetic pull (Rivals style) - pulls harder the closer to crosshair
                local dotProduct = currentLookVector:Dot(directionToTarget)
                local magneticStrength = math.max(0.3, dotProduct) -- Minimum 30% pull, up to 100%
                
                local pullStrength = Settings.InstantLock and 1 or (Settings.Smoothness * magneticStrength * 2)
                
                if Settings.StickyAim then
                    pullStrength = pullStrength + (Settings.StickyStrength * 1.5)
                    pullStrength = math.min(pullStrength, 1)
                end
                
                -- Create STRONG magnetic pull effect
                local newLookVector = currentLookVector:Lerp(directionToTarget, pullStrength)
                local targetCFrame = CFrame.new(cameraCFrame.Position, cameraCFrame.Position + newLookVector)
                
                -- Apply camera pull
                Camera.CFrame = targetCFrame
                
                -- ALSO rotate character body for full tracking (like Rivals)
                local localChar = GetCharacter(LocalPlayer)
                if localChar then
                    local localRoot = GetRootPart(localChar)
                    if localRoot then
                        -- Strong body rotation towards target
                        local direction = (targetPos - localRoot.Position).Unit
                        local horizontalDirection = Vector3.new(direction.X, 0, direction.Z).Unit
                        local targetBodyCFrame = CFrame.new(localRoot.Position, localRoot.Position + horizontalDirection)
                        
                        -- Apply STRONG body rotation (same pull strength as camera)
                        localRoot.CFrame = localRoot.CFrame:Lerp(targetBodyCFrame, pullStrength)
                    end
                end
                
                -- Auto shoot
                if Settings.AutoShoot and (currentTime - lastShootTime) > Settings.ShootDelay then
                    task.spawn(function()
                        mouse1press()
                        task.wait(0.05)
                        mouse1release()
                    end)
                    lastShootTime = currentTime
                end
            else
                TargetIndicator.Visible = false
            end
        else
            TargetIndicator.Visible = false
            CurrentTarget = nil
        end
    else
        TargetIndicator.Visible = false
        CurrentTarget = nil
    end
end)

-- Trigger Bot
if Settings.TriggerBot then
    RunService.RenderStepped:Connect(function()
        if not Settings.TriggerBot then return end
        
        local target = Mouse.Target
        if target then
            local player = Players:GetPlayerFromCharacter(target.Parent)
            if player and IsValidTarget(player) then
                task.wait(Settings.TriggerDelay)
                mouse1press()
                task.wait(0.05)
                mouse1release()
            end
        end
    end)
end

-- Cleanup
local function Cleanup()
    if Connection then
        Connection:Disconnect()
    end
    if FOVCircle then
        FOVCircle:Remove()
    end
    if TargetIndicator then
        TargetIndicator:Remove()
    end
    for _, espData in pairs(ESPObjects) do
        if espData.Box then espData.Box:Remove() end
        if espData.Name then espData.Name:Remove() end
        if espData.Distance then espData.Distance:Remove() end
        if espData.Health then espData.Health:Remove() end
        if espData.HealthBar then espData.HealthBar:Remove() end
        if espData.HealthBarOutline then espData.HealthBarOutline:Remove() end
    end
end

-- Notification
Rayfield:Notify({
    Title = "🌈 RAINBOW AIMBOT LOADED!",
    Content = "Press Q to toggle aimbot! ESP available in ESP tab!",
    Duration = 5,
    Image = 4483362458,
})

print("=================================")
print("🌈 RAINBOW AIMBOT LOADED!")
print("Press Q to toggle aimbot ON/OFF")
print("Enable ESP in the ESP tab")
print("=================================")