-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. Deal with caution.
--
-- Stay safe:
--   • Never log in on unofficial Roblox sites or lookalike domains.
--   • Real Roblox links use roblox.com (check the .com ending).
--   • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End Rscripts Risk Notice ]]

-- Byte | BloxStrike : ESP, assistance de visee et bunny hop
if not shared then
	return warn("Byte : la table shared est indisponible.")
end

if not game:IsLoaded() then
	game.Loaded:Wait()
end

-- Fermer proprement une instance precedente.
if shared.ByteBloxStrike and shared.ByteBloxStrike.destroy then
	pcall(shared.ByteBloxStrike.destroy)
end

-- Services.
local playersService = game:GetService("Players")
local runService = game:GetService("RunService")
local userInputService = game:GetService("UserInputService")
local localPlayer = playersService.LocalPlayer

local Settings = {
	esp = false,
	aim = false,
	bhop = false,
	teamCheck = true,
	espIntensity = 55,
	aimIntensity = 45,
	aimRadius = 180,
	bhopIntensity = 70,
}

local State = { connections = {}, highlights = {}, stopped = false }
shared.ByteBloxStrike = State
local gui
local main
local ring
local sliderDrag
local windowDrag
local lastJump = 0
local lastEspUpdate = 0
local savedMouseBehavior = userInputService.MouseBehavior
local savedMouseIcon = userInputService.MouseIconEnabled
local accent = Color3.fromRGB(113, 210, 255)
local background = Color3.fromRGB(15, 19, 30)
local cardColor = Color3.fromRGB(27, 33, 48)
local muted = Color3.fromRGB(157, 172, 195)

-- Centraliser les connexions pour pouvoir tout fermer en une fois.
local function connect(signal, callback)
	local connection = signal:Connect(callback)
	table.insert(State.connections, connection)
	return connection
end

local function create(className, properties)
	local object = Instance.new(className)
	for key, value in pairs(properties) do
		object[key] = value
	end
	return object
end

local function round(object, radius)
	create("UICorner", { CornerRadius = UDim.new(0, radius), Parent = object })
end

local function removeHighlight(player)
	local highlight = State.highlights[player]
	if highlight then
		highlight:Destroy()
		State.highlights[player] = nil
	end
end

-- S'abstenir si le jeu ne fournit aucune information d'equipe exploitable.
local function isEnemy(player)
	if player == localPlayer then return false end
	if not Settings.teamCheck then return true end

	if localPlayer.Team and player.Team then
		return localPlayer.Team ~= player.Team
	end

	for _, key in ipairs({ "Team", "TeamId", "TeamID", "Side", "Faction" }) do
		local ownTeam = localPlayer:GetAttribute(key)
		local otherTeam = player:GetAttribute(key)

		if ownTeam ~= nil and otherTeam ~= nil then
			return tostring(ownTeam) ~= tostring(otherTeam)
		end
	end

	if not localPlayer.Neutral and not player.Neutral then
		return localPlayer.TeamColor ~= player.TeamColor
	end

	return false
end

local function getLivingCharacter(player)
	local character = player.Character
	if not character then return nil end

	local humanoid = character:FindFirstChildOfClass("Humanoid")
	local root = character:FindFirstChild("HumanoidRootPart")

	if not humanoid or humanoid.Health <= 0 or not root then
		return nil
	end

	return character, humanoid, root
end

-- Ne colorer que les personnages disponibles sur le client.
local function updateEsp()
	for _, player in ipairs(playersService:GetPlayers()) do
		local character = getLivingCharacter(player)

		if Settings.esp and character and isEnemy(player) then
			local highlight = State.highlights[player]

			if highlight and highlight.Adornee ~= character then
				removeHighlight(player)
				highlight = nil
			end

			if not highlight then
				highlight = create("Highlight", {
					Name = "ByteHighlight",
					Adornee = character,
					DepthMode = Enum.HighlightDepthMode.AlwaysOnTop,
					FillColor = Color3.fromRGB(255, 88, 115),
					OutlineColor = Color3.fromRGB(255, 226, 232),
					OutlineTransparency = 0.05,
					Parent = character,
				})

				State.highlights[player] = highlight
			end

			highlight.FillTransparency = 1 - Settings.espIntensity / 100
		else
			removeHighlight(player)
		end
	end

	for player in pairs(State.highlights) do
		if player.Parent ~= playersService then
			removeHighlight(player)
		end
	end
end

-- Choisir la cible vivante la plus proche du curseur dans le rayon choisi.
local function getClosestPlayer(camera)
	local closest, closestDist = nil, Settings.aimRadius
	local mousePos = userInputService:GetMouseLocation()

	for _, player in ipairs(playersService:GetPlayers()) do
		if isEnemy(player) then
			local character, humanoid, root = getLivingCharacter(player)

			if character and humanoid and root then
				local screenPos, onScreen = camera:WorldToViewportPoint(root.Position)

				if onScreen and screenPos.Z > 0 then
					local dist = (Vector2.new(screenPos.X, screenPos.Y) - mousePos).Magnitude

					if dist <= closestDist then
						closest, closestDist = root, dist
					end
				end
			end
		end
	end

	return closest
end

-- Supprimer l'interface, les effets et les connexions.
function State.destroy()
	if State.stopped then return end

	State.stopped = true
	runService:UnbindFromRenderStep("ByteBloxStrikeRender")

	for _, connection in ipairs(State.connections) do
		connection:Disconnect()
	end

	for player in pairs(State.highlights) do
		removeHighlight(player)
	end

	userInputService.MouseBehavior = savedMouseBehavior
	userInputService.MouseIconEnabled = savedMouseIcon

	if gui then
		gui:Destroy()
	end

	if shared.ByteBloxStrike == State then
		shared.ByteBloxStrike = nil
	end
end

local function initializeScript()
	local guiParent = (gethui and gethui()) or game:GetService("CoreGui")

	gui = create("ScreenGui", {
		Name = "ByteBloxStrike",
		ResetOnSpawn = false,
		IgnoreGuiInset = true,
		ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
		Parent = guiParent,
	})

	-- Dessiner le rayon de selection autour du curseur.
	ring = create("Frame", {
		Name = "AimRadius",
		BackgroundTransparency = 1,
		AnchorPoint = Vector2.new(0.5, 0.5),
		Visible = false,
		Parent = gui,
	})

	round(ring, 9999)
	create("UIStroke", {
		Color = accent,
		Transparency = 0.35,
		Thickness = 1,
		Parent = ring,
	})

	main = create("Frame", {
		Name = "Main",
		Size = UDim2.fromOffset(392, 490),
		Position = UDim2.new(0.5, -196, 0.5, -245),
		BackgroundColor3 = background,
		BorderSizePixel = 0,
		Parent = gui,
	})

	round(main, 15)
	create("UIStroke", {
		Color = Color3.fromRGB(61, 80, 104),
		Thickness = 1,
		Parent = main,
	})

	local header = create("Frame", {
		Size = UDim2.new(1, 0, 0, 64),
		BackgroundTransparency = 1,
		Active = true,
		Parent = main,
	})

	create("TextLabel", {
		Position = UDim2.fromOffset(18, 10),
		Size = UDim2.new(1, -65, 0, 26),
		BackgroundTransparency = 1,
		Text = "BYTE  /  BLOXSTRIKE",
		TextColor3 = Color3.fromRGB(238, 246, 255),
		Font = Enum.Font.GothamBold,
		TextSize = 17,
		TextXAlignment = Enum.TextXAlignment.Left,
		Parent = header,
	})

	create("TextLabel", {
		Position = UDim2.fromOffset(19, 35),
		Size = UDim2.new(1, -65, 0, 18),
		BackgroundTransparency = 1,
		Text = "VISUALS  •  AIM  •  MOVEMENT",
		TextColor3 = muted,
		Font = Enum.Font.Gotham,
		TextSize = 10,
		TextXAlignment = Enum.TextXAlignment.Left,
		Parent = header,
	})

	local close = create("TextButton", {
		Position = UDim2.new(1, -46, 0, 13),
		Size = UDim2.fromOffset(30, 30),
		BackgroundColor3 = cardColor,
		Text = "×",
		TextColor3 = muted,
		Font = Enum.Font.Gotham,
		TextSize = 22,
		AutoButtonColor = true,
		Parent = header,
	})

	round(close, 8)
	connect(close.MouseButton1Click, State.destroy)

	local content = create("Frame", {
		Position = UDim2.fromOffset(16, 68),
		Size = UDim2.new(1, -32, 0, 360),
		BackgroundTransparency = 1,
		Parent = main,
	})

	create("UIListLayout", {
		Padding = UDim.new(0, 4),
		SortOrder = Enum.SortOrder.LayoutOrder,
		Parent = content,
	})

	local order = 0

	local function makeToggle(title, description, key)
		order = order + 1

		local row = create("Frame", {
			LayoutOrder = order,
			Size = UDim2.new(1, 0, 0, 40),
			BackgroundColor3 = cardColor,
			BorderSizePixel = 0,
			Parent = content,
		})

		round(row, 8)

		create("TextLabel", {
			Position = UDim2.fromOffset(11, 4),
			Size = UDim2.new(1, -90, 0, 17),
			BackgroundTransparency = 1,
			Text = title,
			TextColor3 = Color3.fromRGB(237, 244, 255),
			Font = Enum.Font.GothamBold,
			TextSize = 12,
			TextXAlignment = Enum.TextXAlignment.Left,
			Parent = row,
		})

		create("TextLabel", {
			Position = UDim2.fromOffset(11, 20),
			Size = UDim2.new(1, -90, 0, 15),
			BackgroundTransparency = 1,
			Text = description,
			TextColor3 = muted,
			Font = Enum.Font.Gotham,
			TextSize = 10,
			TextXAlignment = Enum.TextXAlignment.Left,
			Parent = row,
		})

		local button = create("TextButton", {
			Position = UDim2.new(1, -65, 0.5, -13),
			Size = UDim2.fromOffset(54, 26),
			Font = Enum.Font.GothamBold,
			TextSize = 10,
			AutoButtonColor = false,
			Parent = row,
		})

		round(button, 7)

		local function update()
			button.Text = Settings[key] and "ON" or "OFF"
			button.BackgroundColor3 = Settings[key] and accent or Color3.fromRGB(48, 57, 74)
			button.TextColor3 = Settings[key] and background or muted
		end

		connect(button.MouseButton1Click, function()
			Settings[key] = not Settings[key]
			update()

			if key == "esp" or key == "teamCheck" then
				updateEsp()
			end
		end)

		update()
	end

	local function makeSlider(title, key, minimum, maximum, suffix)
		order = order + 1

		local row = create("Frame", {
			LayoutOrder = order,
			Size = UDim2.new(1, 0, 0, 38),
			BackgroundTransparency = 1,
			Parent = content,
		})

		local label = create("TextLabel", {
			Size = UDim2.new(1, 0, 0, 19),
			BackgroundTransparency = 1,
			TextColor3 = muted,
			Font = Enum.Font.Gotham,
			TextSize = 11,
			TextXAlignment = Enum.TextXAlignment.Left,
			Parent = row,
		})

		local track = create("TextButton", {
			Position = UDim2.fromOffset(0, 25),
			Size = UDim2.new(1, 0, 0, 9),
			BackgroundColor3 = Color3.fromRGB(48, 57, 74),
			Text = "",
			AutoButtonColor = false,
			BorderSizePixel = 0,
			Parent = row,
		})

		round(track, 5)

		local fill = create("Frame", {
			Size = UDim2.fromScale(0, 1),
			BackgroundColor3 = accent,
			BorderSizePixel = 0,
			Parent = track,
		})

		round(fill, 5)

		local function display()
			local fraction = (Settings[key] - minimum) / (maximum - minimum)
			fill.Size = UDim2.fromScale(fraction, 1)
			label.Text = title .. "  ·  " .. tostring(Settings[key]) .. suffix
		end

		local function setFromX(x)
			local width = track.AbsoluteSize.X
			if width <= 0 then return end

			local fraction = math.clamp(
				(x - track.AbsolutePosition.X) / width,
				0,
				1
			)

			Settings[key] = math.floor(
				minimum + fraction * (maximum - minimum) + 0.5
			)

			display()
		end

		connect(track.InputBegan, function(input)
			if input.UserInputType == Enum.UserInputType.MouseButton1 then
				sliderDrag = setFromX
				setFromX(input.Position.X)
			end
		end)

		display()
	end

	makeToggle("ESP", "Ennemis visibles a travers les murs", "esp")
	makeSlider("Intensite ESP", "espIntensity", 5, 95, "%")

	makeToggle("AIM ASSIST", "Maintenir le clic droit pour viser", "aim")
	makeSlider("Intensite de la visee", "aimIntensity", 1, 100, "%")
	makeSlider("Rayon de visee", "aimRadius", 40, 500, " px")

	makeToggle("BUNNY HOP", "Maintenir Espace pour enchainer les sauts", "bhop")
	makeSlider("Frequence des sauts", "bhopIntensity", 1, 100, "%")

	makeToggle(
		"FILTRE EQUIPE",
		"Cible uniquement les adversaires identifies",
		"teamCheck"
	)

	create("TextLabel", {
		Position = UDim2.new(0, 14, 1, -42),
		Size = UDim2.new(1, -28, 0, 30),
		BackgroundTransparency = 1,
		Text = "INSERT : menu   •   CLIC DROIT : viser   •   ESPACE : sauter",
		TextColor3 = muted,
		Font = Enum.Font.Gotham,
		TextSize = 10,
		TextXAlignment = Enum.TextXAlignment.Center,
		Parent = main,
	})

	connect(header.InputBegan, function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1 then
			windowDrag = {
				start = input.Position,
				position = main.Position,
			}
		end
	end)

	connect(userInputService.InputChanged, function(input)
		if input.UserInputType ~= Enum.UserInputType.MouseMovement then
			return
		end

		if sliderDrag then
			sliderDrag(input.Position.X)
		end

		if windowDrag then
			local delta = input.Position - windowDrag.start
			local position = windowDrag.position

			main.Position = UDim2.new(
				position.X.Scale,
				position.X.Offset + delta.X,
				position.Y.Scale,
				position.Y.Offset + delta.Y
			)
		end
	end)

	connect(userInputService.InputEnded, function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1 then
			sliderDrag, windowDrag = nil, nil
		end
	end)

	connect(userInputService.InputBegan, function(input, processed)
		if not processed and input.KeyCode == Enum.KeyCode.Insert then
			main.Visible = not main.Visible

			if main.Visible then
				savedMouseBehavior = userInputService.MouseBehavior
				savedMouseIcon = userInputService.MouseIconEnabled
			else
				userInputService.MouseBehavior = savedMouseBehavior
				userInputService.MouseIconEnabled = savedMouseIcon
			end
		end
	end)

	-- Suivre les personnages et enchainer les sauts au sol.
	connect(runService.Heartbeat, function()
		local now = os.clock()

		if now - lastEspUpdate >= 0.2 then
			lastEspUpdate = now
			updateEsp()
		end

		if not Settings.bhop or main.Visible or userInputService:GetFocusedTextBox() then
			return
		end

		if not userInputService:IsKeyDown(Enum.KeyCode.Space) then
			return
		end

		local character = localPlayer.Character
		local humanoid = character and character:FindFirstChildOfClass("Humanoid")
		local delay = 0.5 - 0.0045 * Settings.bhopIntensity

		if humanoid
			and humanoid.Health > 0
			and humanoid.FloorMaterial ~= Enum.Material.Air
			and now - lastJump >= delay
		then
			lastJump = now
			humanoid.Jump = true
		end
	end)

	-- Appliquer la visee apres la mise a jour normale de la camera.
	runService:BindToRenderStep(
		"ByteBloxStrikeRender",
		Enum.RenderPriority.Camera.Value + 1,
		function(deltaTime)
			local camera = workspace.CurrentCamera
			if not camera then return end

			if main.Visible then
				userInputService.MouseBehavior = Enum.MouseBehavior.Default
				userInputService.MouseIconEnabled = true
			end

			local mousePos = userInputService:GetMouseLocation()

			ring.Size = UDim2.fromOffset(
				Settings.aimRadius * 2,
				Settings.aimRadius * 2
			)

			ring.Position = UDim2.fromOffset(mousePos.X, mousePos.Y)
			ring.Visible = Settings.aim and not main.Visible

			if not Settings.aim or main.Visible or userInputService:GetFocusedTextBox() then
				return
			end

			if not userInputService:IsMouseButtonPressed(
				Enum.UserInputType.MouseButton2
			) then
				return
			end

			local target = getClosestPlayer(camera)

			if target then
				local current = camera.CFrame
				local goal = CFrame.lookAt(current.Position, target.Position)
				local strength = 1 + Settings.aimIntensity * 0.25
				local alpha = 1 - math.exp(-strength * math.min(deltaTime, 0.1))

				camera.CFrame = current:Lerp(goal, alpha)
			end
		end
	)
end

local function onInitializeError(errorMessage)
	warn("Byte : initialisation impossible : " .. tostring(errorMessage))
	warn(debug.traceback())
	State.destroy()
end

xpcall(initializeScript, onInitializeError)