newwww

local Aimbot = {}
Aimbot.__index = Aimbot

--//Localization
local Instance = Instance
local game = game
local math = math
local setmetatable = setmetatable
local workspace = workspace
local CFrame = CFrame
local Vector3 = Vector3
local Vector2 = Vector2
local Random = Random
local RaycastParams = RaycastParams
local pairs = pairs
local string = string
local table = table
local Enum = Enum
local getrawmetatable = getrawmetatable
local replaceclosure = replaceclosure
local setreadonly = setreadonly
local checkcaller = checkcaller
local getclock = os.clock
local mouse1press = mouse1press
local mouse1release = mouse1release
local mousemoverel = mousemoverel
local hookfunction = hookfunction
local newcclosure = newcclosure

--//Instance methods
local Raycast = workspace.Raycast
local GetPropertyChangedSignal = game.GetPropertyChangedSignal
local Connect = game.ChildAdded.Connect
local Destroy = game.Destroy
local GetService = game.GetService
local FindFirstChildOfClass = game.FindFirstChildOfClass
local FindFirstChild = game.FindFirstChild
local GetChildren = game.GetChildren
local IsA = game.IsA
local IsDescendantOf = game.IsDescendantOf

--//Services
local Players = GetService(game, "Players")
local UserInputService = GetService(game, "UserInputService")
local RunService = GetService(game, "RunService")
local GuiService = GetService(game, "GuiService")

--//Temporary instances
local tempcam = Instance.new("Camera")
local tempconn = Connect(game.AncestryChanged, function() end)

--//Other instance methods
local WorldToViewportPoint = tempcam.WorldToViewportPoint
local WorldToScreenPoint = tempcam.WorldToScreenPoint
local GetPlayers = Players.GetPlayers
local GetMouseLocation = UserInputService.GetMouseLocation
local ViewportPointToRay = tempcam.ViewportPointToRay
local Disconnect = tempconn.Disconnect
local Lerp2D = Vector2.new().Lerp

--//Cleanup
Destroy(tempcam)
Disconnect(tempconn)

--//Local functions and constant variables
Aimbot.DefaultSettings = {
    Aimbot = {
        TrackingSettings = {
            XSmoothingPercent = .6,
            YSmoothingPercent = .6,
            RadiusPercentAt1 = 250
        },

        FlickSettings = {
            XSmoothingPercent = 1.3,
            YSmoothingPercent = 1.3,
            RadiusPercentAt1 = 175
        },

        DistanceBias = 1.6
    },

    Silent = {
        RadiusPercentAt1 = 145
    },

    TriggerBot = {
        Enabled = false,
        Semi = false,
        TimeBetweenClick = .3,
        Delay = 160
    },

    DeadZone = {
        Enabled = false,
        XSmoothingPercent = 1.3,
        YSmoothingPercent = 1.3
    },

    AutoPeak = {
        Enabled = false
    },

    General = {
        Offset = Vector2.new(0, 0),
        IgnoreWater = true,
        DefaultIgnore = {},
        TransparencyThreshold = 1,
        IsAliveCheck = true,
        TeamCheck = true,
        InvisibleCheck = true,
        SizeCheck = true,
        RadiusCap = 300
    }
}

local LocalPlayer = Players.LocalPlayer
local Mouse = LocalPlayer.GetMouse(LocalPlayer)
local GuiInset = GuiService.GetGuiInset(GuiService)

local function OnCameraChange()
    local cam = workspace.CurrentCamera
    Aimbot.Camera = cam
    Aimbot.ViewportSize = cam.ViewportSize
    Aimbot.WidthFactor = cam.ViewportSize.X / 100
end

local function UpdateTable(tab, update)
    for name, value in pairs(update) do
        if tab[name] == nil then
            tab[name] = value
        end
    end
end

local function GetChildrenWhichIsA(part, baseclass)
    local parts = GetChildren(part)
    local len = #parts
    local filtered = {}
    if len > 0 then
        for i = 1, len do
            local p = parts[i]
            if IsA(p, baseclass) then
                table.insert(filtered, p)
            end
        end
    end
    return filtered
end

local function GetChildrenWhichIsNotA(part, baseclass)
    local parts = GetChildren(part)
    local len = #parts
    local filtered = {}
    if len > 0 then
        for i = 1, len do
            local p = parts[i]
            if not IsA(p, baseclass) then
                table.insert(filtered, p)
            end
        end
    end
    return filtered
end

if workspace.CurrentCamera then
    OnCameraChange()
end
Connect(GetPropertyChangedSignal(workspace, "CurrentCamera"), OnCameraChange)

--//Methods

--//Gets bias value at a given distance
function Aimbot:GetBiasAtDistance(distance)
    if self.Camera then
        return distance * self.Aimbot.DistanceBias * self.WidthFactor
    end
end

--//Gets circle radius at a given distance
function Aimbot:GetRadiusAtDistance(radius, distance)
    if self.Camera then
        if self.General.RadiusCap then
            if distance >= self.General.RadiusCap then
                distance = self.General.RadiusCap
            end
        end
        return radius / distance * self.WidthFactor
    end
end

--//Checks for parts obscuring camera, including terrain - unlike Camera:GetPartsObscuringTarget
function Aimbot:GetBlockingPart(origin, position, ignore)
    self.WallCheckParams.FilterDescendantsInstances = self.General.DefaultIgnore
    local direction = position - origin
    local thisignore = self.WallCheckParams.FilterDescendantsInstances
    if ignore then
        table.move(ignore, 1, #ignore, #thisignore+ 1, thisignore)
    end
    while true do
        self.WallCheckParams.FilterDescendantsInstances = thisignore
        local result = Raycast(workspace, origin, direction, self.WallCheckParams)
        if result then
            if self.IgnoreTransparent and result.Instance.ClassName ~= "Terrain" and result.Instance.Transparency >= self.General.TransparencyThreshold then
                table.insert(thisignore, result.Instance)
            end
            self.WallCheckParams.FilterDescendantsInstances = self.General.DefaultIgnore
            return result.Instance
        end
        self.WallCheckParams.FilterDescendantsInstances = self.General.DefaultIgnore
        return nil
    end
end

--//Gets target from viewport point
function Aimbot:GetTargetFromViewportPoint(point, distance, ignore)
    local camera = self.Camera
    if camera then
        local ray = ViewportPointToRay(camera, point.X, point.Y)
        return self:GetBlockingPart(ray.Origin, ray.Origin + ray.Direction * distance, ignore)
    end
end

--//Gets closest edge on part from viewport point
function Aimbot:GetClosestEdgeFromViewportPoint(point, part)
    local camera = self.Camera
    if camera then
        local ray = ViewportPointToRay(camera, point.X, point.Y)
        local ppos = part.Position
        local distance = (ray.Origin - ppos).Magnitude
        local direction = (ray.Origin + ray.Direction * distance - ppos).Unit
        local size = part.Size; local half = part.Size / 2; local final = direction * size
        return ppos + Vector3.new(
            final.X < 0 and math.max(final.X, -half.X + size.X / 10) or math.min(final.X, half.X - size.X / 10),
            final.Y < 0 and math.max(final.Y, -half.Y + size.Y / 10) or math.min(final.Y, half.Y - size.Y / 10),
            final.Z < 0 and math.max(final.Z, -half.Z + size.Z / 10) or math.min(final.Z, half.Z - size.Z / 10)
        )
    end
end

--//Gets mouse location with offset accounted for
function Aimbot:GetMouseViewportPoint()
    return GetMouseLocation(UserInputService) + self.General.Offset
end

--//Gets best target from a list of parts and a viewport point, ignoreparent specifies whether to filter the entire parent
function Aimbot:GetBestPartFromViewportPoint(position, parts, ignoreparent, ignore)
    local camera = self.Camera
    if camera then
        local len = #parts
        if len > 0 then
            local leastbias, leastwdist, leastpdist, part = math.huge, math.huge, math.huge, nil
            local campos = camera.CFrame.Position
            ignore = ignore or {}
            table.insert(ignore, LocalPlayer.Character)
            local ipos = #ignore + 1
            for i = 1, len do
                local cpart = parts[i]
                local cpos = cpart.Position
                local point, onscreen = WorldToViewportPoint(camera, cpos)
                ignore[ipos] = ignoreparent and cpart.Parent or cpart
                if onscreen and not self:GetBlockingPart(campos, cpos, ignore) then
                    local pdist = (position - Vector2.new(point.X, point.Y)).Magnitude
                    local wdist = (campos - cpos).Magnitude
                    local playerOb = cpart.Parent:FindFirstChildOfClass("Humanoid") and game:GetService("Players"):GetPlayerFromCharacter(cpart.Parent) or cpart.Parent.Parent:FindFirstChildOfClass("Humanoid") and game:GetService("Players"):GetPlayerFromCharacter(cpart.Parent.Parent)
                    if pdist <= self:GetRadiusAtDistance(self.Targets[playerOb] and self.Aimbot.TrackingSettings.RadiusPercentAt1 or self.Aimbot.FlickSettings.RadiusPercentAt1, wdist) then
                        local bias = self:GetBiasAtDistance(wdist) + pdist
                        if bias < leastbias or (bias == leastbias and wdist < leastwdist) then
                            leastbias = bias
                            leastwdist = wdist
                            leastpdist = pdist
                            part = cpart
                        end
                    end
                end
            end
            ignore[ipos] = nil
            return part, part and leastpdist <= self:GetRadiusAtDistance(self.Silent.RadiusPercentAt1, leastwdist)
        end
    end
end

function Aimbot:IsMousePosition(pos1, pos2)
    return math.abs(pos1 - (pos2 + self.General.Offset.X)) <= 3
end

--//Gets best player to target based on a viewport point
function Aimbot:GetBestPlayerTargetFromViewportPoint(pos, tracking)
    if self.Camera then
        local plrs = GetPlayers(Players)
        local len = #plrs
        if len > 0 then
            local parts = {}
            local lparts = 1
            for i = 1, len do
                local plr = plrs[i]
                local charac = plr.Character
                if plr ~= LocalPlayer and charac then
                    if self.General.TeamCheck and not plr.Neutral and plr.Team == LocalPlayer.Team then
                        continue
                    end
                    if self.General.IsAliveCheck then
                        local hum = FindFirstChildOfClass(charac, "Humanoid")
                        if not hum or hum.Health <= 0 then
                           continue
                        end
                    end
                    if self.General.InvisibleCheck then
                        local head = FindFirstChild(charac, "Head")
                        if not head or head.Transparency >= 1 then
                            continue
                        end
                    end
                    if self.General.SizeCheck then
                        local hum = FindFirstChild(charac, "HumanoidRootPart")
                        if not hum or hum.Size.X < 2 or hum.Size.Y < 2 or hum.Size.Z < 1 then
                            continue
                        end
                    end
                    local filtered = GetChildrenWhichIsA(charac, "BasePart")
                    local lfiltered = #filtered
                    table.move(filtered, 1, lfiltered, lparts, parts)
                    lparts = lparts + lfiltered
                end
            end
            local target, silent = self:GetBestPartFromViewportPoint(pos, parts, true)
            local plrz = target and game:GetService("Players"):GetPlayerFromCharacter(target.Parent) or "nil"
            for aa,_ in pairs(self.Targets) do
                if aa ~= plrz then self.Targets[aa] = false end
            end
            if target then
                return target, silent
            end
        end
    end
end

function Aimbot:Start()
    self.Enabled = true
    self.LastTrigger = 0
    self.TriggerPaused = false
    self.Targets = {}; setmetatable(self.Targets, {__index = function(s, k)
        s[k] = false
        return false
    end})
    local relative
    local holding = false
    local mspoof
    if not self.RenderStep then
        local totalTime = 0
        self.RenderStep = Connect(RunService.RenderStepped, function(delta)
            totalTime += delta
            if (totalTime < 1 / 144) then
                return
            end
            totalTime = 0
            if self.Enabled and relative then
                mousemoverel(relative.X, relative.Y)
            end
        end)
    end
    if not self.Heartbeat then
        local totalTime = 0
        self.Heartbeat = Connect(RunService.Heartbeat, function(delta)
            totalTime += delta
            if (totalTime < 1 / 144) then
                return
            end
            totalTime = 0
            relative = nil
            if self.Enabled then
                local camera = self.Camera
                if camera then
                    local mpos = self:GetMouseViewportPoint()
                    local target, silent = self:GetBestPlayerTargetFromViewportPoint(mpos)
                    if not target then
                        if holding then
                            holding = false
                            mouse1release()
                        end
                    end
                    if target then
                        local charac = target.Parent
                        local plrz = game:GetService("Players"):GetPlayerFromCharacter(charac)
                        local lcharac = LocalPlayer.Character
                        local cignore = GetChildrenWhichIsNotA(charac, "BasePart")
                        table.insert(cignore, lcharac)
                        local mtarget = self:GetTargetFromViewportPoint(mpos, 5000, cignore)
                        local bodyPart = (FindFirstChild(lcharac, "Head") or FindFirstChild(lcharac, "HumanoidRootPart"))
                        local blockingParts = self:GetBlockingPart(bodyPart and bodyPart.Position, target.Position, cignore)
                        if silent and self.TriggerBot.Enabled and lcharac and blockingParts and blockingParts:IsDescendantOf(charac) then
                            if not holding then
                                holding = true
                                mouse1press()
                            else
                                if self.TriggerBot.Semi and (tick() - self.LastTrigger) >= self.TriggerBot.TimeBetweenClick and not self.TriggerPaused then
                                    self.TriggerPaused = true
                                    task.wait(self.TriggerBot.Delay / 1000)
                                    mouse1click()
                                    self.LastTrigger = tick()
                                    self.TriggerPaused = false
                                end
                            end
                        elseif silent and self.TriggerBot.Enabled and lcharac and (not blockingParts or not blockingParts:IsDescendantOf(charac)) then
                            if holding then
                                holding = false
                                mouse1release()
                            end
                        end

                        if mtarget and IsDescendantOf(mtarget, charac) then
                            mspoof = nil
                            self.Targets[plrz] = true
                        elseif silent then
                            mspoof = self:GetClosestEdgeFromViewportPoint(mpos, target)
                        else
                            mspoof = nil
                        end

                        local pos, onscreen = WorldToViewportPoint(camera, self:GetClosestEdgeFromViewportPoint(mpos, target))
                        if onscreen then
                            if self.Targets[plrz] then
                                relative = (Vector2.new(pos.X, pos.Y) - mpos) / Vector2.new(self.Aimbot.TrackingSettings.XSmoothingPercent * self.WidthFactor, self.Aimbot.TrackingSettings.YSmoothingPercent * self.WidthFactor)
                            else
                                relative = (Vector2.new(pos.X, pos.Y) - mpos) / Vector2.new(self.Aimbot.FlickSettings.XSmoothingPercent * self.WidthFactor, self.Aimbot.FlickSettings.YSmoothingPercent * self.WidthFactor)
                            end
                        end
                    end
                end
            end
        end)
    end

    local old; old = hookmetamethod(game, "__index", function(i,v)
        if string.lower(v) == "hit" and mspoof then
            if old(i, "ClassName") == "Mouse" or old(i, "ClassName") == "PlayerMouse" then
                if not checkcaller() then
                    return CFrame.new(mspoof)
                end
            end
        end
        return old(i,v)
    end)

    local old2; old2 = hookmetamethod(game, "__namecall", function(self2, ...)
        local args = {...}
        if getnamecallmethod() == "ViewportPointToRay" and not checkcaller() and mspoof then
            local pos = GetMouseLocation(UserInputService)
            if math.abs(args[1] - (pos.X + self.General.Offset.X)) <= 3  and math.abs(args[2] - (pos.Y + self.General.Offset.Y)) <= 3 then
                local newPos = WorldToViewportPoint(self.Camera, mspoof)
                args[1] = newPos.X
                args[2] = newPos.Y
                return old2(self2, table.unpack(args))
            else
                local pos = Vector2.new(Mouse.X, Mouse.Y)
                if math.abs(args[1] - (pos.X + self.General.Offset.X)) <= 3  and math.abs(args[2] - (pos.Y + self.General.Offset.Y)) <= 3 then
                    local newPos = WorldToViewportPoint(self.Camera, mspoof)
                    args[1] = newPos.X
                    args[2] = newPos.Y
                    return old2(self2, table.unpack(args))
                end
            end
        elseif getnamecallmethod() == "ScreenPointToRay" and not checkcaller() and  mspoof then
            local pos = GetMouseLocation(UserInputService)
            if math.abs(args[1] - (pos.X + self.General.Offset.X)) <= 3  and math.abs(args[2] - (pos.Y + self.General.Offset.Y)) <= 3 then
                local newPos = WorldToScreenPoint(self.Camera, mspoof)
                args[1] = newPos.X
                args[2] = newPos.Y
                return old2(self2, table.unpack(args))
            else
                local pos = Vector2.new(Mouse.X, Mouse.Y)
                if math.abs(args[1] - (pos.X + self.General.Offset.X)) <= 3  and math.abs(args[2] - (pos.Y + self.General.Offset.Y)) <= 3 then
                    local newPos = WorldToScreenPoint(self.Camera, mspoof)
                    args[1] = newPos.X
                    args[2] = newPos.Y
                    return old2(self2, table.unpack(args))
                end
            end
        end
        return old2(self2, ...)
    end)
end

function Aimbot:Kill()
    self.Enabled = false
    if self.RenderStep then
        Disconnect(self.RenderStep)
        self.RenderStep = nil
    end
    if self.Heartbeat then
        Disconnect(self.Heartbeat)
        self.Heartbeat = nil
    end
end

function Aimbot.new(presets)
    presets = presets or {}
    UpdateTable(presets, Aimbot.DefaultSettings)
    local WallCheckParams = RaycastParams.new()
    WallCheckParams.FilterType = Enum.RaycastFilterType.Blacklist
    WallCheckParams.IgnoreWater = presets.General.IgnoreWater
    WallCheckParams.FilterDescendantsInstances = presets.General.DefaultIgnore
    presets.WallCheckParams = WallCheckParams
    return setmetatable(presets, Aimbot)
end

return Aimbot