--[[

Advanced Aimbot Script with Feature Documentation

Features:
1. Toggle System: Enable/disable with customizable key
2. Target Selection: Intelligent closest player targeting
3. Prediction System: Movement prediction with customizable multipliers
4. Airshot Detection: Advanced air state detection with multiple thresholds
5. Smoothness Control: Configurable aim smoothing with easing
6. Range-based Adjustments: Distance-based smoothness adaptation
7. Vertical Offset System: Jump and fall compensation
8. Side Movement Handling: Special handling for lateral movement
9. Triggerbot: Automated firing system
]]

getgenv().private_aimassist = {
-- Main Settings
Enabled = false, -- Master toggle for the entire aimbot
Toggle_Key = Enum.KeyCode.E, -- Key to toggle the aimbot on/off

-- Target Settings
BodyPart = "Head", -- Default aim target body part
Prediction = {
Enabled = true, -- Enable movement prediction
Multiplier = 0.6 -- Base prediction multiplier (higher = more
prediction)
},

-- Vertical Movement Compensation

VerticalOffsets = {
Enabled = true, -- Enable vertical movement compensation
JumpOffset = -0.84, -- Offset applied when target is jumping
FallOffset = -1.2, -- Offset applied when target is falling
JumpThreshold = 1.5, -- Velocity threshold to detect jumping
FallThreshold = -2.0 -- Velocity threshold to detect falling
},

-- Range-based Adjustments
UseRange = false, -- Enable distance-based adjustments
Range = {
Short = { Distance = 50, Smoothness = 0.25 }, -- Close range settings
Medium = { Distance = 150, Smoothness = 0.5 }, -- Medium range settings
Long = { Distance = math.huge, Smoothness = 0.75 } -- Long range settings
},

-- Aim Smoothness Configuration

Smoothness = {
Enabled = true, -- Enable aim smoothing
Base = 0.054511, -- Base smoothness value
Easing = { -- Smoothness interpolation settings
Direction = Enum.EasingDirection.InOut,
Style = Enum.EasingStyle.Back
}
},

-- Side Movement Handling

TeleportOnSides = {
Enabled = true, -- Enable side movement compensation
Threshold = 0.15, -- Threshold to detect side movement
 TeleportSpeed = 0.02121, -- Speed of aim adjustment during side movement
MinWalkSpeed = 0, -- Minimum speed to activate
MaxWalkSpeed = 999999 -- Maximum speed to activate
},

-- Advanced Airshot System

Airshot = {
Enabled = false, -- Master toggle for airshot features
Detection = { -- Air state detection thresholds
BodyPartThreshold = 1.5, -- Threshold for body part selection
PredictionThreshold = 1.2, -- Threshold for prediction adjustment
SmoothnessThreshold = 1.3 -- Threshold for smoothness adjustment
},
BodyPart = { -- Airshot-specific targeting
Part = "HumanoidRootPart" -- Body part to target during airshots
},
Prediction = { -- Airshot-specific prediction
Enabled = true,
Multiplier = 0.2 -- Increased prediction for airshots
},
Smoothness = { -- Airshot-specific smoothing
Enabled = true,
Base = 0.1 -- Modified smoothness for airshots
}
},

-- Triggerbot Configuration
Triggerbot = {
Enabled = false, -- Enable automatic firing
Delay = 0, -- Delay between shots
Key = Enum.UserInputType.MouseButton1 -- Firing button
}
}
-- Service References
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local Camera = workspace.CurrentCamera

-- Core Variables
local LocalPlayer = Players.LocalPlayer
local Mouse = LocalPlayer:GetMouse()
local CurrentTarget = nil
local LastTriggerTime = 0
local LastTargetPosition = Vector3.new(0, 0, 0)

-- Target Validation Functions

local function IsAlive(Player)
if not Player or not Player.Character then return false end
local Humanoid = Player.Character:FindFirstChild("Humanoid")
return Humanoid and Humanoid.Health > 0
end

local function IsValidTarget(Player)

return Player and Player ~= LocalPlayer and IsAlive(Player)
end

-- Air Detection System

local function CheckAirDetection(TargetPart, ThresholdType)
 local Threshold = private_aimassist.Airshot.Detection[ThresholdType ..
"Threshold"]
return TargetPart.Velocity.Y > Threshold
end

-- Settings Management
local function GetTargetSettings(TargetPart)
if not private_aimassist.Airshot.Enabled then
return {
BodyPart = private_aimassist.BodyPart,
Prediction = private_aimassist.Prediction,
Smoothness = private_aimassist.Smoothness,
TeleportOnSides = private_aimassist.TeleportOnSides
}
end

return {
BodyPart = CheckAirDetection(TargetPart, "BodyPart") and
private_aimassist.Airshot.BodyPart.Part or
private_aimassist.BodyPart,
Prediction = CheckAirDetection(TargetPart, "Prediction") and
private_aimassist.Airshot.Prediction or
private_aimassist.Prediction,
Smoothness = CheckAirDetection(TargetPart, "Smoothness") and
private_aimassist.Airshot.Smoothness or
private_aimassist.Smoothness,
TeleportOnSides = private_aimassist.TeleportOnSides
}
end

-- Vertical Movement Compensation

local function CalculateVerticalOffset(TargetPart)
if not private_aimassist.VerticalOffsets.Enabled then return 0 end

local VerticalVelocity = TargetPart.Velocity.Y

if VerticalVelocity > private_aimassist.VerticalOffsets.JumpThreshold then
return private_aimassist.VerticalOffsets.JumpOffset
elseif VerticalVelocity < private_aimassist.VerticalOffsets.FallThreshold then
return private_aimassist.VerticalOffsets.FallOffset
end
return 0
end

-- Target Acquisition
local function GetClosestPlayer()
local MaxDistance = math.huge
local Target = nil

for _, Player in ipairs(Players:GetPlayers()) do

if IsValidTarget(Player) then
pcall(function()
local Settings =
GetTargetSettings(Player.Character.HumanoidRootPart)
if Player.Character and
Player.Character:FindFirstChild(Settings.BodyPart) then
local TargetPart = Player.Character[Settings.BodyPart]
local ScreenPosition, OnScreen =
Camera:WorldToScreenPoint(TargetPart.Position)
 if OnScreen then
local Distance = (Vector2.new(Mouse.X, Mouse.Y) -
Vector2.new(ScreenPosition.X, ScreenPosition.Y)).Magnitude
if Distance < MaxDistance then
MaxDistance = Distance
Target = Player
end
end
end
end)
end
end

return Target
end

-- Range-based Smoothness
local function GetSmoothnessForDistance(Distance, Settings)
if not private_aimassist.UseRange then
return Settings.Smoothness.Base
end

if Distance <= private_aimassist.Range.Short.Distance then

return private_aimassist.Range.Short.Smoothness
elseif Distance <= private_aimassist.Range.Medium.Distance then
return private_aimassist.Range.Medium.Smoothness
else
return private_aimassist.Range.Long.Smoothness
end
end

-- Side Movement Detection

local function IsSideMovement(CurrentPos, LastPos, TargetPart, Settings)
if not Settings.TeleportOnSides.Enabled then return false end

local Velocity = TargetPart.Velocity

local Speed = Vector3.new(Velocity.X, 0, Velocity.Z).Magnitude

if Speed < Settings.TeleportOnSides.MinWalkSpeed or

Speed > Settings.TeleportOnSides.MaxWalkSpeed then
return false
end

local Movement = CurrentPos - LastPos

local SideAmount = math.abs(Movement.X)
local ForwardAmount = math.abs(Movement.Z)

local TotalMovement = SideAmount + ForwardAmount

if TotalMovement == 0 then return false end

local SideRatio = SideAmount / TotalMovement

return SideRatio > Settings.TeleportOnSides.Threshold
end

-- Camera Update Logic

local function UpdateCamera()
if not private_aimassist.Enabled or not CurrentTarget then return end

if not IsValidTarget(CurrentTarget) then

 CurrentTarget = nil
return
end

pcall(function()
local Settings =
GetTargetSettings(CurrentTarget.Character.HumanoidRootPart)
if CurrentTarget.Character and
CurrentTarget.Character:FindFirstChild(Settings.BodyPart) then
local TargetPart = CurrentTarget.Character[Settings.BodyPart]
local TargetPosition = TargetPart.Position

-- Apply vertical offset

TargetPosition = TargetPosition + Vector3.new(0,
CalculateVerticalOffset(TargetPart), 0)

-- Apply prediction
if Settings.Prediction.Enabled then
TargetPosition = TargetPosition + (TargetPart.Velocity *
Settings.Prediction.Multiplier)
end

-- Calculate smoothness
local Distance = (LocalPlayer.Character[Settings.BodyPart].Position -
TargetPart.Position).Magnitude
local Smoothness = GetSmoothnessForDistance(Distance, Settings)

if Settings.Smoothness.Enabled then
Smoothness = Smoothness * Settings.Smoothness.Base
end

-- Check side movement

if IsSideMovement(TargetPosition, LastTargetPosition, TargetPart,
Settings) then
Smoothness = Settings.TeleportOnSides.TeleportSpeed
end

-- Update camera
Camera.CFrame = Camera.CFrame:Lerp(
CFrame.new(Camera.CFrame.Position, TargetPosition),
Smoothness
)

LastTargetPosition = TargetPosition
end
end)
end

-- Triggerbot Logic
local function TriggerCheck()
if not private_aimassist.Triggerbot.Enabled or not CurrentTarget then return
end

local CurrentTime = tick()

if CurrentTime - LastTriggerTime < private_aimassist.Triggerbot.Delay then
return end

if UserInputService:IsMouseButtonPressed(private_aimassist.Triggerbot.Key) then
mouse1press()
 task.wait(0.05)
mouse1release()
LastTriggerTime = CurrentTime
end
end

-- Main Loop
RunService.RenderStepped:Connect(function()
if private_aimassist.Enabled then
if not CurrentTarget or not IsValidTarget(CurrentTarget) then
CurrentTarget = GetClosestPlayer()
if CurrentTarget and CurrentTarget.Character then
local Settings =
GetTargetSettings(CurrentTarget.Character.HumanoidRootPart)
LastTargetPosition =
CurrentTarget.Character[Settings.BodyPart].Position
end
end
UpdateCamera()
TriggerCheck()
end
end)

-- Toggle Handler
UserInputService.InputBegan:Connect(function(Input)
if Input.KeyCode == private_aimassist.Toggle_Key then
private_aimassist.Enabled = not private_aimassist.Enabled

if private_aimassist.Enabled then
CurrentTarget = GetClosestPlayer()
if CurrentTarget and CurrentTarget.Character then
local Settings =
GetTargetSettings(CurrentTarget.Character.HumanoidRootPart)
LastTargetPosition =
CurrentTarget.Character[Settings.BodyPart].Position
end
else
CurrentTarget = nil
end
end
end)