--========================================================
-- FAKE HACKS V8
-- ROBLOX STUDIO / YOUR OWN GAME
--
-- CENTERED + MOBILE FRIENDLY GUI
-- RAGE AIM + LEGIT AIM + ESP
-- TEAM CHECK + WALL CHECK + TARGET LOCK
-- MASTER ON/OFF
-- DRAGGABLE + SCROLLABLE
-- MINIMIZE TO FLOATING CIRCLE
--
-- SILENT AIM REMOVED
--========================================================

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")

local LP = Players.LocalPlayer
local PlayerGui = LP:WaitForChild("PlayerGui")

--========================================================
-- SETTINGS
--========================================================

local Settings = {
	Enabled = true,
	Mode = "Legit",

	ESP = false,
	TeamCheck = true,
	WallCheck = true,
	TargetLock = true,

	FOV = 150,
	Smoothness = 35,
	MaxDistance = 1000,

	RageSpeed = 18,
	LegitSpeed = 6,
}

local CurrentTarget = nil
local CurrentPart = nil
local ScanTimer = 0

--========================================================
-- REMOVE OLD
--========================================================

local Old = PlayerGui:FindFirstChild("FakeHacksV8")

if Old then
	Old:Destroy()
end

--========================================================
-- GUI
--========================================================

local Gui = Instance.new("ScreenGui")
Gui.Name = "FakeHacksV8"
Gui.ResetOnSpawn = false
Gui.IgnoreGuiInset = true
Gui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
Gui.Parent = PlayerGui

--========================================================
-- MAIN WINDOW
--========================================================

local Main = Instance.new("Frame")

-- IMPORTANT:
-- AnchorPoint keeps the CENTER of the GUI at the
-- center of the screen instead of using a corner.
Main.AnchorPoint = Vector2.new(0.5, 0.5)

Main.Position = UDim2.fromScale(0.5, 0.5)

-- Scale-based size so it works better on phones
Main.Size = UDim2.fromScale(0.88, 0.78)

Main.BackgroundColor3 =
	Color3.fromRGB(13, 14, 18)

Main.BorderSizePixel = 0
Main.Active = true
Main.ClipsDescendants = true
Main.Parent = Gui

local MainSizeConstraint =
	Instance.new("UISizeConstraint")

MainSizeConstraint.MinSize =
	Vector2.new(290, 360)

MainSizeConstraint.MaxSize =
	Vector2.new(430, 620)

MainSizeConstraint.Parent = Main

Instance.new("UICorner", Main).CornerRadius =
	UDim.new(0, 14)

local MainStroke =
	Instance.new("UIStroke")

MainStroke.Color =
	Color3.fromRGB(48, 50, 60)

MainStroke.Thickness = 1

MainStroke.Parent = Main

--========================================================
-- TOP BAR
--========================================================

local Top = Instance.new("Frame")

Top.Size =
	UDim2.new(1, 0, 0, 60)

Top.BackgroundColor3 =
	Color3.fromRGB(18, 19, 24)

Top.BorderSizePixel = 0

Top.Active = true
Top.Parent = Main

Instance.new("UICorner", Top).CornerRadius =
	UDim.new(0, 14)

--========================================================
-- ACCENT
--========================================================

local Accent = Instance.new("Frame")

Accent.Size =
	UDim2.fromOffset(4, 34)

Accent.Position =
	UDim2.fromOffset(12, 13)

Accent.BackgroundColor3 =
	Color3.fromRGB(125, 120, 255)

Accent.BorderSizePixel = 0

Accent.Parent = Top

Instance.new("UICorner", Accent).CornerRadius =
	UDim.new(1, 0)

--========================================================
-- TITLE
--========================================================

local Title = Instance.new("TextLabel")

Title.Size =
	UDim2.new(1, -100, 0, 24)

Title.Position =
	UDim2.fromOffset(25, 8)

Title.BackgroundTransparency = 1

Title.Text =
	"AIM CONTROL"

Title.Font =
	Enum.Font.GothamBold

Title.TextSize = 15

Title.TextColor3 =
	Color3.fromRGB(245, 245, 250)

Title.TextXAlignment =
	Enum.TextXAlignment.Left

Title.Parent = Top

local Subtitle = Instance.new("TextLabel")

Subtitle.Size =
	UDim2.new(1, -100, 0, 17)

Subtitle.Position =
	UDim2.fromOffset(25, 31)

Subtitle.BackgroundTransparency = 1

Subtitle.Text =
	"V8  •  PLAYER TARGETING"

Subtitle.Font =
	Enum.Font.Gotham

Subtitle.TextSize = 9

Subtitle.TextColor3 =
	Color3.fromRGB(105, 108, 120)

Subtitle.TextXAlignment =
	Enum.TextXAlignment.Left

Subtitle.Parent = Top

--========================================================
-- MINIMIZE BUTTON
--========================================================

local MinButton = Instance.new("TextButton")

MinButton.AnchorPoint =
	Vector2.new(1, 0.5)

MinButton.Position =
	UDim2.new(1, -12, 0.5, 0)

MinButton.Size =
	UDim2.fromOffset(34, 34)

MinButton.BackgroundColor3 =
	Color3.fromRGB(31, 32, 40)

MinButton.Text =
	"−"

MinButton.Font =
	Enum.Font.GothamBold

MinButton.TextSize = 18

MinButton.TextColor3 =
	Color3.fromRGB(220, 220, 225)

MinButton.AutoButtonColor = false

MinButton.Parent = Top

Instance.new("UICorner", MinButton).CornerRadius =
	UDim.new(0, 9)

--========================================================
-- SCROLLING FRAME
--========================================================

local Scroll = Instance.new("ScrollingFrame")

Scroll.Size =
	UDim2.new(1, -16, 1, -68)

Scroll.Position =
	UDim2.fromOffset(8, 64)

Scroll.BackgroundTransparency = 1

Scroll.BorderSizePixel = 0

Scroll.ScrollBarThickness = 3

Scroll.ScrollBarImageColor3 =
	Color3.fromRGB(90, 90, 105)

Scroll.Active = true

Scroll.ScrollingDirection =
	Enum.ScrollingDirection.Y

Scroll.CanvasSize =
	UDim2.fromOffset(0, 650)

Scroll.Parent = Main

--========================================================
-- SECTION
--========================================================

local function Section(Text, Y)

	local Label = Instance.new("TextLabel")

	Label.Size =
		UDim2.new(1, -25, 0, 20)

	Label.Position =
		UDim2.fromOffset(13, Y)

	Label.BackgroundTransparency = 1

	Label.Text = Text

	Label.Font =
		Enum.Font.GothamBold

	Label.TextSize = 9

	Label.TextColor3 =
		Color3.fromRGB(95, 98, 110)

	Label.TextXAlignment =
		Enum.TextXAlignment.Left

	Label.Parent = Scroll

	return Label
end

--========================================================
-- TOGGLE
--========================================================

local function Toggle(Text, Y)

	local Button = Instance.new("TextButton")

	Button.Size =
		UDim2.new(1, -26, 0, 40)

	Button.Position =
		UDim2.fromOffset(13, Y)

	Button.BackgroundColor3 =
		Color3.fromRGB(22, 23, 29)

	Button.Text = ""

	Button.AutoButtonColor = false

	Button.Parent = Scroll

	Instance.new("UICorner", Button).CornerRadius =
		UDim.new(0, 9)

	local Label = Instance.new("TextLabel")

	Label.Size =
		UDim2.new(1, -65, 1, 0)

	Label.Position =
		UDim2.fromOffset(13, 0)

	Label.BackgroundTransparency = 1

	Label.Text = Text

	Label.Font =
		Enum.Font.GothamMedium

	Label.TextSize = 11

	Label.TextColor3 =
		Color3.fromRGB(210, 211, 218)

	Label.TextXAlignment =
		Enum.TextXAlignment.Left

	Label.Parent = Button

	local Switch = Instance.new("Frame")

	Switch.Size =
		UDim2.fromOffset(36, 20)

	Switch.Position =
		UDim2.new(1, -50, 0.5, -10)

	Switch.BackgroundColor3 =
		Color3.fromRGB(48, 49, 58)

	Switch.Parent = Button

	Instance.new("UICorner", Switch).CornerRadius =
		UDim.new(1, 0)

	local Knob = Instance.new("Frame")

	Knob.Size =
		UDim2.fromOffset(16, 16)

	Knob.Position =
		UDim2.fromOffset(2, 2)

	Knob.BackgroundColor3 =
		Color3.fromRGB(180, 181, 188)

	Knob.Parent = Switch

	Instance.new("UICorner", Knob).CornerRadius =
		UDim.new(1, 0)

	return Button, Switch, Knob
end

--========================================================
-- TOGGLE VISUAL
--========================================================

local function SetToggle(Switch, Knob, Enabled)

	if Enabled then

		Switch.BackgroundColor3 =
			Color3.fromRGB(102, 96, 205)

		Knob.BackgroundColor3 =
			Color3.fromRGB(250, 250, 255)

		Knob.Position =
			UDim2.fromOffset(18, 2)

	else

		Switch.BackgroundColor3 =
			Color3.fromRGB(48, 49, 58)

		Knob.BackgroundColor3 =
			Color3.fromRGB(180, 181, 188)

		Knob.Position =
			UDim2.fromOffset(2, 2)
	end
end

--========================================================
-- MASTER
--========================================================

Section("MASTER", 5)

local AimButton, AimSwitch, AimKnob =
	Toggle("Aimbot Enabled", 30)

SetToggle(
	AimSwitch,
	AimKnob,
	Settings.Enabled
)

--========================================================
-- AIM MODE
--========================================================

Section("AIM MODE", 82)

local Rage = Instance.new("TextButton")

Rage.Size =
	UDim2.new(0.5, -18, 0, 45)

Rage.Position =
	UDim2.fromOffset(13, 107)

Rage.BackgroundColor3 =
	Color3.fromRGB(27, 28, 35)

Rage.Text =
	"RAGE"

Rage.Font =
	Enum.Font.GothamBold

Rage.TextSize = 12

Rage.TextColor3 =
	Color3.fromRGB(190, 191, 200)

Rage.AutoButtonColor = false

Rage.Parent = Scroll

Instance.new("UICorner", Rage).CornerRadius =
	UDim.new(0, 10)

local Legit = Instance.new("TextButton")

Legit.Size =
	UDim2.new(0.5, -18, 0, 45)

Legit.Position =
	UDim2.new(0.5, 5, 0, 107)

Legit.BackgroundColor3 =
	Color3.fromRGB(67, 62, 125)

Legit.Text =
	"LEGIT"

Legit.Font =
	Enum.Font.GothamBold

Legit.TextSize = 12

Legit.TextColor3 =
	Color3.fromRGB(225, 224, 255)

Legit.AutoButtonColor = false

Legit.Parent = Scroll

Instance.new("UICorner", Legit).CornerRadius =
	UDim.new(0, 10)

--========================================================
-- TARGETING
--========================================================

Section("TARGETING", 165)

local ESPButton, ESPSwitch, ESPKnob =
	Toggle("ESP Boxes", 189)

local TeamButton, TeamSwitch, TeamKnob =
	Toggle("Team Check", 232)

local WallButton, WallSwitch, WallKnob =
	Toggle("Wall Check", 275)

local LockButton, LockSwitch, LockKnob =
	Toggle("Target Lock", 318)

SetToggle(
	ESPSwitch,
	ESPKnob,
	Settings.ESP
)

SetToggle(
	TeamSwitch,
	TeamKnob,
	Settings.TeamCheck
)

SetToggle(
	WallSwitch,
	WallKnob,
	Settings.WallCheck
)

SetToggle(
	LockSwitch,
	LockKnob,
	Settings.TargetLock
)

--========================================================
-- SLIDER
--========================================================

local function Slider(Text, Y, Min, Max, Initial, Callback)

	local Label = Instance.new("TextLabel")

	Label.Size =
		UDim2.new(1, -80, 0, 20)

	Label.Position =
		UDim2.fromOffset(13, Y)

	Label.BackgroundTransparency = 1

	Label.Text = Text

	Label.Font =
		Enum.Font.GothamMedium

	Label.TextSize = 10

	Label.TextColor3 =
		Color3.fromRGB(190, 191, 198)

	Label.TextXAlignment =
		Enum.TextXAlignment.Left

	Label.Parent = Scroll

	local Value = Instance.new("TextLabel")

	Value.Size =
		UDim2.fromOffset(55, 20)

	Value.Position =
		UDim2.new(1, -70, 0, Y)

	Value.BackgroundTransparency = 1

	Value.Text =
		tostring(Initial)

	Value.Font =
		Enum.Font.GothamBold

	Value.TextSize = 10

	Value.TextColor3 =
		Color3.fromRGB(150, 145, 255)

	Value.TextXAlignment =
		Enum.TextXAlignment.Right

	Value.Parent = Scroll

	local Bar = Instance.new("Frame")

	Bar.Size =
		UDim2.new(1, -26, 0, 5)

	Bar.Position =
		UDim2.fromOffset(13, Y + 27)

	Bar.BackgroundColor3 =
		Color3.fromRGB(40, 41, 49)

	Bar.BorderSizePixel = 0

	Bar.Active = true

	Bar.Parent = Scroll

	Instance.new("UICorner", Bar).CornerRadius =
		UDim.new(1, 0)

	local Fill = Instance.new("Frame")

	Fill.BackgroundColor3 =
		Color3.fromRGB(125, 119, 235)

	Fill.BorderSizePixel = 0

	Fill.Parent = Bar

	Instance.new("UICorner", Fill).CornerRadius =
		UDim.new(1, 0)

	local Percent =
		(Initial - Min) / (Max - Min)

	Fill.Size =
		UDim2.new(Percent, 0, 1, 0)

	local Dragging = false

	local function Update(X)

		local P =
			math.clamp(
				(X - Bar.AbsolutePosition.X)
				/ Bar.AbsoluteSize.X,
				0,
				1
			)

		local Number =
			math.floor(
				Min + (Max - Min) * P + 0.5
			)

		Fill.Size =
			UDim2.new(P, 0, 1, 0)

		Value.Text =
			tostring(Number)

		Callback(Number)
	end

	Bar.InputBegan:Connect(function(Input)

		if Input.UserInputType ==
			Enum.UserInputType.MouseButton1
			or Input.UserInputType ==
			Enum.UserInputType.Touch then

			Dragging = true

			Update(
				Input.Position.X
			)
		end
	end)

	UserInputService.InputChanged:Connect(function(Input)

		if not Dragging then
			return
		end

		if Input.UserInputType ==
			Enum.UserInputType.MouseMovement
			or Input.UserInputType ==
			Enum.UserInputType.Touch then

			Update(
				Input.Position.X
			)
		end
	end)

	UserInputService.InputEnded:Connect(function(Input)

		if Input.UserInputType ==
			Enum.UserInputType.MouseButton1
			or Input.UserInputType ==
			Enum.UserInputType.Touch then

			Dragging = false
		end
	end)
end

--========================================================
-- AIM SETTINGS
--========================================================

Section("AIM SETTINGS", 365)

Slider(
	"FOV",
	390,
	50,
	300,
	Settings.FOV,
	function(V)

		Settings.FOV = V
	end
)

Slider(
	"SMOOTHNESS",
	442,
	5,
	100,
	Settings.Smoothness,
	function(V)

		Settings.Smoothness = V
	end
)

Slider(
	"MAX DISTANCE",
	494,
	100,
	2000,
	Settings.MaxDistance,
	function(V)

		Settings.MaxDistance = V
	end
)

--========================================================
-- FOV
--========================================================

local FOVCircle = Instance.new("Frame")

FOVCircle.Name = "FOV"

FOVCircle.AnchorPoint =
	Vector2.new(0.5, 0.5)

FOVCircle.Position =
	UDim2.fromScale(0.5, 0.5)

FOVCircle.Size =
	UDim2.fromOffset(
		Settings.FOV * 2,
		Settings.FOV * 2
	)

FOVCircle.BackgroundTransparency = 1

FOVCircle.Parent = Gui

Instance.new("UICorner", FOVCircle).CornerRadius =
	UDim.new(1, 0)

local FOVStroke =
	Instance.new("UIStroke")

FOVStroke.Color =
	Color3.fromRGB(135, 130, 255)

FOVStroke.Transparency = 0.5

FOVStroke.Thickness = 1

FOVStroke.Parent = FOVCircle

--========================================================
-- STATUS
--========================================================

local Status = Instance.new("TextLabel")

Status.Size =
	UDim2.new(1, -26, 0, 25)

Status.Position =
	UDim2.fromOffset(13, 550)

Status.BackgroundTransparency = 1

Status.Text =
	"TARGET  •  NONE"

Status.Font =
	Enum.Font.GothamBold

Status.TextSize = 9

Status.TextColor3 =
	Color3.fromRGB(100, 102, 113)

Status.TextXAlignment =
	Enum.TextXAlignment.Left

Status.Parent = Scroll

--========================================================
-- TARGET CHECK
--========================================================

local function ValidTarget(Player)

	if Player == LP then
		return false
	end

	if Settings.TeamCheck then

		if LP.Team
			and Player.Team
			and LP.Team == Player.Team then

			return false
		end
	end

	local Character =
		Player.Character

	if not Character then
		return false
	end

	local Humanoid =
		Character:FindFirstChildOfClass(
			"Humanoid"
		)

	local Root =
		Character:FindFirstChild(
			"HumanoidRootPart"
		)

	local Head =
		Character:FindFirstChild(
			"Head"
		)

	if not Humanoid
		or Humanoid.Health <= 0
		or not Root
		or not Head then

		return false
	end

	local MyCharacter =
		LP.Character

	local MyRoot =
		MyCharacter
		and MyCharacter:FindFirstChild(
			"HumanoidRootPart"
		)

	if MyRoot then

		local Distance =
			(
				Root.Position
				- MyRoot.Position
			).Magnitude

		if Distance >
			Settings.MaxDistance then

			return false
		end
	end

	return true
end

--========================================================
-- WALL CHECK
--========================================================

local function Visible(Part)

	if not Settings.WallCheck then
		return true
	end

	local Camera =
		workspace.CurrentCamera

	if not Camera then
		return false
	end

	local Origin =
		Camera.CFrame.Position

	local Direction =
		Part.Position - Origin

	local Params =
		RaycastParams.new()

	Params.FilterType =
		Enum.RaycastFilterType.Exclude

	Params.FilterDescendantsInstances = {
		LP.Character
	}

	local Result =
		workspace:Raycast(
			Origin,
			Direction,
			Params
		)

	if not Result then
		return true
	end

	return Result.Instance:IsDescendantOf(
		Part.Parent
	)
end

--========================================================
-- AIM PART
--========================================================

local function GetAimPart(Character)

	if Settings.Mode == "Rage" then

		return Character:FindFirstChild(
			"Head"
		)
	end

	return Character:FindFirstChild(
		"UpperTorso"
	)
	or Character:FindFirstChild(
		"Torso"
	)
	or Character:FindFirstChild(
		"Head"
	)
end

--========================================================
-- SCREEN DISTANCE
--========================================================

local function ScreenDistance(Part)

	local Camera =
		workspace.CurrentCamera

	if not Camera then
		return math.huge
	end

	local Position, OnScreen =
		Camera:WorldToViewportPoint(
			Part.Position
		)

	if not OnScreen
		or Position.Z <= 0 then

		return math.huge
	end

	local Center =
		Vector2.new(
			Camera.ViewportSize.X / 2,
			Camera.ViewportSize.Y / 2
		)

	local Point =
		Vector2.new(
			Position.X,
			Position.Y
		)

	return (
		Point - Center
	).Magnitude
end

--========================================================
-- FIND TARGET
--========================================================

local function FindTarget()

	local BestPlayer = nil
	local BestPart = nil

	local BestDistance =
		Settings.FOV

	for _, Player in ipairs(
		Players:GetPlayers()
	) do

		if ValidTarget(Player) then

			local Character =
				Player.Character

			local Part =
				GetAimPart(Character)

			if Part and Visible(Part) then

				local Distance =
					ScreenDistance(Part)

				if Distance <
					BestDistance then

					BestDistance =
						Distance

					BestPlayer =
						Player

					BestPart =
						Part
				end
			end
		end
	end

	return BestPlayer, BestPart
end

--========================================================
-- TARGET STILL VALID
--========================================================

local function TargetStillValid()

	if not CurrentTarget
		or not CurrentPart then

		return false
	end

	if not ValidTarget(CurrentTarget) then
		return false
	end

	local Character =
		CurrentTarget.Character

	local Part =
		GetAimPart(Character)

	if not Part then
		return false
	end

	CurrentPart = Part

	if not Visible(Part) then
		return false
	end

	return ScreenDistance(Part)
		<= Settings.FOV * 1.35
end

--========================================================
-- ESP
--========================================================

local ESPObjects = {}

local function RemoveESP(Player)

	if ESPObjects[Player] then

		ESPObjects[Player]:Destroy()

		ESPObjects[Player] = nil
	end
end

local function CreateESP(Player)

	if Player == LP then
		return
	end

	if ESPObjects[Player] then
		return
	end

	if not Player.Character then
		return
	end

	local Highlight =
		Instance.new("Highlight")

	Highlight.Name =
		"ESPBox"

	Highlight.Adornee =
		Player.Character

	Highlight.FillTransparency = 1

	Highlight.OutlineTransparency =
		0.05

	Highlight.OutlineColor =
		Color3.fromRGB(
			235,
			235,
			255
		)

	Highlight.DepthMode =
		Enum.HighlightDepthMode.AlwaysOnTop

	Highlight.Enabled =
		Settings.ESP

	Highlight.Parent =
		Gui

	ESPObjects[Player] =
		Highlight
end

local function UpdateESP()

	for Player, Object in pairs(
		ESPObjects
	) do

		if not Player.Parent then

			Object:Destroy()

			ESPObjects[Player] = nil

		else

			Object.Adornee =
				Player.Character

			Object.Enabled =
				Settings.ESP
		end
	end

	if not Settings.ESP then
		return
	end

	for _, Player in ipairs(
		Players:GetPlayers()
	) do

		if Player ~= LP then

			CreateESP(Player)
		end
	end
end

Players.PlayerAdded:Connect(function(Player)

	Player.CharacterAdded:Connect(
		function()

			task.wait(0.1)

			if Settings.ESP then
				CreateESP(Player)
			end
		end
	)
end)

Players.PlayerRemoving:Connect(function(Player)

	RemoveESP(Player)

	if CurrentTarget == Player then

		CurrentTarget = nil
		CurrentPart = nil
	end
end)

--========================================================
-- BUTTONS
--========================================================

AimButton.MouseButton1Click:Connect(function()

	Settings.Enabled =
		not Settings.Enabled

	SetToggle(
		AimSwitch,
		AimKnob,
		Settings.Enabled
	)

	if not Settings.Enabled then

		CurrentTarget = nil
		CurrentPart = nil

		Status.Text =
			"AIM  •  OFF"

	else

		Status.Text =
			"AIM  •  READY"
	end
end)

Rage.MouseButton1Click:Connect(function()

	Settings.Mode = "Rage"

	Rage.BackgroundColor3 =
		Color3.fromRGB(95, 55, 65)

	Rage.TextColor3 =
		Color3.fromRGB(255, 225, 230)

	Legit.BackgroundColor3 =
		Color3.fromRGB(27, 28, 35)

	Legit.TextColor3 =
		Color3.fromRGB(190, 191, 200)

	CurrentTarget = nil
	CurrentPart = nil
end)

Legit.MouseButton1Click:Connect(function()

	Settings.Mode = "Legit"

	Legit.BackgroundColor3 =
		Color3.fromRGB(67, 62, 125)

	Legit.TextColor3 =
		Color3.fromRGB(225, 224, 255)

	Rage.BackgroundColor3 =
		Color3.fromRGB(27, 28, 35)

	Rage.TextColor3 =
		Color3.fromRGB(190, 191, 200)

	CurrentTarget = nil
	CurrentPart = nil
end)

ESPButton.MouseButton1Click:Connect(function()

	Settings.ESP =
		not Settings.ESP

	SetToggle(
		ESPSwitch,
		ESPKnob,
		Settings.ESP
	)

	UpdateESP()
end)

TeamButton.MouseButton1Click:Connect(function()

	Settings.TeamCheck =
		not Settings.TeamCheck

	SetToggle(
		TeamSwitch,
		TeamKnob,
		Settings.TeamCheck
	)

	CurrentTarget = nil
	CurrentPart = nil
end)

WallButton.MouseButton1Click:Connect(function()

	Settings.WallCheck =
		not Settings.WallCheck

	SetToggle(
		WallSwitch,
		WallKnob,
		Settings.WallCheck
	)

	CurrentTarget = nil
	CurrentPart = nil
end)

LockButton.MouseButton1Click:Connect(function()

	Settings.TargetLock =
		not Settings.TargetLock

	SetToggle(
		LockSwitch,
		LockKnob,
		Settings.TargetLock
	)

	if not Settings.TargetLock then

		CurrentTarget = nil
		CurrentPart = nil
	end
end)

--========================================================
-- AIM LOOP
--========================================================

RunService:BindToRenderStep(
	"FakeHacksV8Aim",
	Enum.RenderPriority.Camera.Value + 1,
	function(DeltaTime)

		local Camera =
			workspace.CurrentCamera

		if not Camera then
			return
		end

		FOVCircle.Size =
			UDim2.fromOffset(
				Settings.FOV * 2,
				Settings.FOV * 2
			)

		UpdateESP()

		if not Settings.Enabled then

			CurrentTarget = nil
			CurrentPart = nil

			Status.Text =
				"AIM  •  OFF"

			return
		end

		ScanTimer += DeltaTime

		if ScanTimer >= 0.033 then

			ScanTimer = 0

			if Settings.TargetLock then

				if not TargetStillValid() then

					CurrentTarget,
					CurrentPart =
						FindTarget()
				end

			else

				CurrentTarget,
				CurrentPart =
					FindTarget()
			end
		end

		if not CurrentTarget
			or not CurrentPart then

			Status.Text =
				"TARGET  •  NONE"

			return
		end

		if not TargetStillValid() then

			CurrentTarget = nil
			CurrentPart = nil

			Status.Text =
				"TARGET  •  NONE"

			return
		end

		Status.Text =
			"TARGET  •  "
			.. CurrentTarget.DisplayName
			.. "  •  "
			.. CurrentPart.Name

		local Desired =
			CFrame.lookAt(
				Camera.CFrame.Position,
				CurrentPart.Position
			)

		local Speed

		if Settings.Mode == "Rage" then

			Speed =
				Settings.RageSpeed

		else

			Speed =
				1
				+ (
					Settings.Smoothness
					/ 100
				)
				* Settings.LegitSpeed
		end

		local Alpha =
			1 - math.exp(
				-Speed * DeltaTime
			)

		Camera.CFrame =
			Camera.CFrame:Lerp(
				Desired,
				Alpha
			)
	end
)

--========================================================
-- DRAG MAIN WINDOW
--========================================================

local Dragging = false
local DragStart
local StartPosition

Top.InputBegan:Connect(function(Input)

	if Input.UserInputType ==
		Enum.UserInputType.MouseButton1
		or Input.UserInputType ==
		Enum.UserInputType.Touch then

		Dragging = true

		DragStart =
			Input.Position

		StartPosition =
			Main.Position
	end
end)

UserInputService.InputChanged:Connect(function(Input)

	if not Dragging then
		return
	end

	if Input.UserInputType ==
		Enum.UserInputType.MouseMovement
		or Input.UserInputType ==
		Enum.UserInputType.Touch then

		local Delta =
			Input.Position
			- DragStart

		Main.Position =
			UDim2.new(
				StartPosition.X.Scale,
				StartPosition.X.Offset + Delta.X,

				StartPosition.Y.Scale,
				StartPosition.Y.Offset + Delta.Y
			)
	end
end)

UserInputService.InputEnded:Connect(function(Input)

	if Input.UserInputType ==
		Enum.UserInputType.MouseButton1
		or Input.UserInputType ==
		Enum.UserInputType.Touch then

		Dragging = false
	end
end)

--========================================================
-- FLOATING BUTTON
--========================================================

local Floating = Instance.new("TextButton")

Floating.AnchorPoint =
	Vector2.new(0.5, 0.5)

Floating.Position =
	UDim2.fromScale(0.5, 0.5)

Floating.Size =
	UDim2.fromOffset(58, 58)

Floating.BackgroundColor3 =
	Color3.fromRGB(18, 19, 25)

Floating.Text =
	"A"

Floating.Font =
	Enum.Font.GothamBlack

Floating.TextSize = 25

Floating.TextColor3 =
	Color3.fromRGB(150, 145, 255)

Floating.Visible = false

Floating.Active = true

Floating.AutoButtonColor = false

Floating.Parent = Gui

Instance.new("UICorner", Floating).CornerRadius =
	UDim.new(1, 0)

local FloatingStroke =
	Instance.new("UIStroke")

FloatingStroke.Color =
	Color3.fromRGB(100, 95, 200)

FloatingStroke.Thickness = 2

FloatingStroke.Parent = Floating

--========================================================
-- MINIMIZE / RESTORE
--========================================================

MinButton.MouseButton1Click:Connect(function()

	Main.Visible = false
	Floating.Visible = true
end)

Floating.MouseButton1Click:Connect(function()

	Main.Visible = true
	Floating.Visible = false
end)

--========================================================
-- FLOATING BUTTON DRAG
--========================================================

local FloatDragging = false
local FloatStart
local FloatPosition

Floating.InputBegan:Connect(function(Input)

	if Input.UserInputType ==
		Enum.UserInputType.MouseButton1
		or Input.UserInputType ==
		Enum.UserInputType.Touch then

		FloatDragging = true

		FloatStart =
			Input.Position

		FloatPosition =
			Floating.Position
	end
end)

UserInputService.InputChanged:Connect(function(Input)

	if not FloatDragging then
		return
	end

	if Input.UserInputType ==
		Enum.UserInputType.MouseMovement
		or Input.UserInputType ==
		Enum.UserInputType.Touch then

		local Delta =
			Input.Position
			- FloatStart

		Floating.Position =
			UDim2.new(
				FloatPosition.X.Scale,
				FloatPosition.X.Offset + Delta.X,

				FloatPosition.Y.Scale,
				FloatPosition.Y.Offset + Delta.Y
			)
	end
end)

UserInputService.InputEnded:Connect(function(Input)

	if Input.UserInputType ==
		Enum.UserInputType.MouseButton1
		or Input.UserInputType ==
		Enum.UserInputType.Touch then

		FloatDragging = false
	end
end)

--========================================================
-- F4
--========================================================

UserInputService.InputBegan:Connect(function(
	Input,
	Processed
)

	if Processed then
		return
	end

	if Input.KeyCode ==
		Enum.KeyCode.F4 then

		Settings.Enabled =
			not Settings.Enabled

		SetToggle(
			AimSwitch,
			AimKnob,
			Settings.Enabled
		)

		if not Settings.Enabled then

			CurrentTarget = nil
			CurrentPart = nil

			Status.Text =
				"AIM  •  OFF"

		else

			Status.Text =
				"AIM  •  READY"
		end
	end
end)

--========================================================
-- START
--========================================================

FOVCircle.Visible = true

print("[Fake Hacks V8] Loaded")
print("[Fake Hacks V8] Centered GUI")
print("[Fake Hacks V8] Mobile friendly")
print("[Fake Hacks V8] Master toggle ready")