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 = {
	RadiusPercentAt1 = 130, --//Radius percent of screen width at 1 stud for aimbot
	XSmoothingPercent = .125,
	YSmoothingPercent = .15, --//Slows down mouse movement by a percentage of screen width
	DistanceBias = 1, --//Raises sensitivity of distance from camera when choosing target
	Offset = Vector2.new(0, 0), --//Mouse offset in pixels
	SilentRadiusPercentAt1 = 130, --//Radius percent of screen width at 1 stud for silent aim
	IgnoreTransparent = true, --//Whether to ignore transparent parts above the threshold or not in wallcheck
	IgnoreWater = false, --//Whether to ignore water in wallcheck
	TransparencyThreshold = .5, --//Threshold for what transparency or greater counts as ignorable
	DefaultIgnore = {}, --//List for what the aimbot should ignore during wallcheck
	IsAliveCheck = true, --//Ignore dead players
	TeamCheck = true,
	TriggerBot = true
}

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

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.DistanceBias * self.WidthFactor
	end
end

--//Gets circle radius at a given distance
function Aimbot:GetRadiusAtDistance(rpercent, distance)
	if self.Camera then
		return rpercent / 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.DefaultIgnore --//Incase it got updated

	local dir = position - origin
	local thisignore = self.WallCheckParams.FilterDescendantsInstances --//Copies table for you essentially

	if ignore then
		table.move(ignore, 1, #ignore, #thisignore + 1, thisignore)
	end

	while true do
		self.WallCheckParams.FilterDescendantsInstances = thisignore --//Copies
		local result = Raycast(workspace, origin, dir, self.WallCheckParams)

		if result then
			if self.IgnoreTransparent and result.Instance.ClassName ~= "Terrain" and result.Instance.Transparency >= self.TransparencyThreshold then
				table.insert(thisignore, result.Instance)
				continue
			end

			self.WallCheckParams.FilterDescendantsInstances = self.DefaultIgnore
			return result.Instance
		end

		self.WallCheckParams.FilterDescendantsInstances = self.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 dist = (ray.Origin - ppos).Magnitude
		local dir = (ray.Origin + ray.Direction * dist - ppos).Unit

		local size = part.Size

		local half = size / 2
		local final = dir * 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.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 {}
			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 --//Pixel Distance
					local wdist = (campos - cpos).Magnitude --//World Distance

					if pdist <= self:GetRadiusAtDistance(self.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.SilentRadiusPercentAt1, leastwdist)
		end
	end
end

--//Gets best player to target based on a viewport point
function Aimbot:GetBestPlayerTargetFromViewportPoint(pos)
	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.TeamCheck and not plr.Neutral and plr.Team == LocalPlayer.Team then
				        continue
				    end

					if self.IsAliveCheck then
						local hum = FindFirstChildOfClass(charac, "Humanoid")

						if not hum or hum.Health <= 0 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)

			if target then
				return target, silent
			end
		end
	end
end

--//Begins aimbot
function Aimbot:Start()
	self.Enabled = true

	local relative
	local holding = false
	local mspoof

	local lastframe = getclock()

	if not self.RenderStep then
        local lastt = 0
        local fdelt = 0.016666666666666666

		self.RenderStep = Connect(RunService.RenderStepped, function(delta)
			local timee = tick()
            if self.Enabled and relative and timee > lastt + fdelt or (1 / delta < 60) then
                lastt = timee
				mousemoverel(relative.X, relative.Y)
			end
		end)
	end

	if not self.Heartbeat then
        local lastt = 0
        local fdelt = 0.016666666666666666

		self.Heartbeat = Connect(RunService.Heartbeat, function(delta)
            local timee = tick()
		    relative = nil

			if self.Enabled and timee > lastt + fdelt or (1 / delta < 60) then
                lastt = timee
                relative = nil
				local camera = self.Camera

				if camera then
					local mpos = self:GetMouseViewportPoint()
					local target, silent = self:GetBestPlayerTargetFromViewportPoint(mpos)

					if target then
					    local charac = target.Parent
					    local lcharac = LocalPlayer.Character
					    local cignore = GetChildrenWhichIsNotA(charac, "BasePart")

					    table.insert(cignore, lcharac)

						local mtarget = self:GetTargetFromViewportPoint(mpos, 5000, cignore)

						if silent and self.TriggerBot and lcharac and IsDescendantOf(self:GetBlockingPart((FindFirstChild(lcharac, "Head") or FindFirstChild(lcharac, "HumanoidRootPart")).Position, target.Position, cignore), charac) then
						    if not holding then
    						    holding = true
    						    mouse1press()
    						end
						elseif holding then
						    holding = false
						    mouse1release()
						end

						if mtarget and IsDescendantOf(mtarget, charac) then
						    mspoof = nil

						    if not self.TargetPart then
						        return
						    end
						elseif silent then
						    mspoof = self:GetClosestEdgeFromViewportPoint(mpos, target)
						else
						    mspoof = nil
						end

						target = (self.TargetPart and FindFirstChild(charac, self.TargetPart)) or target
    					local pos, onscreen = WorldToViewportPoint(camera, target.Position)

    					if onscreen then
    					    relative = (Vector2.new(pos.X, pos.Y) - mpos) / Vector2.new(self.XSmoothingPercent * self.WidthFactor, self.YSmoothingPercent * self.WidthFactor)
					    end
					else
					    if holding then
					        holding = false
					        mouse1release()
					    end

					    mspoof = nil
					end
				else
					if holding then
					    holding = false
					    mouse1release()
					end

				    mspoof = nil
				end
			else
				if holding then
					holding = false
				    mouse1release()
			    end

			    mspoof = nil
		    end
		end)
	end

    setreadonly(GameMeta, false)

    local index
    index = replaceclosure(GameMeta.__index, function(self2, indice)
    	if not checkcaller() and self.Enabled and self2 == Mouse and mspoof then
    	    local lc = string.lower(indice)
    	    local cam = self.Camera

    		if lc == "hit" then
    			return CFrame.new(mspoof)
    		elseif lc == "x" and cam then
    		    return WorldToScreenPoint(cam, mspoof).X
    		elseif lc == "y" and cam then
    		    return WorldToScreenPoint(cam, mspoof).Y
    		end
    	end

    	return index(self2, indice)
    end)

    setreadonly(GameMeta, true)

    local getml
    getml = hookfunction(UserInputService.GetMouseLocation, newcclosure(function(self2)
        if not checkcaller() and self.Enabled and self2 == UserInputService and mspoof then
            local cam = self.Camera

            if cam then
                local pos = WorldToViewportPoint(cam, mspoof)
                return Vector2.new(pos.X, pos.Y)
            end
        end

        return getml(self2)
    end))
end

--//Completely kills aimbot, as opposed to enabled = false
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

--//Constructor
function Aimbot.new(presets)
	presets = presets or {}
	UpdateTable(presets, Aimbot.DefaultSettings)

	local WallCheckParams = RaycastParams.new()
	WallCheckParams.FilterType = Enum.RaycastFilterType.Blacklist
	WallCheckParams.IgnoreWater = presets.IgnoreWater
	WallCheckParams.FilterDescendantsInstances = presets.DefaultIgnore

	presets.WallCheckParams = WallCheckParams
	return setmetatable(presets, Aimbot)
end

--//Return with default settings
return Aimbot