NPC Aimbot (VirtualUser)

																																			--[[

			                  __/\\\\____________/\\\\_________________________________________________________
							   _\/\\\\\\________/\\\\\\_________________________________________________________
			                    _\/\\\//\\\____/\\\//\\\_________________________________________________________
			                     _\/\\\\///\\\/\\\/_\/\\\_____/\\\\\_____/\\/\\\\\\\___/\\\\\\\\\\_____/\\\\\\\\__
			                      _\/\\\__\///\\\/___\/\\\___/\\\///\\\__\/\\\/////\\\_\/\\\//////____/\\\/////\\\_
			                       _\/\\\____\///_____\/\\\__/\\\__\//\\\_\/\\\___\///__\/\\\\\\\\\\__/\\\\\\\\\\\__
			                        _\/\\\_____________\/\\\_\//\\\__/\\\__\/\\\_________\////////\\\_\//\\///////___
			                         _\/\\\_____________\/\\\__\///\\\\\/___\/\\\__________/\\\\\\\\\\__\//\\\\\\\\\\_
			                          _\///______________\///_____\/////_____\///__________\//////////____\//////////__
										[A1.exe#1168]

									      									 FIRST PERSON SHOOTERS
                                                                            ------------------------
																				-: CHANGELOG :-
																			------------------------
																				4.5.3:
																					-- Added `protect_gui` to UI instances on synapse
																					- Significant Performance Enhancements (Shouldn't lag as much on any game)
																					- Aimbot now has range instead of depth
																					- Aimbot has mode option now
																					- Fixed ESP to cycle between 'All', 'Players', 'NPCs'
																					- Fixed Chams Transparency
																					- 4.x emphasizes the focus on including NPCs
																					- Completely rewrote ESP
																					- Completely rewrote Chams
																					- Aimbot uses mouse (Change Depth if it doesn't Detect NPCs)
																					- Changed default chams transparency to 0.9

																			------------------------
																				   -: NOTES :-
																			------------------------
																				- Pressing `Esc` lets u focus on using this menu fully
																				- This script relies heavily on Synapse's anti CoreGui detection methods.
																				- Use at your own risk.
																				- This script is laggy on some games... It is what it is.
																				- Games with custom drag implementations kinda screw this script

																				Esp:
																					- This is pretty much safe.
																				Chams:
																					- This is very easily detected.
																					- Be careful using this.
																				Aimbot:
																					- This is pretty much safe, as it
																					relies entirely on dragging the mouse.
																					- Works better on lower sensitivities
																					- Players within CloseRange (75 studs)
																					are targeted by who's closest.
																					- Increase depth to search workspace
																					further. Some games hide NPCs deeper in folders.
																				Fullbright:
																					- Messes with stuff, might get you banned.
																				Floaty:
																					- Messes with stuff, might get you banned.

																			------------------------
																				 -: CONTROLS :-
																			------------------------
																				Menu:
																					Delete - Toggle

																				Chams:
																					Click [Toggle] to cycle colors

																				Aimbot:
																					H - Toggle
																					U - Up
																					J - Down

																				Floaty:
																					N - Still
																					B - Up
																					M - Down


																																			--]]

local IsScreenActive = true
local UserInputService = game:GetService("UserInputService")
UserInputService.WindowFocusReleased:Connect(function()
	IsScreenActive = false
end)
UserInputService.WindowFocused:Connect(function()
	IsScreenActive = true
end)

local GameSettings = UserSettings():GetService('UserGameSettings')
local CoreGUI = game:GetService('CoreGui')

local Run = game:GetService('RunService');
local World = game:GetService('Workspace');
local Input = game:GetService('UserInputService');
local Lighting = game:GetService('Lighting');
local Players = game:GetService('Players');
local Player = Players['LocalPlayer'];
local PlayerMouse = Player:GetMouse()
local PlayerCamera = World.CurrentCamera
local PlayerModel = Player.Character or Player.CharacterAdded:wait()

local Temp = {}
local Targets = {}
local Inputs = {}
local Keys = {}
local Events = {
	Targets = Instance.new('BindableEvent')
}

local VirtualUser = game:GetService("VirtualUser")


local Settings = {
	-- Order and Defaults --
	Menu = {
		Defaults = {
			{'Menu', false, Enum.KeyCode.Delete},
			{'Team Chams', true, '<-'},
			{'Enemy Chams', true, '<-'},
			{'Toggle Chams', true, '<-'},
			{'Fullbright', true, '\'MAX\''},
			{'Floaty', true, '\'Still\''},
			{'Aimbot', true, '<-'},
			{'Aimbot Mode', false, '<-'},
			{'ESP', true, '<-'},
			{'Written by: A1.exe#1168', false, 'Discord'}
		},

		Colors = {
			Enabled 		= Color3.fromRGB(46, 105, 132),
			Disabled 		= Color3.fromRGB(97, 97, 97),
		}
	},

	--- ESP ---
	ESP = {
		Enabled = false,
		Options = {'All', 'Players', 'NPCs'},
		Current = 1
	},

	--- Chams ---
	Chams = {
		Enabled = false,
		Transparency = 0.9,

		Team = {
			Enabled = false,
			Color = {'Grey', 	Color3.fromRGB(204, 204, 204)}
		},

		Enemy = {
			Enabled = false,
			Color = {'Red', 	Color3.fromRGB(255, 0, 0)}
		},

		Colors = {
			{'White', 	Color3.fromRGB(255, 255, 255)},
			{'Black', 	Color3.fromRGB(0, 0, 0)},
			{'Grey', 	Color3.fromRGB(204, 204, 204)},
			{'Red', 	Color3.fromRGB(255, 0, 0)},
			{'Yellow',  Color3.fromRGB(255, 255, 0)},
			{'Purple', 	Color3.fromRGB(166, 0, 166)},
			{'Blue', 	Color3.fromRGB(0, 0, 255)},
			{'Green', 	Color3.fromRGB(0, 255, 0)},
		},
	},

	--- Aimbot ---
	Aimbot = {
		Enabled = false,
		Mode = 3,
		ModeOptions = {'All', 'Players', 'NPCs'},
		Range = 1,
		RangeOptions = {math.huge, 100, 250, 500, 750, 1000, 1250, 1500, 1750, 2000, 2500, 5000},
		CloseRange = -1,
		Selection = {},
		Selected = 1,
		Scrolled = 0,
		Status = {},
		Menu = {
			{'Enabled', false},		-- // Toggle aimbot
			{'TeamCheck', false},  	-- // Check team
			{'HeadsOnly', true},  	-- // Only target head
			{'Shake', false},		-- // Shake mouse between body and head
			{'RayCheck', true},		-- // Obstacles exist
			{'CamCheck', false}, 	-- // Don't check inside the camera
			{'AutoAim', false},		-- // No need to hold mouse
			{'Hide Menu', false},  	-- // Hide the ui
		}
	},

	--- Floaty ---
	Floaty = {
		Enabled = false,
		Height = 3.9,
		Current = 1,
		Options = {'Still', 'Up', 'Down'}
	},

	--- Fullbright ---
	Fullbright = {
		Enabled = false,
		Current = 1,
		Options = {'Max', 'Half', 'Default'},
		OptionDefs = {
			Max = {
				Fog = 1000000,
				Brightness = 10,
				InAmbience = Color3.new(1, 1, 1),
				OutAmbience = Color3.new(1, 1, 1),
			},
			Half = {
				Fog = 250,
				Brightness = 1.5,
				InAmbience = Color3.fromRGB(153, 153, 153),
				OutAmbience = Color3.fromRGB(153, 153, 153),
			},
			Default = {
				Fog = Lighting.FogEnd,
				Brightness = Lighting.Brightness,
				InAmbience = Lighting.Ambient,
				OutAmbience = Lighting.OutdoorAmbient
			}
		}
	}
}

---- LOAD EVENTS ----
for name, tab in next, (Settings) do
	Events[name] = Instance.new('BindableEvent')
end
---------------------


local function GetFunc(tab, name)
	for funcName, func in next, (tab) do
		if funcName == name then
			return func, funcName
		end
	end
end

local function GetColor(tab, name)
	for index, colortab in next, (tab) do
		if (colortab[1] == name) then
			return colortab, index
		elseif (colortab[2] == name) then
			return colortab, index
		end
	end
end

------------ [[ GUI SPAWN ]] ------------
FormAssets = function()
	------ ERROR MAGIC ------
	local __ERROR__ = Instance.new('BindableEvent')
	__ERROR__['Event']:Connect(error)

	--------- CREATE FUNCTION ---------
	local create = function(class, parent)
		local instance = Instance.new(class);

		if instance:IsA('GuiObject') and syn and syn.protect_gui then
			syn.protect_gui(instance)
		end

		return function(props)
			for property, value in next, (props) do
				if (property ~= 'Parent') and (typeof(value) ~= 'Instance') then
					local suc, err = pcall(function()
						instance[property] = value
					end)
					if not suc then __ERROR__:Fire('[Script->Asset]: ' .. err) end

				elseif (property == 'Parent') then
					parent = value
				end
			end

			if parent and (typeof(parent) == 'Instance') then
				instance['Parent'] = parent
			end

			return instance
		end
	end

	-------------------------------------
	-------------------------------------
	-- SOME THINGS MAY BE OUT OF ORDER --
	----(INSTANCE RELATED PROPERTIES)----
	-------------(UNLIKELY)--------------
	-------------------------------------
	-------------------------------------

	local Main = create('ScreenGui'){
		Name = 'FPS Hacks - Menu'
	}

	local Folder = create('Folder', Main){
		Name = 'Chams'
	}

	local Folder1 = create('Folder', Folder){
		Name = 'Team'
	}

	local Folder2 = create('Folder', Folder){
		Name = 'Enemy'
	}

	local Folder3 = create('Folder', Main){
		Name = 'ESP'
	}

	local Frame = create('Frame', Main){
		Name 					= 'Main';
		BackgroundColor3		= Color3.new(1, 1, 1);
		BackgroundTransparency 	= 1;
		Position 				= UDim2.new(0.5, 0, 0.5, 0);
		Size 					= UDim2.new(0, 250, 0, 190);
		Draggable				= true;
		Active 					= true;
		AnchorPoint 			= Vector2.new(0.5, 0.5);
		Transparency 			= 1
	}

	local TextLabel = create('TextLabel', Frame){
		Name 					= 'Title';
		BackgroundColor3		= Color3.new(0.180392, 0.411765, 0.517647);
		BorderSizePixel			= 0;
		Size 					= UDim2.new(1, 0, 0, 35);
		Text 					= 'FPS Hacks v4.5.3';
		TextColor3 				= Color3.new(0.866667, 0.843137, 0.843137);
		Font 					= Enum.Font.SciFi;
		FontSize 				= Enum.FontSize.Size28;
		TextWrapped				= true
	}

	local ScrollingFrame = create('ScrollingFrame', Frame){
		Name 					= 'Buttons';
		BackgroundColor3		= Color3.new(1, 1, 1);
		BackgroundTransparency	= 1;
		BorderSizePixel			= 0;
		Position 				= UDim2.new(0.5, 0, 0, 40);
		CanvasSize 				= UDim2.new(0, 0, 0, 0);
		Size 					= UDim2.new(1, 0, 0, 290);
		AnchorPoint				= Vector2.new(0.5, 0);
		Transparency 			= 1
	}

	local Frame1 = create('Frame'){
		BackgroundColor3		= Color3.new(1, 1, 1);
		BackgroundTransparency	= 1;
		BorderSizePixel			= 0;
		Position 				= UDim2.new(0, 0, 0, 1);
		Selectable 				= true;
		Size 					= UDim2.new(1, 0, 0, 25);
		ClipsDescendants		= true;
		Transparency 			= 1
	}

	local TextLabel1 = create('TextButton', Frame1){
		Name 					= 'Text';
		BackgroundColor3		= Color3.new(1, 1, 1);
		BorderColor3			= Color3.new(0.180392, 0.411765, 0.517647);
		Position 				= UDim2.new(0.100000001, 0, 0, 0);
		Size 					= UDim2.new(0.600000024, 0, 1, 0);
		Text 					= 'Example';
		TextColor3 				= Color3.new(0.180392, 0.411765, 0.517647);
		Font 					= Enum.Font.SciFi;
		FontSize 				= Enum.FontSize.Size14
	}

	local Frame2 = create('Frame', Frame1){
		Name 					= 'Status';
		BackgroundColor3		= Color3.new(0, 1, 0);
		BorderSizePixel			= 0;
		Position 				= UDim2.new(0.0250000004, 0, 0.5, 0);
		Size 					= UDim2.new(0, 7, 0, 7);
		Style 					= Enum.FrameStyle.DropShadow;
		AnchorPoint				= Vector2.new(0, 0.5)
	}

	local TextButton = create('TextButton', Frame1){
		Name 					= 'Key';
		BackgroundColor3		= Color3.new(0.180392, 0.411765, 0.517647);
		BackgroundTransparency	= 0.5;
		BorderSizePixel			= 0;
		Position 				= UDim2.new(0.699999988, 0, 0, 0);
		Size 					= UDim2.new(0.300000012, 0, 1, 0);
		Text 					= '[EXAMPLE]';
		TextColor3 				= Color3.new(0.839216, 0.839216, 0.839216);
		Font 					= Enum.Font.SciFi;
		FontSize 				= Enum.FontSize.Size14;
		TextStrokeColor3		= Color3.new(0.380392, 0.380392, 0.380392);
		TextStrokeTransparency	= 0;
		Transparency 			= 0.5
	}

	local UIListLayout = create('UIListLayout', ScrollingFrame){
		Padding 				= UDim.new(0, 4);
		HorizontalAlignment 	= Enum.HorizontalAlignment.Center
	}

	local UIPadding = create('UIPadding', ScrollingFrame){}

	local ESP_GUI = create('BillboardGui'){
		Active 					= true;
		AlwaysOnTop				= true;
		StudsOffsetWorldSpace	= Vector3.new(0, 4, 0);
		Size 					= UDim2.new(0, 25, 0, 12)
	}

	create('TextLabel', ESP_GUI){
		Name 					= 'Target';
		BackgroundColor3		= Color3.new(1, 1, 1);
		BackgroundTransparency	= 1;
		BorderSizePixel			= 0;
		Size 					= UDim2.new(1, 0, 0, 20);
		Text 					= '';
		TextColor3 				= Color3.new(1, 0, 0);
		Font 					= Enum.Font.GothamBlack;
		TextSize 				= 16;
		TextScaled				= true;
		TextStrokeTransparency	= 0.20000000298023;
		TextWrapped				= true
	}

	create('TextLabel', ESP_GUI){
		Name 					= 'Dist';
		BackgroundColor3		= Color3.new(1, 1, 1);
		BackgroundTransparency	= 1;
		Position 				= UDim2.new(0, 0, 0.349999994, 0);
		Size 					= UDim2.new(1, 0, 0, 20);
		Text 					= '';
		TextColor3 				= Color3.new(1, 0, 0.498039);
		Font 					= Enum.Font.Ubuntu;
		FontSize 				= Enum.FontSize.Size14;
		TextScaled 				= true;
		TextStrokeTransparency	= 0.20000000298023;
		TextWrapped				= true
	}


	local Float = function()
		return create('Part', World){
			Size = Vector3.new(6, 1.8, 6);
			Transparency = 1;
			CanCollide = false;
			Anchored = true
		}
	end

	return create, Main, Frame1, Folder, Folder3, ESP_GUI, Float
end

local Create, Menu, Button, Chams, ESPFolder, Billboard, Float = FormAssets()

local Functions;
Functions = {
	['Menu'] 		= function()
		Menu['Enabled'] = not (Menu['Enabled']);
	end;

	['Floaty'] = function(change)
		local FloatySettings = Settings.Floaty
		if not Floaty then Floaty = Float() end

		if (change:lower() == 'toggle') then
			FloatySettings.Enabled = not FloatySettings.Enabled
		end

		if (change:lower() == 'up') then
			FloatySettings.Height = 2
			FloatySettings.UI.Key.Text = '[ \'UP\' ]'
			return
		elseif (change:lower() == 'still') then
			FloatySettings.Height = 3.9
			FloatySettings.UI.Key.Text = '[ \'STILL\' ]'
			return
		elseif (change:lower() == 'down') then
			FloatySettings.Height = 6
			FloatySettings.UI.Key.Text = '[ \'DOWN\' ]'
			return
		end

		if FloatySettings.Enabled then
			Floaty.CanCollide = true

			coroutine.wrap(function()
				while FloatySettings.Enabled and wait() and Floaty do
					local Char = Player.Character or Player.CharacterAdded:wait()
					local RootPart = Char and Char:FindFirstChild('HumanoidRootPart')

					if RootPart then
						Floaty.CFrame = CFrame.new(RootPart.CFrame.x, RootPart.CFrame.y - FloatySettings.Height, RootPart.CFrame.z)
					end
				end

				if Foaty then
					Floaty.CanCollide = false
				end
			end)()
		elseif Floaty then
			Floaty.CanCollide = false
		end
	end;

	['ESP'] = function()
		local ESPSettings = Settings.ESP

		ESPSettings.Enabled = not ESPSettings.Enabled

		ESPFolder:ClearAllChildren()
		if ESPSettings.Enabled then
			if Temp['ESP'] then
				Temp['ESP']:Disconnect()
				Temp['ESP'] = nil
			end

			local function HandleESP(model, player)
				if (player == Player) then return end

				local RootPart = model:WaitForChild('HumanoidRootPart', 1)
				if not RootPart then return end

				local Bill = Billboard:Clone()
				local Folder, targetCon, playerCon;
				local modeModel = (player and ESPSettings.Options[2]) or ESPSettings.Options[3]
				local modeESP = ESPSettings.Options[ESPSettings.Current]

				if player then
					local name = player['Name']
					if (#name > 20) then
						name = name:sub(1, 20) .. '...'
					end

					local teammate = (player.TeamColor == Player.TeamColor)
					Folder = Create('Folder', ESPFolder){Name = name}
					Bill.Target.Text 		= name..(((player.TeamColor == Player.TeamColor) and ' [T]') or '')
					Bill.Target.TextColor3 	= player.TeamColor.Color

					local function teamChanged()
						local name = player['Name']
						if (#name > 20) then
							name = name:sub(1, 20) .. '...'
						end

						Bill.Target.Text 		= name..(((player.TeamColor == Player.TeamColor) and ' [T]') or '')
						Bill.Target.TextColor3 	= player.TeamColor.Color
					end

					targetCon = player:GetPropertyChangedSignal('TeamColor'):Connect(teamChanged)
					playerCon = Player:GetPropertyChangedSignal('TeamColor'):Connect(teamChanged)
				else
					local name = model['Name']
					if (#name > 20) then
						name = name:sub(1, 20) .. '...'
					end

					Folder = Create('Folder', ESPFolder){Name = 'NPC: '..name}
					Bill.Target.Text 		= 'NPC: '..name
				end

				Bill.Enabled 			= (ESPSettings.Current == 1) or (modeESP == modeModel)
				Bill.Adornee 			= RootPart
				Bill.Parent 			= Folder

				local modeChanged = Events.ESP.Event:Connect(function(kind)
					if kind == 'change' then
						modeESP 		= ESPSettings.Options[ESPSettings.Current]
						Bill.Enabled 	= (ESPSettings.Current == 1) or (modeESP == modeModel)
					end
				end)

				PlayerModel = Player.Character or Player.CharacterAdded:wait()

				while model:IsDescendantOf(World) and Folder:IsDescendantOf(CoreGUI) and ESPSettings.Enabled do
					local CHRP = PlayerModel and PlayerModel:FindFirstChild('HumanoidRootPart')
					if CHRP then
						Bill.Dist.Text = ""
					end

					wait()
				end

				Folder.Parent = nil
				if targetCon then targetCon:Disconnect() end
				if playerCon then playerCon:Disconnect() end
				modeChanged:Disconnect()
			end

			for model, player in next, (Targets) do
				if not ESPSettings.Enabled then
					break
				end

				coroutine.wrap(function()
					HandleESP(model, player)
				end)()
			end

			if not ESPSettings.Enabled then return end
			Temp['ESP'] = Events.Targets.Event:Connect(function(kind, model)
				if (kind == 'added') then
					coroutine.wrap(function()
						HandleESP(model, Targets[model])
					end)()
				end
			end)

		elseif Temp['ESP'] then
			Temp['ESP']:Disconnect()
			Temp['ESP'] = nil
		end
	end,

	['Team Chams'] = function(mainbutton)
		local TeamSettings = Settings.Chams.Team
		if mainbutton then
			TeamSettings.Enabled = not TeamSettings.Enabled
		end

		for __, handle in next, (Chams['Team']:GetDescendants()) do
			if handle:IsA('BoxHandleAdornment') then
				handle.Color3 = TeamSettings.Color[2]
				handle.Visible = TeamSettings.Enabled
			end
		end
	end,

	['Enemy Chams'] = function(mainbutton)
		local ChamSettings = Settings.Chams
		local EnemySettings = ChamSettings.Enemy
		if mainbutton then
			EnemySettings.Enabled = not EnemySettings.Enabled
		end

		for __, handle in next, (Chams['Enemy']:GetDescendants()) do
			if handle:IsA('BoxHandleAdornment') then
				handle.Color3 = EnemySettings.Color[2]
				handle.Visible = EnemySettings.Enabled
			end
		end
	end,

	['Toggle Chams'] = function()
		local ChamSettings = Settings.Chams
		local TeamSettings = ChamSettings.Team
		local EnemySettings = ChamSettings.Enemy

		ChamSettings.Enabled = not ChamSettings.Enabled
		Chams['Team']:ClearAllChildren()
		Chams['Enemy']:ClearAllChildren()

		if ChamSettings.Enabled then
			local function HandleChams(model, player)
				if (player == Player) then return end

				local RootPart = model:WaitForChild('HumanoidRootPart', 1)
				if not RootPart or (not player and #model:GetDescendants() > 300) then
					return
				end

				local Folder, FoldCon, pTeamCon, PTeamCon, ModelCon;
				local isFriendly = player and (player.TeamColor == Player.TeamColor)
				if player then
					Folder = Create('Folder', (isFriendly and Chams['Team']) or Chams['Enemy']){Name = player['Name']}

					local function teamChanged()
						if not Folder:IsDescendantOf(CoreGUI) then
							if pTeamCon then pTeamCon:Disconnect() end
							if PTeamCon then PTeamCon:Disconnect() end
							return
						end

						isFriendly = (player.TeamColor == Player.TeamColor)
						if isFriendly then
							if Folder:IsDescendantOf(Chams['Enemy']) then
								Folder.Parent = Chams['Team']
							end

							for __, handle in next, (Folder:GetChildren()) do
								handle.Color3 = TeamSettings.Color[2]
								handle.Visible = TeamSettings.Enabled
							end
						else
							if Folder:IsDescendantOf(Chams['Team']) then
								Folder.Parent = Chams['Enemy']
							end

							for __, handle in next, (Folder:GetChildren()) do
								handle.Color3 = EnemySettings.Color[2]
								handle.Visible = EnemySettings.Enabled
							end
						end
					end

					pTeamCon = player:GetPropertyChangedSignal('TeamColor'):Connect(teamChanged)
					PTeamCon = Player:GetPropertyChangedSignal('TeamColor'):Connect(teamChanged)

				else
					Folder = Create('Folder', Chams['Enemy']){Name = model['Name']}
				end

				for __, part in next, (model:GetChildren()) do
					if part:IsA('BasePart') then
						if isFriendly then
							Create('BoxHandleAdornment', Folder)
							{
								Color3 = TeamSettings.Color[2];
								AlwaysOnTop = true;
								Transparency = ChamSettings.Transparency;
								Visible = TeamSettings.Enabled;
								ZIndex = 10;

								Size = (part['Name'] == 'Head' and Vector3.new(1.25, 1.3, 1.25))
									or (Vector3.new(.5, .5, .5) + part.Size)
							}['Adornee'] = part
						else
							Create('BoxHandleAdornment', Folder)
							{
								Color3 = EnemySettings.Color[2];
								AlwaysOnTop = true;
								Transparency = ChamSettings.Transparency;
								Visible = EnemySettings.Enabled;
								ZIndex = 10;

								Size = (part['Name'] == 'Head' and Vector3.new(1.25, 1.3, 1.25))
									or (Vector3.new(.5, .5, .5) + part.Size)
							}['Adornee'] = part
						end
					end
				end

				FoldCon = Folder:GetPropertyChangedSignal('Parent'):Connect(function()
					if not Folder:IsDescendantOf(CoreGUI) then
						if pTeamCon then pTeamCon:Disconnect() end
						if PTeamCon then PTeamCon:Disconnect() end
						if ModelCon then ModelCon:Disconnect() end

						FoldCon:Disconnect()
					end
				end)

				if not model:IsDescendantOf(World) or not Folder:IsDescendantOf(CoreGUI) then
					if pTeamCon then pTeamCon:Disconnect() end
					if PTeamCon then PTeamCon:Disconnect() end
					if FoldCon then FoldCon:Disconnect() end

					Folder.Parent = nil
				end
				ModelCon = Events.Targets.Event:Connect(function(kind, rmodel)
					if (kind == 'removed') and (rmodel == model) then
						if pTeamCon then pTeamCon:Disconnect() end
						if PTeamCon then PTeamCon:Disconnect() end
						if FoldCon then FoldCon:Disconnect() end

						Folder.Parent = nil
						ModelCon:Disconnect()
					end
				end)
			end

			for model, player in next, (Targets) do
				if not ChamSettings.Enabled then
					break
				end

				coroutine.wrap(function()
					HandleChams(model, player)
				end)()
			end

			if not ChamSettings.Enabled then return end
			Temp['Chams'] = Events.Targets.Event:Connect(function(kind, model)
				if (kind == 'added') then
					coroutine.wrap(function()
						HandleChams(model, Targets[model])
					end)()
				end
			end)

		elseif Temp['Chams'] then
			Temp['Chams']:Disconnect()
			Temp['Chams'] = nil
		end
	end,

	['Fullbright'] = function(mainbutton)
		local Fullbright = Settings.Fullbright
		if mainbutton then
			Fullbright.Enabled = not Fullbright.Enabled
		end

		local function Handle()
			local Setting = Fullbright.Options[Fullbright.Current]
			local Settings = Fullbright.OptionDefs[Setting]


			Fullbright.UI.Key['Text'] = '[ \'' .. Setting .. '\' ]'
			Lighting.Ambient = Settings.InAmbience;
			Lighting.OutdoorAmbient = Settings.OutAmbience;
			Lighting.Brightness = Settings.Brightness;
			Lighting.FogStart = Settings.Fog;
			Lighting.FogEnd = Settings.Fog;
		end

		if (not Fullbright.Enabled) then
			Fullbright.Current = 3
		end

		Handle()
	end;

	['Aimbot'] = function(Aimbot)
		local IgnorePlayersNamed = {A1_exe=true} -- Name = true or false
		--[[
			[J] - To go down the list.
			[U] - To go up the list.
			[H] - To toggle that item in the list.
			[RMB] - To aim at your target using the current settings. (THIS UPDATES IN LIVE TIME SO YOU DON'T HAVE TO STOP AIMING FOR IT TO TAKE EFFECT)
		--]]

		local ResizeUI = function(ui,downscale,byclass)
			if not rawequal(ui['ClassName'], 'ScrollingFrame') then return end

			local count = 0;
			for __, asset in next, (ui:GetChildren()) do
				if rawequal(asset['ClassName'],byclass) then
					count = count + 1
				end
			end

			ui['CanvasSize'] = UDim2.new(ui.CanvasSize.X.Scale,ui.CanvasSize.X.Offset,ui.CanvasSize.Y.Scale,downscale*count)
		end

		local ffc, ffoc, cast, ray = World.FindFirstChild, World.FindFirstChildOfClass, World.FindPartOnRayWithIgnoreList, Ray.new
		local selection, status = Aimbot.Selection, Aimbot.Status

		local MakeAimUI = function()
			local GUI = Create('ScreenGui', CoreGUI){
				Name = '___';
				On
			}

			local Frame = Create('ScrollingFrame', GUI){
				BackgroundTransparency	= 1,
				BorderSizePixel			= 0,
				Name 					= 'Options',
				Position 				= UDim2.new(.8,0,.915,0),
				Size 					= UDim2.new(.2,0,0,30),
				ZIndex 					= 10,
				ClipsDescendants		= true,
				CanvasSize 				= UDim2.new(0,0,0,0),
				CanvasPosition 			= Vector2.new(0, current_pos),
				ScrollBarThickness 		= 0,
				ScrollingEnabled 		= false,
			}

			local UILL 					= Create('UIListLayout', Frame){
				Name 					= 'LayoutHandler',
				FillDirection			= 'Vertical',
				HorizontalAlignment		= 'Center',
				SortOrder 				= 'LayoutOrder',
				VerticalAlignment		= 'Top'
			}

			local Template = Create('TextButton'){
				BackgroundTransparency	= 1,
				BorderSizePixel			= 0,
				Name 					= 'Template',
				Size 					= UDim2.new(.9,0,0,30),
				Font 					= 'SciFi',
				Text 					= '',
				TextColor3 				= Color3.fromRGB(255,255,255),
				TextScaled 				= true,
				TextWrapped 		          	= true,
			}

			local TSC = Create('UISizeConstraint', Template){
				Name 					= 'TemplateSizeConstraint',
				MaxSize 				= Vector2.new(math.huge,30),
			}

			Frame['ChildAdded']:Connect(function()
				ResizeUI(Frame, 30, 'TextButton')
			end)

			for ___, packed_option in next, Aimbot.Menu do
				local option, val = unpack(packed_option)
				status[option] = val

				local tp = Template:Clone()
				tp.LayoutOrder = sel_pos
				tp.Name = option

				if option:match('Hide') then
					tp.Text = ':: ' .. option .. ' ::'
					tp.TextColor3 = Color3.fromRGB(220, 100, 220)
				else
					tp.Text = option .. ': ' .. tostring(val)
					if status[option] then
						tp.TextColor3 = Color3.fromRGB(0,255,0)
					else
						tp.TextColor3 = Color3.fromRGB(255,0,0)
					end
				end

				table.insert(selection, tp)
				tp.Parent = Frame
			end

			return Frame
		end

		local ActiveUI = MakeAimUI()
		Aimbot.ActiveUI = ActiveUI

		local function cast_ray(p0,p1,blacklist)
			local Part
			local __=0
			repeat
				__=__+1
				local cond=(p1-p0).magnitude < 999
				Part,p0=cast(workspace,ray(p0,cond and p1-p0 or (p1-p0).unit*999),blacklist)
				if Part then
					local pname = tostring(Part):lower()
					if Part.CanCollide == false or Part.Transparency >= 0.7 or ((pname:match('glass') or pname:match('window')) and Part.Transparency >= .3) or ffoc(Part.Parent, 'Humanoid') then
						blacklist[#blacklist+1]=Part
						Part=nil
					end
				elseif cond or __ > 15 then
					break
				end
			until Part
			return Part,p0
		end

		Run.RenderStepped:Connect(function()
			if status['Enabled'] and (Inputs[Enum.UserInputType.MouseButton2] or status['AutoAim']) then
				local close, range, dot, face = false, math.huge, -1
				for model, player in next, (Targets) do
					if (player == Player) then continue end
					if not status['CamCheck'] and model:IsDescendantOf(PlayerCamera) then
						continue
					end

					local modeModel = (player and Aimbot.ModeOptions[2]) or Aimbot.ModeOptions[3]
					local modeAimbot = Aimbot.ModeOptions[Aimbot.Mode]
					if (Aimbot.Mode ~= 1) and (modeModel ~= modeAimbot) then
						continue
					end

					local hum = ffoc(model, 'Humanoid')
					local root = ffc(model, 'HumanoidRootPart')
					local head = ffc(model, 'Head')


					if root ~= nil then
						    local camera135 = workspace.CurrentCamera
    						local vector, onScreen = camera135:WorldToViewportPoint(root.position)
							if not onScreen then
								continue
							end
					end


					if not Inputs[Enum.UserInputType.MouseButton2] and not status['AutoAim'] then return end

					if IgnorePlayersNamed[model['Name']] or (player and IgnorePlayersNamed[player['Name']]) or ffoc(model, 'ForceField') then continue end

					if not root or (status['HeadsOnly'] and not head) then continue end

					if hum and hum['Health'] > 0 then
						if player and status['TeamCheck'] then
							if Player['TeamColor'] == player['TeamColor'] then
								continue
							end
						end

						local cc 		= PlayerCamera.CFrame
						local pos 		= ((head and (status['HeadsOnly'] or (status['Shake'] and math.random(1, 10) < 6))) and head.Position) or root.Position
						local dist 		= (pos-cc.p).magnitude

						local RangeVal = Aimbot.RangeOptions[Aimbot.Range]
						if (RangeVal ~= math.huge) and (dist > RangeVal) then
							continue
						end

						local hitPart;
						if status['RayCheck'] then
							hitPart = cast_ray(cc.p,pos,{PlayerCamera,PlayerModel})
						end
						if not (status['RayCheck'] and hitPart) or model:IsAncestorOf(hitPart) then
							local m = (pos-cc.p).unit:Dot(cc.lookVector)

							if (dist <= Aimbot.CloseRange) then
								close = true
							end

							if close then
								if (dist < range) then
									dot, face, range = m, pos, dist
								end
							elseif (m > dot) then
								dot, face, range = m, pos, dist
							end
						end
					end
				end

				if face then


					if IsScreenActive then
						--PlayerCamera.CFrame = CFrame.new(PlayerCamera.CFrame.p,face) * CFrame.new(0,0,0.5)
                        local Pos, InFront = PlayerCamera:WorldToScreenPoint(face)
                        local TargetX, TargetY = (InFront and Pos.x) or -Pos.x, Pos.y
                        local MouseX, MouseY = PlayerMouse.X, PlayerMouse.Y
                        local NewX, NewY = math.abs(MouseX - TargetX), math.abs(MouseY - TargetY)
                        local Inc = GameSettings.MouseSensitivity * (17/3)

                        if (MouseX > TargetX) then
                            NewX = -NewX/Inc
                        else
                            NewX = NewX/Inc
                        end

                        if (MouseY > TargetY) then
                            NewY = -NewY/Inc
                        else
                            NewY = NewY/Inc
                        end
                        --mousemoveabs(TargetX/Inc, TargetY/Inc)
						VirtualUser:MoveMouse(Vector2.new(TargetX/Inc, TargetY/Inc), PlayerCamera.CFrame)
                    end
				end
			end
		end)
	end
}


for __, option in next, (Settings.Menu.Defaults) do
	local Name, Functional, Setting = unpack(option)
	local Func = GetFunc(Functions, Name)
	local NewOption = Button:Clone()

	if Name == 'Menu' or Name:match('Written') then
		NewOption['Status']['Style'] = 'Custom';
		NewOption['Key']['TextStrokeColor3'] = Settings.Menu.Colors.Enabled
	end

	NewOption['Text'].Text = Name
	NewOption['Key'].Text = '[ '.. ((typeof(Setting) == 'EnumItem' and Setting.Name) or Setting) .. ' ]'
	NewOption.Parent = Menu['Main']['Buttons']

	if Func then
		NewOption['Text']['MouseButton1Down']:Connect(function()
			if not Functional then return end
			if NewOption.Status.Style.Name == 'DropShadow' then
				NewOption.Status.Style = 'Custom'
				NewOption['Key']['TextStrokeColor3'] = Settings.Menu.Colors.Enabled
			elseif NewOption.Status.Style.Name == 'Custom' and not Name:match('Aimbot') then
				NewOption.Status.Style = 'DropShadow'
				NewOption['Key']['TextStrokeColor3'] = Settings.Menu.Colors.Disabled
			end

			if (Name == 'Aimbot') and not Settings.Aimbot.Enabled then
				Settings.Aimbot.Enabled = true

				-- Activate Mode UI --
				Settings.Aimbot.ModeUI.Status.Style = 'Custom'
				Settings.Aimbot.ModeUI['Key']['TextStrokeColor3'] = Settings.Menu.Colors.Enabled
				----------------------

				Func(Settings.Aimbot)

			elseif (Name == 'Floaty') then
				Func('Toggle')

			else
				Func(true)
			end
		end)
	end

	if Name:match('Chams') then
		local ChamSettings = Settings.Chams
		local TeamSettings = ChamSettings.Team
		local EnemySettings = ChamSettings.Enemy

		if Name == 'Team Chams' then
			NewOption['Key'].Text = '[ \''..TeamSettings.Color[1]..'\' ]'

			NewOption['Key']['MouseButton1Down']:Connect(function()
				local ChamColors = ChamSettings.Colors
				if not TeamSettings.Enabled then return end
				local Tab, Pos = GetColor(ChamColors, TeamSettings.Color[1])

				if (Pos + 1) < #ChamColors then
					TeamSettings.Color = ChamColors[Pos + 1]
				else
					TeamSettings.Color = ChamColors[1]
				end

				NewOption['Key'].Text = '[ \''..TeamSettings.Color[1]..'\' ]'
				Func()
			end)

		elseif Name == 'Enemy Chams' then
			NewOption['Key'].Text = '[ \''..EnemySettings.Color[1]..'\' ]'

			NewOption['Key']['MouseButton1Down']:Connect(function()
				local ChamColors = ChamSettings.Colors
				if not EnemySettings.Enabled then return end
				local Tab, Pos = GetColor(ChamColors, EnemySettings.Color[1])

				if (Pos + 1) < #ChamColors then
					EnemySettings.Color = ChamColors[Pos + 1]
				else
					EnemySettings.Color = ChamColors[1]
				end

				NewOption['Key'].Text = '[ \''..EnemySettings.Color[1]..'\' ]'
				Func()
			end)

		elseif Name == 'Toggle Chams' then
			NewOption['Key'].Text = '[ \'' .. ChamSettings.Transparency .. '\' ]'

			NewOption['Key']['MouseButton1Down']:Connect(function()
				if not ChamSettings.Enabled then return end

				local Trans = ChamSettings.Transparency
				ChamSettings.Transparency = (Trans < .8 and Trans + (1/10)) or 0

				for __, handle in next, (Chams:GetDescendants()) do
					if handle:IsA('BoxHandleAdornment') then
						handle.Transparency = ChamSettings.Transparency
					end
				end

				NewOption['Key'].Text = '[ \'' .. ChamSettings.Transparency .. '\' ]'
			end)
		end
	elseif Name == 'Fullbright' then
		local Fullbright = Settings.Fullbright
		Fullbright.UI = NewOption

		NewOption['Key']['MouseButton1Down']:Connect(function()
			if not Fullbright.Enabled then return end
			if Fullbright.Current < #Fullbright.Options	 then
				Fullbright.Current = Fullbright.Current + 1
			else
				Fullbright.Current = 1
			end
			Func(false)
		end)

	elseif Name == 'ESP' then
		local ESP = Settings.ESP
		NewOption['Key'].Text = '[ \'' .. ESP.Options[ESP.Current] .. '\' ]'

		NewOption['Key']['MouseButton1Down']:Connect(function()
			if not ESP.Enabled then return end
			if ESP.Current < #ESP.Options	 then
				ESP.Current = ESP.Current + 1
			else
				ESP.Current = 1
			end

			Events.ESP:Fire('change')
			NewOption['Key'].Text = '[ \'' .. ESP.Options[ESP.Current] .. '\' ]'
		end)
	elseif Name == 'Aimbot' then
		local Aimbot = Settings.Aimbot
		local RangeVal = Aimbot.RangeOptions[Aimbot.Range]
		if RangeVal == math.huge then
			NewOption['Key'].Text = '[ ∞ ]'
		else
			NewOption['Key'].Text = '[ ' .. RangeVal .. ' ]'
		end

		NewOption['Key']['MouseButton1Down']:Connect(function()
			if not Aimbot.Enabled then return end
			if Aimbot.Range < #Aimbot.RangeOptions then
				Aimbot.Range = Aimbot.Range + 1
			else
				Aimbot.Range = 1
			end

			local RangeVal = Aimbot.RangeOptions[Aimbot.Range]
			if RangeVal == math.huge then
				NewOption['Key'].Text = '[ ∞ ]'
			else
				NewOption['Key'].Text = '[ ' .. RangeVal .. ' ]'
			end
		end)
	elseif Name == 'Aimbot Mode' then
		local Aimbot = Settings.Aimbot
		Aimbot.ModeUI = NewOption
		NewOption['Key'].Text = '[ \'' .. Aimbot.ModeOptions[Aimbot.Mode] .. '\' ]'

		NewOption['Key']['MouseButton1Down']:Connect(function()
			if not Aimbot.Enabled then return end
			if Aimbot.Mode < #Aimbot.ModeOptions then
				Aimbot.Mode = Aimbot.Mode + 1
			else
				Aimbot.Mode = 1
			end

			NewOption['Key'].Text = '[ \'' .. Aimbot.ModeOptions[Aimbot.Mode] .. '\' ]'
		end)
	elseif Name == 'Floaty' then
		local Floaty = Settings.Floaty
		Floaty.UI = NewOption

		NewOption['Key']['MouseButton1Down']:Connect(function()
			if not Floaty.Enabled then return end
			if Floaty.Current < #Floaty.Options	 then
				Floaty.Current = Floaty.Current + 1
			else
				Floaty.Current = 1
			end
			Func(Floaty.Options[Floaty.Current])
		end)
	end
end

--[[Players.PlayerRemoving:Connect(function(player)
	local ESP = ESPFolder:FindFirstChild(player['Name'])

	if ESP then ESP['Parent'] = nil end
end)]]

local function toggle(button)
	local Aimbot = Settings.Aimbot
	local ActiveUI = Aimbot.ActiveUI
	local status = Aimbot.Status
	local text = button['Text']
	if text:match('Hide') then
		status['Hide Menu'] = not status['Hide Menu']
		if (status['Hide Menu']) then
			ActiveUI.Visible = false
		else
			ActiveUI.Visible = true
		end
		return
	end

	local option, val = text:match('%s*(.*)%s*:%s*(.*)')
	status[option] = not status[option]

	if status[option] then
		button.TextColor3 = Color3.fromRGB(0,255,0)
	else
		button.TextColor3 = Color3.fromRGB(255,0,0)
	end

	button.Text = option .. ': ' .. tostring(status[option])
end

Input.InputBegan:Connect(function(input, procc)
	Keys[input.KeyCode], Inputs[input.UserInputType] = true, true

	if procc then return end
	if not input.UserInputType == Enum.UserInputType.Keyboard then
		return
	end

	-- MENU/Floaty --
	if input.KeyCode == Enum.KeyCode.Delete then
		Functions['Menu']()
	elseif input.KeyCode == Enum.KeyCode.B then
		Functions['Floaty']('Up')
	elseif input.KeyCode == Enum.KeyCode.N then
		Functions['Floaty']('Still')
	elseif input.KeyCode == Enum.KeyCode.M then
		Functions['Floaty']('Down')
	end

	-- AIMBOT --
	local Aimbot = Settings.Aimbot
	local ActiveUI = Aimbot.ActiveUI
	if not ActiveUI then return end

	if input.KeyCode == Enum.KeyCode.H then
		toggle(Aimbot.Selection[Aimbot.Selected])

	elseif not Aimbot.Status['Hide Menu'] then
		if input.KeyCode == Enum.KeyCode.U then
			if (Aimbot.Selected > 1) then
				Aimbot.Selected = Aimbot.Selected - 1
			else
				Aimbot.Selected = #Aimbot.Selection
			end

		elseif input.KeyCode == Enum.KeyCode.J then
			if (Aimbot.Selected < #Aimbot.Selection) then
				Aimbot.Selected = Aimbot.Selected + 1
			else
				Aimbot.Selected = 1
			end
		end

		Aimbot.Scrolled = 30 * (Aimbot.Selected - 1)
		ActiveUI.CanvasPosition = Vector2.new(0, Aimbot.Scrolled)
	end
end)

Input.InputEnded:Connect(function(input, procc)
	Keys[input.KeyCode], Inputs[input.UserInputType] = false, false
end)

local function TargetHandler(model)
	if Targets[model] == nil then
		local event;
		Targets[model] = Players:GetPlayerFromCharacter(model) or false

		Events.Targets:Fire('added', model)
		if not model:IsDescendantOf(World) then
			if Targets[model] ~= nil then
				Events.Targets:Fire('removed', model)
				Targets[model] = nil
			end

			return
		end

		event = model:GetPropertyChangedSignal('Parent'):Connect(function()
			if model:IsDescendantOf(World) then return end

			if Targets[model] ~= nil then
				Events.Targets:Fire('removed', model)
				Targets[model] = nil
			end

			event:Disconnect()
		end)
	end
end

Player['CharacterAdded']:Connect(function(char)
	PlayerModel = char
end)

for __, target in next, (World:GetDescendants()) do
	coroutine.wrap(function()
		if target:IsA('Model') and (target ~= PlayerModel) then
			local hrp = target:WaitForChild('HumanoidRootPart', 1)
			if hrp and hrp:IsA('BasePart') then
				TargetHandler(target)
			end
		end
	end)()
end

World.DescendantAdded:Connect(function(target)
	if target:IsA('Model') and (target ~= PlayerModel) then
		local hrp = target:WaitForChild('HumanoidRootPart', 1)
		if hrp and hrp:IsA('BasePart') then
			coroutine.wrap(function()
				TargetHandler(target)
			end)()
		end
	end
end)

Menu.Parent = CoreGUI