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 task = task
local string = string
local table = table
local require = require
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 WaitForChild = game.WaitForChild
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 temphum = Instance.new("Humanoid")
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 MoveTo = temphum.MoveTo
local Lerp2D = Vector2.new().Lerp

--//Cleanup
Destroy(temphum)
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
}


--Test
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 and rpercent == self.RadiusPercentAt1 then
				distance = self.RadiusCap
            elseif self.FlickSettings.RadiusCap and rpercent == self.FlickSettings.RadiusPercentAt1 and distance >= self.FlickSettings.RadiusCap then
                distance = self.FlickSettings.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 peaking = false
	local lastframe = getclock()

	if not self.RenderStep then
        local sum = 0

		self.RenderStep = Connect(RunService.RenderStepped, function(delta)
            sum = sum + delta

            if sum >= 1 / 60 then
                if self.Enabled and relative then
                    if self.HoldControl and self.Holding or not self.HoldControl then
                       mousemoverel(relative.X, relative.Y)
                       relative = nil
                    end
                end

                sum = sum - 1 / 60
            end
		end)
	end

	if not self.Heartbeat then
        local sum = 0
		self.Heartbeat = Connect(RunService.Heartbeat, function(delta)

            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()


                                if self.AutoPeak.PointPosition and not peaking then
                                    local hum = lcharac and FindFirstChildOfClass(lcharac, "Humanoid")

                                    if hum then
                                        peaking = true

                                        Controls:Disable()
                                        MoveTo(hum, self.AutoPeak.PointPosition)

                                        local moveconn
                                        moveconn = Connect(hum.MoveToFinished, function()
                                            moveconn:Disconnect()
                                            moveconn = nil

                                            Controls:Enable()
                                            peaking = false
                                        end)

                                        task.delay(8, function()
                                            if moveconn then
                                                moveconn:Disconnect()
                                                moveconn = nil

                                                Controls:Enable()
                                                peaking = false
                                            end
                                        end)
                                    end
                                end
                            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) then
                            mspoof = nil
							if not (mtarget == charac:FindFirstChild("Left Arm") or mtarget == charac:FindFirstChild("Right Arm") or mtarget == charac:FindFirstChild("Left Leg") or mtarget == charac:FindFirstChild("Right Leg")) then
								self.Targets[plrz] = true
							end
						elseif silent then
                            mspoof = self:GetClosestEdgeFromViewportPoint(mpos, target)
                        else
                            mspoof = nil
                        end

						if self.Targets[plrz] then
							if self.Deadzone.Enabled then
                                target = (self.TargetPart and FindFirstChild(charac, self.TargetPart)) or target
                                local pos, onscreen = WorldToViewportPoint(camera, target.Position)
                                if onscreen and not self.Disabled 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
						end

                            --local pos, onscreen = WorldToViewportPoint(camera, target.Position)
                        local g = self.TargetPart and charac:FindFirstChild(self.TargetPart).Position or charac:FindFirstChild("HumanoidRootPart").Position
                        if g then

                            local pos, onscreen = WorldToViewportPoint(camera, g)
                            if onscreen and not self.Disabled then
								local mpos = self:GetMouseViewportPoint()
								local mtarget = self:GetTargetFromViewportPoint(mpos, 5000, cignore)

								if not mtarget or IsDescendantOf(mtarget, charac) and (mtarget == charac:FindFirstChild("Left Arm") or mtarget == charac:FindFirstChild("Right Arm") or mtarget == charac:FindFirstChild("Left Leg") or mtarget == charac:FindFirstChild("Right Leg")) or not IsDescendantOf(mtarget, charac) then
									if self.Targets[plrz] then
										local displ = (Vector2.new(pos.X, pos.Y) - mpos)
										local smoothing = Vector2.new(self.XSmoothingPercent * self.WidthFactor, self.YSmoothingPercent * self.WidthFactor)
										local rel = Vector2.new(displ.X, displ.Y) /  smoothing

										local rX = (rel.X < 1 and  rel.X > 0.001) and 1 or (rel.X < -0.001 and rel.X > -1) and -1 or rel.X
										local rY = (rel.Y < 1 and  rel.Y > 0.001) and 1 or (rel.Y < -0.001 and rel.Y > -1) and -1 or rel.Y

										relative = Vector2.new(rX, rY)
									else
										if self.FlickSettings.Flick then
											local displ = (Vector2.new(pos.X, pos.Y) - mpos)
											local smoothing = Vector2.new(self.FlickSettings.FlickXSmoothingPercent * self.WidthFactor, self.FlickSettings.FlickYSmoothingPercent * self.WidthFactor)
                                            local rel = Vector2.new(displ.X, displ.Y) / smoothing

                                            local rX = (rel.X < 1 and  rel.X > 0.001) and 1 or (rel.X < -0.001 and rel.X > -1) and -1 or rel.X
                                            local rY = (rel.Y < 1 and  rel.Y > 0.001) and 1 or (rel.Y < -0.001 and rel.Y > -1) and -1 or rel.Y

                                            relative = Vector2.new(rX, rY)
										end
									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

	self.InputConnection = Connect(UserInputService.InputBegan, function(key)
		if self.Enabled and self.AutoPeak.Enabled and key.UserInputType == Enum.UserInputType.MouseButton3 then
			local root = LocalPlayer.Character and FindFirstChild(LocalPlayer.Character, "HumanoidRootPart")

			if root then
				self.AutoPeak.PointPosition = not self.AutoPeak.PointPosition and root.Position or 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

	if self.InputConnection then
		Disconnect(self.InputConnection)
		self.InputConnection = 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