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 GetDescendants = game.GetDescendants
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,
	InvisibleCheck = true,
	TriggerBotTime = 160,
	TriggerBotSemi = false,
	TriggerBotTimeBetweenClick = .3,
	HoldControl = false,
	Holding = false,
	SizeCheck = false,
	FlickSettings = {
		FlickXSmoothingPercent = .9, -- .6
		FlickYSmoothingPercent = .9, -- .6
		Flick = true -- false if only will track
	},
	AutoPeak = {
		Enabled = false,
		PointPosition = nil -- dont chage this
	},
	RadiusCap = nil
}

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 GetDescendantsWhichIsA(part, baseclass)
	local parts = GetDescendants(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
		if self.RadiusCap then
			if distance >= self.RadiusCap and rpercent ~= self.SilentRadiusPercentAt1 then
				distance = self.RadiusCap
			end
		end

		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 Blacklisted = {
			["Right Arm"] = "LeftSurface",
			["Left Arm"] = "RightSurface",
			["Right Leg"] = "TopSurface",
			["Left Leg"] = "TopSurface",
			["Head"] = "BottomSurface"
		}

		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

		local Pos = 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)
		)

		local g = {
			TopSurface = part.CFrame * CFrame.new(0, part.Size.Y / 2, 0) * CFrame.Angles(math.pi / 2, 0, 0),
			BottomSurface = part.CFrame * CFrame.new(0, part.Size.Y / -2, 0) * CFrame.Angles(math.pi / -2, 0, 0),
			FrontSurface = part.CFrame * CFrame.new(0, 0, part.Size.Z / -2),
			BackSurface = part.CFrame * CFrame.new(0, 0, part.Size.Z / 2) * CFrame.Angles(0, math.pi, 0),
			LeftSurface = part.CFrame * CFrame.new(part.Size.X / -2, 0, 0) * CFrame.Angles(0, math.pi / 2, 0),
			RightSurface = part.CFrame * CFrame.new(part.Size.X / 2, 0, 0) * CFrame.Angles(0, math.pi / -2, 0)
		}

		local closest = math.huge
		local new = nil
		for i,v in pairs(g) do
			local h = (Pos - v.Position).Magnitude
			if h < closest then
				new = i
				closest = h
			end
		end

		if Blacklisted[part.Name] ~= new then
			return Pos
		end
	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
					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.RadiusPercentAt1 or self.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.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
			local maxPlr = {}
			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

					if self.InvisibleCheck then
						local head = FindFirstChild(charac, "Head")

						if not head or head.Transparency >= 1 then
							continue
						end
					end

					if self.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

					if self.AntiLag then
						if #maxPlr >= 4 then continue end
						table.insert(maxPlr, plr)
					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

--//Begins aimbot

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

	local lastframe = getclock()

	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
				if self.HoldControl and self.Holding or not self.HoldControl then
					mousemoverel(relative.X, relative.Y)
				end
			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")

						--if cignore then
						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 and lcharac and BlockingParts and BlockingParts:IsDescendantOf(charac) then
							if not holding then
								holding = true
								mouse1press()
							else
								if self.TriggerBotSemi and (tick() - self.LastTrigger) >= self.TriggerBotTimeBetweenClick and not self.TriggerPaused then
									self.TriggerPaused = true
									task.wait(self.TriggerBotTime / 1000)
									mouse1press()
									self.LastTrigger = tick()
									self.TriggerPaused = false
								end
							end
						elseif silent and self.TriggerBot 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) and not (string.find(mtarget.Name:lower(), "arm") or string.find(mtarget.Name:lower(), "leg")) then
							mspoof = nil
							self.Targets[plrz] = true
							if self.Deadzone.Enabled then
								target = (self.TargetPart and FindFirstChild(charac, self.TargetPart)) or target
								local pos, onscreen = WorldToViewportPoint(camera, target.Position)
								if onscreen then
									local g = (Vector2.new(pos.X, pos.Y) - mpos) / Vector2.new(self.Deadzone.XSmoothingPercent * self.WidthFactor, self.Deadzone.YSmoothingPercent * self.WidthFactor)
									mousemoverel(g.X, g.Y)
								end
							end
							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 charac:FindFirstChild("HumanoidRootPart")
						--local pos, onscreen = WorldToViewportPoint(camera, target.Position)
						local g = self:GetClosestEdgeFromViewportPoint(mpos, target)
						if g then

							local pos, onscreen = WorldToViewportPoint(camera, g)
							if onscreen then
								if self.Targets[plrz] then
									relative = (Vector2.new(pos.X, pos.Y) - mpos) / Vector2.new(self.XSmoothingPercent * self.WidthFactor, self.YSmoothingPercent * self.WidthFactor)
								else
									if self.FlickSettings.Flick then
										relative = (Vector2.new(pos.X, pos.Y) - mpos) / Vector2.new(self.FlickSettings.FlickXSmoothingPercent * self.WidthFactor, self.FlickSettings.FlickYSmoothingPercent * self.WidthFactor)
									end
								end
							end
						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
	local Players2 = game.GetService(game, "Players");
	local Client2 = Players2.LocalPlayer;
	local Mouse2 = Client2.GetMouse(Client2);

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

	local old2; old2 = hookmetamethod(game, "__namecall", newcclosure(function(self2, ...)
		if getnamecallmethod() == "ViewportPointToRay" and not checkcaller() and mspoof then
			local args = {...}
			local pos = GetMouseLocation(UserInputService)
			if math.abs(args[1] - (pos.X + self.Offset.X)) <= 3 and math.abs(args[2] - (pos.Y + self.Offset.Y)) <= 3 then
				local newPos = workspace.CurrentCamera.WorldToViewportPoint(workspace.CurrentCamera, mspoof)
				args[1] = newPos.X
				args[2] = newPos.Y
				return old2(self2, table.unpack(args))
			else
				if math.abs(args[1] - (Mouse2.X + self.Offset.X)) <= 3 and math.abs(args[2] - (Mouse2.Y + self.Offset.Y)) <= 3 then
					local newPos = workspace.CurrentCamera.WorldToViewportPoint(workspace.CurrentCamera, 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 args = {...}
			local pos = GetMouseLocation(UserInputService)
			if math.abs(args[1] - (pos.X + self.Offset.X)) <= 3 and math.abs(args[2] - (pos.Y + self.Offset.Y)) <= 3 then
				local newPos = workspace.CurrentCamera.WorldToScreenPoint(workspace.CurrentCamera, mspoof)
				args[1] = newPos.X
				args[2] = newPos.Y
				return old2(self2, table.unpack(args))
			else
				if math.abs(args[1] - (Mouse2.X + self.Offset.X)) <= 3 and math.abs(args[2] - (Mouse2.Y + self.Offset.Y)) <= 3 then
					local newPos = workspace.CurrentCamera.WorldToScreenPoint(workspace.CurrentCamera, mspoof)
					args[1] = newPos.X
					args[2] = newPos.Y
					return old2(self2, table.unpack(args))
				end
			end
		end
		return old2(self2, ...)
	end))

	--[[
    local old2; old2 = hookmetamethod(game, "__namecall", function(self2, ...)
        local args = {...}
        if getnamecallmethod() == "ScreenPointToRay" or getnamecallmethod() == "ViewportPointToRay" and mspoof then
            local SecondPosition = game.GetService(game, "UserInputService").GetMouseLocation(game.GetService(game, "UserInputService"))
            if args[1] == Mouse2.X and args[2] == Mouse2.Y or args[1] == SecondPosition.X and args[2] == SecondPosition.Y then
                local newPos = workspace.CurrentCamera.WorldToScreenPoint(workspace.CurrentCamera, mspoof)
                args[1] = newPos.X
                args[2] = newPos.Y
                return old2(self2, table.unpack(args))
            end
        end
        return old2(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