basic menu gui

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local Workspace = game:GetService("Workspace")
local Lighting = game:GetService("Lighting")
local TweenService = game:GetService("TweenService")
local Camera = Workspace.CurrentCamera
local LocalPlayer = Players.LocalPlayer

local settings = {
	esp = false,
	noclip = false,
	teamCheck = true,
	fogRemover = true,
	hitbox = false,
	infjump = false,
	speed = false,
	triggerbot = false,
	hitboxSize = 10,
	jumpPower = 50,
	speedMultiplier = 2,
	triggerbotDelay = 0.3,
	maxDistance = 300,
	keybinds = {
		esp = Enum.KeyCode.F1,
		noclip = Enum.KeyCode.F2,
		teamCheck = Enum.KeyCode.F3,
		fogRemover = Enum.KeyCode.F4,
		hitbox = Enum.KeyCode.F5,
		infjump = Enum.KeyCode.F6,
		speed = Enum.KeyCode.F7,
		triggerbot = Enum.KeyCode.F8
	}
}

local state = {
	noclipConnection = nil,
	speedConnection = nil,
	hitboxConnection = nil,
	triggerbotConnection = nil,
	espObjects = {},
	hitboxParts = {},
	changingKeybind = nil,
	canJump = true,
	lastShot = 0,
	playerCharacters = {}
}

local COLORS = {
	background = Color3.fromRGB(15, 15, 18),
	surface = Color3.fromRGB(22, 22, 26),
	surfaceLight = Color3.fromRGB(32, 32, 36),
	accent = Color3.fromRGB(88, 101, 242),
	accentHover = Color3.fromRGB(71, 82, 196),
	success = Color3.fromRGB(67, 181, 129),
	text = Color3.fromRGB(224, 225, 227),
	textDim = Color3.fromRGB(148, 152, 157),
	border = Color3.fromRGB(38, 38, 42)
}

local function createGUI()
	local sg = Instance.new("ScreenGui")
	sg.Name = "AceHelper"
	sg.ResetOnSpawn = false
	sg.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
	sg.IgnoreGuiInset = true
	
	local main = Instance.new("Frame")
	main.Name = "Main"
	main.Size = UDim2.new(0, 280, 0, 420)
	main.Position = UDim2.new(0.5, -140, 0.5, -210)
	main.BackgroundColor3 = COLORS.background
	main.BorderSizePixel = 0
	main.Active = true
	main.ClipsDescendants = true
	main.BackgroundTransparency = 1
	main.AnchorPoint = Vector2.new(0.5, 0.5)
	main.Parent = sg
	
	local mainCorner = Instance.new("UICorner")
	mainCorner.CornerRadius = UDim.new(0, 10)
	mainCorner.Parent = main
	
	local mainStroke = Instance.new("UIStroke")
	mainStroke.Color = COLORS.border
	mainStroke.Thickness = 1
	mainStroke.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
	mainStroke.Transparency = 1
	mainStroke.Parent = main
	
	local title = Instance.new("Frame")
	title.Name = "Title"
	title.Size = UDim2.new(1, 0, 0, 38)
	title.BackgroundColor3 = COLORS.surface
	title.BorderSizePixel = 0
	title.Parent = main
	
	local titleCorner = Instance.new("UICorner")
	titleCorner.CornerRadius = UDim.new(0, 10)
	titleCorner.Parent = title
	
	local titleFix = Instance.new("Frame")
	titleFix.Size = UDim2.new(1, 0, 0, 10)
	titleFix.Position = UDim2.new(0, 0, 1, -10)
	titleFix.BackgroundColor3 = COLORS.surface
	titleFix.BorderSizePixel = 0
	titleFix.Parent = title
	
	local titleText = Instance.new("TextLabel")
	titleText.Size = UDim2.new(1, -20, 1, 0)
	titleText.Position = UDim2.new(0, 20, 0, 0)
	titleText.BackgroundTransparency = 1
	titleText.Text = "ACE HELPER"
	titleText.TextColor3 = COLORS.text
	titleText.Font = Enum.Font.GothamBold
	titleText.TextSize = 14
	titleText.TextXAlignment = Enum.TextXAlignment.Left
	titleText.Parent = title
	
	local accent = Instance.new("Frame")
	accent.Size = UDim2.new(1, 0, 0, 2)
	accent.Position = UDim2.new(0, 0, 0, 38)
	accent.BackgroundColor3 = COLORS.accent
	accent.BorderSizePixel = 0
	accent.Parent = main
	
	local scrollContainer = Instance.new("Frame")
	scrollContainer.Name = "ScrollContainer"
	scrollContainer.Size = UDim2.new(1, 0, 1, -40)
	scrollContainer.Position = UDim2.new(0, 0, 0, 40)
	scrollContainer.BackgroundTransparency = 1
	scrollContainer.ClipsDescendants = true
	scrollContainer.Parent = main
	
	local scroll = Instance.new("ScrollingFrame")
	scroll.Name = "Scroll"
	scroll.Size = UDim2.new(1, 0, 1, 0)
	scroll.CanvasSize = UDim2.new(0, 0, 0, 0)
	scroll.BackgroundTransparency = 1
	scroll.BorderSizePixel = 0
	scroll.ScrollBarThickness = 4
	scroll.ScrollBarImageColor3 = COLORS.accent
	scroll.ScrollingDirection = Enum.ScrollingDirection.Y
	scroll.AutomaticCanvasSize = Enum.AutomaticSize.Y
	scroll.ScrollBarImageTransparency = 0.5
	scroll.Parent = scrollContainer
	
	local content = Instance.new("Frame")
	content.Name = "Content"
	content.Size = UDim2.new(1, -24, 1, 0)
	content.Position = UDim2.new(0, 12, 0, 8)
	content.BackgroundTransparency = 1
	content.AutomaticSize = Enum.AutomaticSize.Y
	content.Parent = scroll
	
	local layout = Instance.new("UIListLayout")
	layout.Padding = UDim.new(0, 6)
	layout.SortOrder = Enum.SortOrder.LayoutOrder
	layout.Parent = content
	
	local topGradient = Instance.new("Frame")
	topGradient.Name = "TopGradient"
	topGradient.Size = UDim2.new(1, 0, 0, 20)
	topGradient.Position = UDim2.new(0, 0, 0, 40)
	topGradient.BackgroundColor3 = COLORS.background
	topGradient.BorderSizePixel = 0
	topGradient.ZIndex = 10
	topGradient.Parent = main
	
	local topGrad = Instance.new("UIGradient")
	topGrad.Rotation = 90
	topGrad.Transparency = NumberSequence.new({
		NumberSequenceKeypoint.new(0, 0),
		NumberSequenceKeypoint.new(1, 1)
	})
	topGrad.Parent = topGradient
	
	local bottomGradient = Instance.new("Frame")
	bottomGradient.Name = "BottomGradient"
	bottomGradient.Size = UDim2.new(1, 0, 0, 20)
	bottomGradient.Position = UDim2.new(0, 0, 1, -20)
	bottomGradient.BackgroundColor3 = COLORS.background
	bottomGradient.BorderSizePixel = 0
	bottomGradient.ZIndex = 10
	bottomGradient.Parent = main
	
	local bottomGrad = Instance.new("UIGradient")
	bottomGrad.Rotation = 90
	bottomGrad.Transparency = NumberSequence.new({
		NumberSequenceKeypoint.new(0, 1),
		NumberSequenceKeypoint.new(1, 0)
	})
	bottomGrad.Parent = bottomGradient
	
	local bottomCorner = Instance.new("UICorner")
	bottomCorner.CornerRadius = UDim.new(0, 10)
	bottomCorner.Parent = bottomGradient
	
	return sg, content, main, mainStroke, title
end

local gui, content, mainFrame, mainStroke, titleFrame = createGUI()
local yOffset = 0

local function createToggle(name: string, setting: string)
	local frame = Instance.new("Frame")
	frame.Size = UDim2.new(1, 0, 0, 32)
	frame.BackgroundColor3 = COLORS.surface
	frame.BorderSizePixel = 0
	frame.LayoutOrder = yOffset
	frame.Parent = content
	yOffset += 1
	
	local frameCorner = Instance.new("UICorner")
	frameCorner.CornerRadius = UDim.new(0, 6)
	frameCorner.Parent = frame
	
	local label = Instance.new("TextLabel")
	label.Size = UDim2.new(0, 110, 1, 0)
	label.Position = UDim2.new(0, 10, 0, 0)
	label.BackgroundTransparency = 1
	label.Text = name
	label.TextColor3 = COLORS.text
	label.Font = Enum.Font.GothamMedium
	label.TextSize = 12
	label.TextXAlignment = Enum.TextXAlignment.Left
	label.Parent = frame
	
	local toggle = Instance.new("TextButton")
	toggle.Name = "Toggle"
	toggle.Size = UDim2.new(0, 42, 0, 20)
	toggle.Position = UDim2.new(0, 115, 0.5, -10)
	toggle.BackgroundColor3 = COLORS.surfaceLight
	toggle.BorderSizePixel = 0
	toggle.AutoButtonColor = false
	toggle.Text = "OFF"
	toggle.TextColor3 = COLORS.textDim
	toggle.Font = Enum.Font.GothamBold
	toggle.TextSize = 9
	toggle.Parent = frame
	
	local toggleCorner = Instance.new("UICorner")
	toggleCorner.CornerRadius = UDim.new(0, 5)
	toggleCorner.Parent = toggle
	
	local keybind = Instance.new("TextButton")
	keybind.Name = "Keybind"
	keybind.Size = UDim2.new(0, 50, 0, 20)
	keybind.Position = UDim2.new(1, -60, 0.5, -10)
	keybind.BackgroundColor3 = COLORS.surfaceLight
	keybind.BorderSizePixel = 0
	keybind.AutoButtonColor = false
	keybind.Text = settings.keybinds[setting].Name
	keybind.TextColor3 = COLORS.textDim
	keybind.Font = Enum.Font.GothamMedium
	keybind.TextSize = 9
	keybind.Parent = frame
	
	local keybindCorner = Instance.new("UICorner")
	keybindCorner.CornerRadius = UDim.new(0, 5)
	keybindCorner.Parent = keybind
	
	return toggle, keybind
end

local function createSlider(name: string, min: number, max: number, default: number, setting: string)
	local frame = Instance.new("Frame")
	frame.Size = UDim2.new(1, 0, 0, 44)
	frame.BackgroundColor3 = COLORS.surface
	frame.BorderSizePixel = 0
	frame.LayoutOrder = yOffset
	frame.Parent = content
	yOffset += 1
	
	local frameCorner = Instance.new("UICorner")
	frameCorner.CornerRadius = UDim.new(0, 6)
	frameCorner.Parent = frame
	
	local label = Instance.new("TextLabel")
	label.Size = UDim2.new(0, 110, 0, 16)
	label.Position = UDim2.new(0, 10, 0, 6)
	label.BackgroundTransparency = 1
	label.Text = name
	label.TextColor3 = COLORS.text
	label.Font = Enum.Font.GothamMedium
	label.TextSize = 11
	label.TextXAlignment = Enum.TextXAlignment.Left
	label.Parent = frame
	
	local valueBox = Instance.new("TextBox")
	valueBox.Size = UDim2.new(0, 50, 0, 16)
	valueBox.Position = UDim2.new(1, -60, 0, 6)
	valueBox.BackgroundColor3 = COLORS.surfaceLight
	valueBox.BorderSizePixel = 0
	valueBox.Text = tostring(default)
	valueBox.TextColor3 = COLORS.text
	valueBox.Font = Enum.Font.GothamMedium
	valueBox.TextSize = 10
	valueBox.Parent = frame
	
	local valueCorner = Instance.new("UICorner")
	valueCorner.CornerRadius = UDim.new(0, 4)
	valueCorner.Parent = valueBox
	
	local sliderBg = Instance.new("Frame")
	sliderBg.Size = UDim2.new(1, -20, 0, 5)
	sliderBg.Position = UDim2.new(0, 10, 0, 30)
	sliderBg.BackgroundColor3 = COLORS.surfaceLight
	sliderBg.BorderSizePixel = 0
	sliderBg.Parent = frame
	
	local sliderBgCorner = Instance.new("UICorner")
	sliderBgCorner.CornerRadius = UDim.new(1, 0)
	sliderBgCorner.Parent = sliderBg
	
	local sliderFill = Instance.new("Frame")
	sliderFill.Size = UDim2.new((default - min) / (max - min), 0, 1, 0)
	sliderFill.BackgroundColor3 = COLORS.accent
	sliderFill.BorderSizePixel = 0
	sliderFill.Parent = sliderBg
	
	local sliderFillCorner = Instance.new("UICorner")
	sliderFillCorner.CornerRadius = UDim.new(1, 0)
	sliderFillCorner.Parent = sliderFill
	
	local sliderBtn = Instance.new("Frame")
	sliderBtn.Size = UDim2.new(0, 12, 0, 12)
	sliderBtn.Position = UDim2.new((default - min) / (max - min), -6, 0.5, -6)
	sliderBtn.BackgroundColor3 = COLORS.text
	sliderBtn.BorderSizePixel = 0
	sliderBtn.Parent = sliderBg
	
	local sliderBtnCorner = Instance.new("UICorner")
	sliderBtnCorner.CornerRadius = UDim.new(1, 0)
	sliderBtnCorner.Parent = sliderBtn
	
	local dragDetector = Instance.new("TextButton")
	dragDetector.Size = UDim2.new(1, 20, 1, 20)
	dragDetector.Position = UDim2.new(0, -10, 0, -10)
	dragDetector.BackgroundTransparency = 1
	dragDetector.Text = ""
	dragDetector.Parent = sliderBg
	
	local dragging = false
	local dragConnection = nil
	
	local function updateValue(value: number, animate: boolean)
		value = math.clamp(value, min, max)
		local percent = (value - min) / (max - min)
		
		if animate then
			local tweenInfo = TweenInfo.new(0.15, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
			TweenService:Create(sliderFill, tweenInfo, {Size = UDim2.new(percent, 0, 1, 0)}):Play()
			TweenService:Create(sliderBtn, tweenInfo, {Position = UDim2.new(percent, -6, 0.5, -6)}):Play()
		else
			sliderFill.Size = UDim2.new(percent, 0, 1, 0)
			sliderBtn.Position = UDim2.new(percent, -6, 0.5, -6)
		end
		
		valueBox.Text = tostring(math.floor(value * 100) / 100)
		settings[setting] = value
	end
	
	dragDetector.MouseButton1Down:Connect(function()
		dragging = true
		if dragConnection then dragConnection:Disconnect() end
		
		dragConnection = RunService.RenderStepped:Connect(function()
			if dragging then
				local mouse = LocalPlayer:GetMouse()
				local relativeX = mouse.X - sliderBg.AbsolutePosition.X
				local percent = math.clamp(relativeX / sliderBg.AbsoluteSize.X, 0, 1)
				local value = min + (max - min) * percent
				updateValue(value, false)
			end
		end)
	end)
	
	UserInputService.InputEnded:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1 then
			dragging = false
			if dragConnection then
				dragConnection:Disconnect()
				dragConnection = nil
			end
		end
	end)
	
	valueBox.FocusLost:Connect(function()
		local value = tonumber(valueBox.Text)
		if value then
			updateValue(value, true)
		else
			valueBox.Text = tostring(settings[setting])
		end
	end)
	
	return frame
end

local espToggle, espKey = createToggle("ESP", "esp")
local noclipToggle, noclipKey = createToggle("Noclip", "noclip")
local teamToggle, teamKey = createToggle("Team Check", "teamCheck")
local fogToggle, fogKey = createToggle("Fog Remover", "fogRemover")
local hitboxToggle, hitboxKey = createToggle("Hitbox Expand", "hitbox")
local infjumpToggle, infjumpKey = createToggle("Inf Jump", "infjump")
local speedToggle, speedKey = createToggle("Speed", "speed")
local triggerbotToggle, triggerbotKey = createToggle("Triggerbot", "triggerbot")

createSlider("Hitbox Size", 1, 30, settings.hitboxSize, "hitboxSize")
createSlider("Jump Power", 20, 100, settings.jumpPower, "jumpPower")
createSlider("Speed Mult", 1, 5, settings.speedMultiplier, "speedMultiplier")
createSlider("Trigger Delay", 0.05, 1, settings.triggerbotDelay, "triggerbotDelay")
createSlider("Max Distance", 50, 500, settings.maxDistance, "maxDistance")

gui.Parent = game:GetService("CoreGui")

local dragging = false
local dragStart = nil
local startPos = nil

titleFrame.InputBegan:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton1 then
		dragging = true
		dragStart = input.Position
		startPos = mainFrame.Position
	end
end)

UserInputService.InputChanged:Connect(function(input)
	if dragging and input.UserInputType == Enum.UserInputType.MouseMovement then
		local delta = input.Position - dragStart
		local newPos = UDim2.new(
			startPos.X.Scale,
			startPos.X.Offset + delta.X,
			startPos.Y.Scale,
			startPos.Y.Offset + delta.Y
		)
		mainFrame.Position = newPos
	end
end)

UserInputService.InputEnded:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton1 then
		dragging = false
	end
end)

task.spawn(function()
	local tweenInfo = TweenInfo.new(0.4, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
	mainFrame.Size = UDim2.new(0, 0, 0, 0)
	
	TweenService:Create(mainFrame, tweenInfo, {
		Size = UDim2.new(0, 280, 0, 420),
		BackgroundTransparency = 0
	}):Play()
	
	TweenService:Create(mainStroke, tweenInfo, {Transparency = 0}):Play()
	
	task.wait(0.1)
	for _, child in ipairs(content:GetChildren()) do
		if child:IsA("Frame") then
			child.BackgroundTransparency = 1
			TweenService:Create(child, TweenInfo.new(0.3, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), {
				BackgroundTransparency = 0
			}):Play()
			task.wait(0.02)
		end
	end
end)

local function updateToggleUI(toggle: TextButton, enabled: boolean)
	local tweenInfo = TweenInfo.new(0.2, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
	if enabled then
		TweenService:Create(toggle, tweenInfo, {BackgroundColor3 = COLORS.accent}):Play()
		toggle.Text = "ON"
		toggle.TextColor3 = COLORS.text
	else
		TweenService:Create(toggle, tweenInfo, {BackgroundColor3 = COLORS.surfaceLight}):Play()
		toggle.Text = "OFF"
		toggle.TextColor3 = COLORS.textDim
	end
end

local function disableFog()
	Lighting.FogEnd = 1e6
	Lighting.FogStart = 0
	Lighting.FogColor = Color3.new(1, 1, 1)
end

local function enableFog()
	Lighting.FogEnd = 500
	Lighting.FogStart = 0
end

local function getCenterPart(character: Model)
	if not character then return nil end
	return character:FindFirstChild("HumanoidRootPart") 
		or character:FindFirstChild("Torso") 
		or character:FindFirstChild("UpperTorso")
		or character:FindFirstChildWhichIsA("BasePart")
end

local function isSameTeam(a: Player, b: Player): boolean
	if not settings.teamCheck then return false end
	if a.Team and b.Team then
		return a.Team == b.Team
	end
	return false
end

local function updatePlayerCache()
	state.playerCharacters = {}
	for _, p in ipairs(Players:GetPlayers()) do
		if p ~= LocalPlayer and p.Character then
			state.playerCharacters[p.Character] = p
		end
	end
end

local function applyESP(player: Player)
	local function addHighlight(character: Model)
		if not settings.esp then return end
		if character:FindFirstChild("ESP_Highlight") then return end
		
		local h = Instance.new("Highlight")
		h.Name = "ESP_Highlight"
		h.Adornee = character
		h.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
		h.FillTransparency = 0.7
		h.OutlineTransparency = 0
		h.OutlineColor = Color3.fromRGB(255, 255, 255)
		h.FillColor = isSameTeam(LocalPlayer, player) 
			and Color3.fromRGB(80, 150, 255) 
			or Color3.fromRGB(255, 80, 80)
		h.Parent = character
		
		state.espObjects[player] = h
	end
	
	player.CharacterAdded:Connect(function(char)
		task.wait(0.5)
		addHighlight(char)
	end)
	
	if player.Character then
		addHighlight(player.Character)
	end
end

local function removeESP(player: Player)
	if state.espObjects[player] then
		state.espObjects[player]:Destroy()
		state.espObjects[player] = nil
	end
	if player.Character then
		local h = player.Character:FindFirstChild("ESP_Highlight")
		if h then h:Destroy() end
	end
end

local function getTargetParts(character: Model)
	local parts = {}
	for _, part in ipairs(character:GetDescendants()) do
		if part:IsA("BasePart") and (
			part.Name:match("Head") or
			part.Name:match("Torso") or
			part.Name:match("Chest") or
			part.Name:match("Upper") or
			part.Name:match("HumanoidRootPart")
		) then
			table.insert(parts, part)
		end
	end
	if #parts == 0 then
		local hrp = getCenterPart(character)
		if hrp then table.insert(parts, hrp) end
	end
	return parts
end

local function createHitbox(character: Model, player: Player)
	if not character or isSameTeam(LocalPlayer, player) then return end
	
	local targetParts = getTargetParts(character)
	if #targetParts == 0 then return end
	
	for _, originalPart in ipairs(targetParts) do
		if not originalPart:FindFirstChild("HitboxExtender") then
			local hitbox = Instance.new("Part")
			hitbox.Name = "HitboxExtender"
			hitbox.Size = Vector3.new(settings.hitboxSize, settings.hitboxSize, settings.hitboxSize)
			hitbox.Transparency = 1
			hitbox.CanCollide = false
			hitbox.Massless = true
			hitbox.CFrame = originalPart.CFrame
			hitbox.Anchored = false
			
			local weld = Instance.new("WeldConstraint")
			weld.Part0 = hitbox
			weld.Part1 = originalPart
			weld.Parent = hitbox
			
			for _, existing in ipairs(originalPart:GetChildren()) do
				if existing:IsA("BodyVelocity") or existing:IsA("BodyGyro") or existing:IsA("BodyPosition") then
					existing:Destroy()
				end
			end
			
			hitbox.Parent = character
			
			if not state.hitboxParts[player] then
				state.hitboxParts[player] = {}
			end
			table.insert(state.hitboxParts[player], hitbox)
		end
	end
end

local function removeHitbox(player: Player)
	if state.hitboxParts[player] then
		for _, hitbox in ipairs(state.hitboxParts[player]) do
			if hitbox and hitbox.Parent then
				hitbox:Destroy()
			end
		end
		state.hitboxParts[player] = nil
	end
	
	if player.Character then
		for _, part in ipairs(player.Character:GetDescendants()) do
			if part.Name == "HitboxExtender" then
				part:Destroy()
			end
		end
	end
end

local function hitboxLoop()
	if not settings.hitbox then return end
	
	for _, player in ipairs(Players:GetPlayers()) do
		if player ~= LocalPlayer and player.Character then
			if not isSameTeam(LocalPlayer, player) then
				local char = player.Character
				local needsUpdate = false
				
				if not state.hitboxParts[player] or #state.hitboxParts[player] == 0 then
					needsUpdate = true
				else
					for _, hitbox in ipairs(state.hitboxParts[player]) do
						if not hitbox or not hitbox.Parent then
							needsUpdate = true
							break
						end
					end
				end
				
				if needsUpdate then
					removeHitbox(player)
					createHitbox(char, player)
				end
			else
				removeHitbox(player)
			end
		end
	end
end

local function noclipLoop()
	if not settings.noclip then return end
	
	local char = LocalPlayer.Character
	if not char then return end
	
	for _, part in ipairs(char:GetDescendants()) do
		if part:IsA("BasePart") then
			part.CanCollide = false
		end
	end
end

local function speedLoop()
	if not settings.speed then return end
	
	local char = LocalPlayer.Character
	if not char then return end
	
	local hrp = char:FindFirstChild("HumanoidRootPart")
	if not hrp then return end
	
	local moveDir = Vector3.zero
	
	if UserInputService:IsKeyDown(Enum.KeyCode.W) then
		moveDir += Camera.CFrame.LookVector
	end
	if UserInputService:IsKeyDown(Enum.KeyCode.S) then
		moveDir -= Camera.CFrame.LookVector
	end
	if UserInputService:IsKeyDown(Enum.KeyCode.A) then
		moveDir -= Camera.CFrame.RightVector
	end
	if UserInputService:IsKeyDown(Enum.KeyCode.D) then
		moveDir += Camera.CFrame.RightVector
	end
	
	if moveDir.Magnitude > 0 then
		moveDir = Vector3.new(moveDir.X, 0, moveDir.Z).Unit
		local currentVel = hrp.AssemblyLinearVelocity
		hrp.AssemblyLinearVelocity = Vector3.new(
			moveDir.X * 16 * settings.speedMultiplier,
			currentVel.Y,
			moveDir.Z * 16 * settings.speedMultiplier
		)
	end
end

local function triggerbotLoop()
	if not settings.triggerbot then return end
	
	local now = tick()
	if now - state.lastShot < settings.triggerbotDelay then return end
	
	local mouse = LocalPlayer:GetMouse()
	local origin = Camera.CFrame.Position
	local direction = (mouse.Hit.Position - origin).Unit * settings.maxDistance
	
	local rayParams = RaycastParams.new()
	rayParams.FilterDescendantsInstances = {LocalPlayer.Character}
	rayParams.FilterType = Enum.RaycastFilterType.Exclude
	rayParams.IgnoreWater = true
	
	local result = Workspace:Raycast(origin, direction, rayParams)
	
	if result and result.Instance then
		local hitPart = result.Instance
		local hitChar = hitPart:FindFirstAncestorOfClass("Model")
		
		if hitChar and state.playerCharacters[hitChar] then
			local targetPlayer = state.playerCharacters[hitChar]
			
			if not isSameTeam(LocalPlayer, targetPlayer) then
				local hum = hitChar:FindFirstChild("Humanoid")
				if hum and hum.Health > 0 then
					local distance = (origin - result.Position).Magnitude
					
					if distance <= settings.maxDistance then
						mouse1click()
						state.lastShot = now
					end
				end
			end
		end
	end
end

local function infJumpLoop()
	if not settings.infjump then return end
	if not state.canJump then return end
	
	local char = LocalPlayer.Character
	if not char then return end
	
	local hrp = char:FindFirstChild("HumanoidRootPart")
	if not hrp then return end
	
	local vel = Instance.new("BodyVelocity")
	vel.Velocity = Vector3.new(hrp.AssemblyLinearVelocity.X, settings.jumpPower, hrp.AssemblyLinearVelocity.Z)
	vel.MaxForce = Vector3.new(0, math.huge, 0)
	vel.Parent = hrp
	
	state.canJump = false
	task.wait(0.1)
	vel:Destroy()
	task.wait(0.15)
	state.canJump = true
end

local function toggleESP()
	settings.esp = not settings.esp
	updateToggleUI(espToggle, settings.esp)
	
	if settings.esp then
		for _, p in ipairs(Players:GetPlayers()) do
			if p ~= LocalPlayer then
				applyESP(p)
			end
		end
	else
		for _, p in ipairs(Players:GetPlayers()) do
			removeESP(p)
		end
		state.espObjects = {}
	end
end

local function toggleNoclip()
	settings.noclip = not settings.noclip
	updateToggleUI(noclipToggle, settings.noclip)
	
	if settings.noclip then
		if not state.noclipConnection then
			state.noclipConnection = RunService.Stepped:Connect(noclipLoop)
		end
	else
		if state.noclipConnection then
			state.noclipConnection:Disconnect()
			state.noclipConnection = nil
		end
		local char = LocalPlayer.Character
		if char then
			for _, part in ipairs(char:GetDescendants()) do
				if part:IsA("BasePart") then
					part.CanCollide = true
				end
			end
		end
	end
end

local function toggleTeamCheck()
	settings.teamCheck = not settings.teamCheck
	updateToggleUI(teamToggle, settings.teamCheck)
	
	if settings.esp then
		for _, p in ipairs(Players:GetPlayers()) do
			if p ~= LocalPlayer and p.Character then
				local h = p.Character:FindFirstChild("ESP_Highlight")
				if h then
					h.FillColor = isSameTeam(LocalPlayer, p)
						and Color3.fromRGB(80, 150, 255)
						or Color3.fromRGB(255, 80, 80)
				end
			end
		end
	end
end

local function toggleFogRemover()
	settings.fogRemover = not settings.fogRemover
	updateToggleUI(fogToggle, settings.fogRemover)
	
	if settings.fogRemover then
		disableFog()
	else
		enableFog()
	end
end

local function toggleHitbox()
	settings.hitbox = not settings.hitbox
	updateToggleUI(hitboxToggle, settings.hitbox)
	
	if settings.hitbox then
		if not state.hitboxConnection then
			state.hitboxConnection = RunService.Heartbeat:Connect(hitboxLoop)
		end
		for _, p in ipairs(Players:GetPlayers()) do
			if p ~= LocalPlayer and p.Character then
				createHitbox(p.Character, p)
			end
		end
	else
		if state.hitboxConnection then
			state.hitboxConnection:Disconnect()
			state.hitboxConnection = nil
		end
		for _, p in ipairs(Players:GetPlayers()) do
			removeHitbox(p)
		end
		state.hitboxParts = {}
	end
end

local function toggleInfJump()
	settings.infjump = not settings.infjump
	updateToggleUI(infjumpToggle, settings.infjump)
	state.canJump = true
end

local function toggleSpeed()
	settings.speed = not settings.speed
	updateToggleUI(speedToggle, settings.speed)
	
	if settings.speed then
		if not state.speedConnection then
			state.speedConnection = RunService.Heartbeat:Connect(speedLoop)
		end
	else
		if state.speedConnection then
			state.speedConnection:Disconnect()
			state.speedConnection = nil
		end
	end
end

local function toggleTriggerbot()
	settings.triggerbot = not settings.triggerbot
	updateToggleUI(triggerbotToggle, settings.triggerbot)
	
	if settings.triggerbot then
		updatePlayerCache()
		if not state.triggerbotConnection then
			state.triggerbotConnection = RunService.RenderStepped:Connect(triggerbotLoop)
		end
	else
		if state.triggerbotConnection then
			state.triggerbotConnection:Disconnect()
			state.triggerbotConnection = nil
		end
	end
end

espToggle.MouseButton1Click:Connect(toggleESP)
noclipToggle.MouseButton1Click:Connect(toggleNoclip)
teamToggle.MouseButton1Click:Connect(toggleTeamCheck)
fogToggle.MouseButton1Click:Connect(toggleFogRemover)
hitboxToggle.MouseButton1Click:Connect(toggleHitbox)
infjumpToggle.MouseButton1Click:Connect(toggleInfJump)
speedToggle.MouseButton1Click:Connect(toggleSpeed)
triggerbotToggle.MouseButton1Click:Connect(toggleTriggerbot)

local keybindMap = {
	[espKey] = {setting = "esp", func = toggleESP},
	[noclipKey] = {setting = "noclip", func = toggleNoclip},
	[teamKey] = {setting = "teamCheck", func = toggleTeamCheck},
	[fogKey] = {setting = "fogRemover", func = toggleFogRemover},
	[hitboxKey] = {setting = "hitbox", func = toggleHitbox},
	[infjumpKey] = {setting = "infjump", func = toggleInfJump},
	[speedKey] = {setting = "speed", func = toggleSpeed},
	[triggerbotKey] = {setting = "triggerbot", func = toggleTriggerbot}
}

for btn, data in pairs(keybindMap) do
	btn.MouseButton1Click:Connect(function()
		state.changingKeybind = {button = btn, setting = data.setting}
		btn.Text = "..."
		TweenService:Create(btn, TweenInfo.new(0.15, Enum.EasingStyle.Quad), {BackgroundColor3 = COLORS.accent}):Play()
	end)
end

UserInputService.InputBegan:Connect(function(input: InputObject, gp: boolean)
	if gp then return end
	
	if state.changingKeybind then
		if input.KeyCode ~= Enum.KeyCode.Unknown and input.KeyCode ~= Enum.KeyCode.Escape then
			settings.keybinds[state.changingKeybind.setting] = input.KeyCode
			state.changingKeybind.button.Text = input.KeyCode.Name
			TweenService:Create(state.changingKeybind.button, TweenInfo.new(0.15, Enum.EasingStyle.Quad), {BackgroundColor3 = COLORS.surfaceLight}):Play()
		end
		state.changingKeybind = nil
		return
	end
	
	for setting, keycode in pairs(settings.keybinds) do
		if input.KeyCode == keycode then
			if setting == "esp" then toggleESP()
			elseif setting == "noclip" then toggleNoclip()
			elseif setting == "teamCheck" then toggleTeamCheck()
			elseif setting == "fogRemover" then toggleFogRemover()
			elseif setting == "hitbox" then toggleHitbox()
			elseif setting == "infjump" then toggleInfJump()
			elseif setting == "speed" then toggleSpeed()
			elseif setting == "triggerbot" then toggleTriggerbot()
			end
		end
	end
	
	if input.KeyCode == Enum.KeyCode.Space and settings.infjump then
		infJumpLoop()
	end
end)

Players.PlayerAdded:Connect(function(p)
	if p ~= LocalPlayer then
		if settings.esp then
			applyESP(p)
		end
		p.CharacterAdded:Connect(function(char)
			task.wait(0.5)
			updatePlayerCache()
			if settings.hitbox then
				createHitbox(char, p)
			end
		end)
		if p.Character then
			updatePlayerCache()
			if settings.hitbox then
				createHitbox(p.Character, p)
			end
		end
	end
end)

Players.PlayerRemoving:Connect(function(p)
	state.espObjects[p] = nil
	removeHitbox(p)
	updatePlayerCache()
end)

LocalPlayer.CharacterAdded:Connect(function()
	task.wait(0.5)
	state.canJump = true
	updatePlayerCache()
	
	if settings.noclip and not state.noclipConnection then
		state.noclipConnection = RunService.Stepped:Connect(noclipLoop)
	end
	if settings.speed and not state.speedConnection then
		state.speedConnection = RunService.Heartbeat:Connect(speedLoop)
	end
	if settings.triggerbot and not state.triggerbotConnection then
		state.triggerbotConnection = RunService.RenderStepped:Connect(triggerbotLoop)
	end
end)

if settings.fogRemover then
	disableFog()
	RunService.RenderStepped:Connect(function()
		if settings.fogRemover then
			disableFog()
		end
	end)
end

RunService.Heartbeat:Connect(function()
	if settings.triggerbot then
		updatePlayerCache()
	end
end)

updateToggleUI(teamToggle, settings.teamCheck)
updateToggleUI(fogToggle, settings.fogRemover)
updatePlayerCache()