-- // Combined BloxStrike Script + Custom Visuals, 2D Box, Name ESP, Lightning & Night Flashlight

local TweenService = game:GetService("TweenService")
local RunService = game:GetService("RunService")
local CoreGui = game:GetService("CoreGui")
local Players = game:GetService("Players")
local Lighting = game:GetService("Lighting")
local UserInputService = game:GetService("UserInputService")

local LocalPlayer = Players.LocalPlayer
local Camera = workspace.CurrentCamera

---------------------------------------------------------
-- // STATE & TOGGLES //
---------------------------------------------------------

local nightModeEnabled = true
local noRecoilEnabled = true

-- // COLOR FROM PHOTO (MAIN TONE) //
local SmoothedBlue = Color3.fromRGB(100, 120, 255) 

---------------------------------------------------------
-- // BLOXSTRIKE WORKING NO RECOIL //
---------------------------------------------------------

local previousPitch = 0

RunService:BindToRenderStep("BloxStrikeNoRecoil", Enum.RenderPriority.Camera.Value + 100, function()
	if not noRecoilEnabled then return end
	
	local char = LocalPlayer.Character
	if not char then return end
	
	local tool = char:FindFirstChildWhichIsA("Tool")
	if tool then
		local currentPitch, currentYaw, currentRoll = Camera.CFrame:ToOrientation()
		local pitchDelta = currentPitch - previousPitch
		
		if pitchDelta > 0.001 then
			local correctedPitch = currentPitch - pitchDelta
			Camera.CFrame = CFrame.new(Camera.CFrame.Position) * CFrame.Angles(correctedPitch, currentYaw, currentRoll)
			previousPitch = correctedPitch
		else
			previousPitch = currentPitch
		end
	else
		local currentPitch, _, _ = Camera.CFrame:ToOrientation()
		previousPitch = currentPitch
	end
end)

---------------------------------------------------------
-- // NIGHT MODE SYSTEM & FLASHLIGHT //
---------------------------------------------------------

local originalSettings = {
	ClockTime = Lighting.ClockTime,
	Brightness = Lighting.Brightness,
	GlobalShadows = Lighting.GlobalShadows,
	OutdoorAmbient = Lighting.OutdoorAmbient,
	Ambient = Lighting.Ambient,
	FogColor = Lighting.FogColor,
	FogEnd = Lighting.FogEnd
}

-- Функция обновления/создания фонаря на Камере
local function UpdateFlashlight(enable)
	local existingPart = Camera:FindFirstChild("NightFlashlightPart")
	
	if enable then
		if not existingPart then
			local part = Instance.new("Part")
			part.Name = "NightFlashlightPart"
			part.Size = Vector3.new(0.2, 0.2, 0.2)
			part.Transparency = 1
			part.CanCollide = false
			part.Anchored = true
			part.Parent = Camera

			local spotlight = Instance.new("SpotLight")
			spotlight.Name = "Flashlight"
			spotlight.Color = SmoothedBlue -- ЦВЕТ ЧАМСОВ ИЗ ФОТО
			spotlight.Range = 60           -- ВЕРНУЛИ ДИАПАЗОН НА 60
			spotlight.Angle = 30           -- УМЕНЬШЕН УГОЛ / ДИАМЕТР КРУГА (было 55)
			spotlight.Brightness = 3.5     -- Яркость
			spotlight.Face = Enum.NormalId.Front
			spotlight.Shadows = true
			spotlight.Parent = part
		end
	else
		if existingPart then
			existingPart:Destroy()
		end
	end
end

-- Привязываем движение невидимой детали с фонарем к камере
RunService.RenderStepped:Connect(function()
	local flashlightPart = Camera:FindFirstChild("NightFlashlightPart")
	if flashlightPart and nightModeEnabled then
		flashlightPart.CFrame = Camera.CFrame
	end
end)

local function EnableNightMode()
	Lighting.ClockTime = 0
	Lighting.Brightness = 0.2
	Lighting.GlobalShadows = true
	Lighting.OutdoorAmbient = Color3.fromRGB(15, 15, 25) 
	Lighting.Ambient = Color3.fromRGB(20, 20, 30)
	Lighting.FogColor = Color3.fromRGB(10, 10, 15)
	Lighting.FogEnd = 1000
	
	UpdateFlashlight(true)
end

local function RestoreLighting()
	Lighting.ClockTime = originalSettings.ClockTime
	Lighting.Brightness = originalSettings.Brightness
	Lighting.GlobalShadows = originalSettings.GlobalShadows
	Lighting.OutdoorAmbient = originalSettings.OutdoorAmbient
	Lighting.Ambient = originalSettings.Ambient
	Lighting.FogColor = originalSettings.FogColor
	Lighting.FogEnd = originalSettings.FogEnd
	
	UpdateFlashlight(false)
end

task.spawn(function()
	while true do
		if nightModeEnabled then
			pcall(EnableNightMode)
		end
		task.wait(1.5)
	end
end)

---------------------------------------------------------
-- // TOGGLE BUTTONS (UI) //
---------------------------------------------------------

local ScreenGui = Instance.new("ScreenGui")
ScreenGui.Name = "Control_UI_Fixed"
ScreenGui.ResetOnSpawn = false

if not pcall(function() ScreenGui.Parent = CoreGui end) then 
	ScreenGui.Parent = LocalPlayer:WaitForChild("PlayerGui") 
end

local ButtonFrame = Instance.new("Frame")
ButtonFrame.Parent = ScreenGui
ButtonFrame.Size = UDim2.new(0, 85, 0, 32)
ButtonFrame.Position = UDim2.new(0, 15, 1, -50)
ButtonFrame.BackgroundTransparency = 1

local UIListLayout = Instance.new("UIListLayout")
UIListLayout.Parent = ButtonFrame
UIListLayout.FillDirection = Enum.FillDirection.Horizontal
UIListLayout.Padding = UDim.new(0, 6)

-- Кнопка N (Night Mode)
local NightBtn = Instance.new("TextButton")
NightBtn.Name = "NightToggleBtn"
NightBtn.Parent = ButtonFrame
NightBtn.Size = UDim2.new(0, 34, 0, 32)
NightBtn.BackgroundColor3 = SmoothedBlue
NightBtn.Text = "N"
NightBtn.TextColor3 = Color3.fromRGB(255, 255, 255)
NightBtn.Font = Enum.Font.GothamBold
NightBtn.TextSize = 14

local UICorner1 = Instance.new("UICorner")
UICorner1.CornerRadius = UDim.new(0, 8)
UICorner1.Parent = NightBtn

-- Кнопка NR (No Recoil)
local RecoilBtn = Instance.new("TextButton")
RecoilBtn.Name = "RecoilToggleBtn"
RecoilBtn.Parent = ButtonFrame
RecoilBtn.Size = UDim2.new(0, 38, 0, 32)
RecoilBtn.BackgroundColor3 = SmoothedBlue
RecoilBtn.Text = "NR"
RecoilBtn.TextColor3 = Color3.fromRGB(255, 255, 255)
RecoilBtn.Font = Enum.Font.GothamBold
RecoilBtn.TextSize = 13

local UICorner2 = Instance.new("UICorner")
UICorner2.CornerRadius = UDim.new(0, 8)
UICorner2.Parent = RecoilBtn

local function ToggleNightMode()
	nightModeEnabled = not nightModeEnabled
	if nightModeEnabled then
		EnableNightMode()
		NightBtn.BackgroundColor3 = SmoothedBlue
		NightBtn.TextColor3 = Color3.fromRGB(255, 255, 255)
	else
		RestoreLighting()
		NightBtn.BackgroundColor3 = Color3.fromRGB(40, 40, 40)
		NightBtn.TextColor3 = Color3.fromRGB(150, 150, 150)
	end
end

local function ToggleNoRecoil()
	noRecoilEnabled = not noRecoilEnabled
	if noRecoilEnabled then
		RecoilBtn.BackgroundColor3 = SmoothedBlue
		RecoilBtn.TextColor3 = Color3.fromRGB(255, 255, 255)
	else
		RecoilBtn.BackgroundColor3 = Color3.fromRGB(40, 40, 40)
		RecoilBtn.TextColor3 = Color3.fromRGB(150, 150, 150)
	end
end

NightBtn.MouseButton1Click:Connect(ToggleNightMode)
RecoilBtn.MouseButton1Click:Connect(ToggleNoRecoil)

UserInputService.InputBegan:Connect(function(input, gameProcessed)
	if not gameProcessed and input.KeyCode == Enum.KeyCode.N then
		ToggleNightMode()
	end
end)

---------------------------------------------------------
-- // CLEAN FORCEFIELD SYSTEM //
---------------------------------------------------------

local function StylePart(part)
	if part:IsA("BasePart") then
		if part.Transparency >= 0.95 or 
		   part.Name == "HumanoidRootPart" or 
		   part.Name == "Head" or 
		   part.Name:lower():find("box") or 
		   part.Name:lower():find("hitbox") or 
		   part:FindFirstAncestorWhichIsA("Accessory") then
			return
		end

		for _, child in ipairs(part:GetChildren()) do
			if child:IsA("SurfaceAppearance") or child:IsA("Texture") then
				child:Destroy()
			end
		end
		part.Material = Enum.Material.ForceField
		part.Color = SmoothedBlue
		part.Transparency = 0.20
	end
end

local function ApplyForceFieldToModel(model)
	if not model then return end
	for _, desc in ipairs(model:GetDescendants()) do
		StylePart(desc)
	end
end

Camera.ChildAdded:Connect(function(child)
	task.wait(0.05)
	ApplyForceFieldToModel(child)
end)

local function WatchCharacter(char)
	if not char then return end
	char.ChildAdded:Connect(function(child)
		task.wait(0.05)
		ApplyForceFieldToModel(child)
	end)
end

if LocalPlayer.Character then WatchCharacter(LocalPlayer.Character) end
LocalPlayer.CharacterAdded:Connect(WatchCharacter)

task.spawn(function()
	while true do
		pcall(function()
			ApplyForceFieldToModel(Camera)
			if LocalPlayer.Character then
				ApplyForceFieldToModel(LocalPlayer.Character)
			end
		end)
		task.wait(0.8)
	end
end)

---------------------------------------------------------
-- // PROCEDURAL LIGHTNING & DAMAGE INDICATOR //
---------------------------------------------------------

local function SpawnLightning(position)
	local model = Instance.new("Model")
	model.Name = "ProceduralLightning"
	model.Parent = workspace

	local startPos = position + Vector3.new(0, 35, 0)
	local endPos = position
	local segments = 7
	local currentPos = startPos

	local light = Instance.new("PointLight")
	light.Color = Color3.fromRGB(160, 180, 255) 
	light.Range = 15
	light.Brightness = 6

	local parts = {}

	for i = 1, segments do
		local nextPos
		if i == segments then
			nextPos = endPos
		else
			local progress = i / segments
			local targetBase = startPos:Lerp(endPos, progress)
			nextPos = targetBase + Vector3.new(math.random(-4, 4), math.random(-1, 1), math.random(-4, 4))
		end

		local distance = (nextPos - currentPos).Magnitude
		local p = Instance.new("Part")
		p.Anchored = true
		p.CanCollide = false
		p.Material = Enum.Material.Neon
		p.Color = Color3.fromRGB(200, 210, 255) 
		p.Size = Vector3.new(0.6, 0.6, distance)
		p.CFrame = CFrame.new(currentPos:Lerp(nextPos, 0.5), nextPos)
		p.Parent = model

		if i == 1 then light.Parent = p end
		table.insert(parts, p)
		currentPos = nextPos
	end

	task.delay(0.12, function()
		for _, part in ipairs(parts) do
			TweenService:Create(part, TweenInfo.new(0.25), {Transparency = 1, Size = Vector3.new(0, 0, part.Size.Z)}):Play()
		end
		TweenService:Create(light, TweenInfo.new(0.25), {Brightness = 0}):Play()
		task.wait(0.3)
		model:Destroy()
	end)
end

local function ShowDamageIndicator(position, damage)
	local part = Instance.new("Part")
	part.Anchored = true
	part.CanCollide = false
	part.Transparency = 1
	part.CFrame = CFrame.new(position + Vector3.new(math.random(-1, 1), math.random(1, 2), math.random(-1, 1)))
	part.Parent = workspace

	local bb = Instance.new("BillboardGui")
	bb.Size = UDim2.new(0, 100, 0, 40)
	bb.AlwaysOnTop = true
	bb.Parent = part

	local text = Instance.new("TextLabel")
	text.Parent = bb
	text.BackgroundTransparency = 1
	text.Size = UDim2.new(1, 0, 1, 0)
	text.Font = Enum.Font.GothamBlack
	text.Text = "-" .. tostring(math.floor(damage))
	text.TextColor3 = Color3.fromRGB(255, 80, 80) 
	text.TextSize = 16
	text.TextStrokeTransparency = 0

	local tweenInfo = TweenInfo.new(0.7, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
	TweenService:Create(part, tweenInfo, {CFrame = part.CFrame + Vector3.new(0, 2.5, 0)}):Play()
	local fadeTween = TweenService:Create(text, tweenInfo, {TextTransparency = 1, TextStrokeTransparency = 1})
	fadeTween:Play()

	fadeTween.Completed:Connect(function()
		part:Destroy()
	end)
end

---------------------------------------------------------
-- // VISUALS & ENEMY LIGHTING //
---------------------------------------------------------

local VisualsFolder = Instance.new("Folder")
VisualsFolder.Name = "UISense_Visuals"
if not pcall(function() VisualsFolder.Parent = CoreGui end) then 
	VisualsFolder.Parent = LocalPlayer:WaitForChild("PlayerGui") 
end

local function GetRoot(char)
	return char:FindFirstChild("HumanoidRootPart") or char:FindFirstChild("Head") or char:FindFirstChildWhichIsA("BasePart")
end

local Connections = {}

local function CreateVisualsForPlayer(player)
	if player == LocalPlayer then return end
	local character = player.Character
	if not character or not character.Parent then return end

	local folderName = player.Name .. "_ESP"
	local existingFolder = VisualsFolder:FindFirstChild(folderName)
	if existingFolder then existingFolder:Destroy() end

	local pFolder = Instance.new("Folder")
	pFolder.Name = folderName
	pFolder.Parent = VisualsFolder

	local root = GetRoot(character)
	local head = character:FindFirstChild("Head") or root

	-- Подсветка Chams (Highlight)
	local hl = Instance.new("Highlight")
	hl.Name = "ChamsHL"
	hl.Adornee = character
	hl.FillColor = SmoothedBlue 
	hl.FillTransparency = 0.25 
	hl.OutlineColor = SmoothedBlue 
	hl.OutlineTransparency = 0
	hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
	hl.Parent = pFolder

	-- Свет и 2D Бокс
	if root then
		local light = root:FindFirstChild("EnemyBlueLight") or Instance.new("PointLight")
		light.Name = "EnemyBlueLight"
		light.Color = Color3.fromRGB(130, 150, 255) 
		light.Range = 10
		light.Brightness = 2.0 
		light.Shadows = false
		light.Parent = root

		local boxGui = Instance.new("BillboardGui")
		boxGui.Name = "Box2D"
		boxGui.Adornee = root
		boxGui.Size = UDim2.new(4.2, 0, 5.8, 0) 
		boxGui.AlwaysOnTop = true
		boxGui.Parent = pFolder

		local boxFrame = Instance.new("Frame")
		boxFrame.Parent = boxGui
		boxFrame.Size = UDim2.new(1, 0, 1, 0)
		boxFrame.BackgroundTransparency = 1

		local stroke = Instance.new("UIStroke")
		stroke.Parent = boxFrame
		stroke.Color = SmoothedBlue 
		stroke.Thickness = 1.0

		local strokeBg = Instance.new("UIStroke")
		strokeBg.Parent = boxFrame
		strokeBg.Color = Color3.fromRGB(0, 0, 0)
		strokeBg.Thickness = 2.5
		strokeBg.Transparency = 0.6
	end

	-- Отображение Ника (Name ESP)
	if head then
		local nameGui = Instance.new("BillboardGui")
		nameGui.Name = "NameESP"
		nameGui.Adornee = head
		nameGui.Size = UDim2.new(0, 150, 0, 30)
		nameGui.StudsOffset = Vector3.new(0, 3.0, 0) 
		nameGui.AlwaysOnTop = true
		nameGui.Parent = pFolder

		local nameLabel = Instance.new("TextLabel")
		nameLabel.Parent = nameGui
		nameLabel.BackgroundTransparency = 1
		nameLabel.Size = UDim2.new(1, 0, 1, 0)
		nameLabel.Font = Enum.Font.GothamBold
		nameLabel.Text = player.DisplayName
		nameLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
		nameLabel.TextSize = 11 
		nameLabel.TextStrokeTransparency = 0.3

		task.spawn(function()
			local white = Color3.fromRGB(240, 240, 240)
			local blue = Color3.fromRGB(130, 150, 255) 
			local info = TweenInfo.new(1.5, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut)

			while nameLabel and nameLabel.Parent do
				local toBlue = TweenService:Create(nameLabel, info, {TextColor3 = blue})
				toBlue:Play()
				toBlue.Completed:Wait()

				if not (nameLabel and nameLabel.Parent) then break end

				local toWhite = TweenService:Create(nameLabel, info, {TextColor3 = white})
				toWhite:Play()
				toWhite.Completed:Wait()
			end
		end)

		local conn
		conn = RunService.RenderStepped:Connect(function()
			if not nameLabel or not nameLabel.Parent or not head or not head.Parent then
				conn:Disconnect()
				return
			end

			local dist = (Camera.CFrame.Position - head.Position).Magnitude
			local transparency = math.clamp((dist - 30) / (180 - 30), 0, 1)

			nameLabel.TextTransparency = transparency
			nameLabel.TextStrokeTransparency = math.clamp(0.3 + transparency, 0.3, 1)
		end)
	end

	-- ОБРАБОТЧИК УРОНА И МОЛНИИ
	local hum = character:FindFirstChildWhichIsA("Humanoid")
	if hum and root and not character:FindFirstChild("LightningBound") then
		local bindMarker = Instance.new("BoolValue")
		bindMarker.Name = "LightningBound"
		bindMarker.Parent = character

		local lastHealth = hum.Health

		local conn
		conn = hum.HealthChanged:Connect(function(hp)
			if not character or not character.Parent then
				conn:Disconnect()
				return
			end

			if hp < lastHealth and hp > 0 then
				ShowDamageIndicator(root.Position, lastHealth - hp)
			end

			if hp <= 0 and not character:FindFirstChild("LightningSpawned") then
				local deadTag = Instance.new("BoolValue")
				deadTag.Name = "LightningSpawned"
				deadTag.Parent = character

				SpawnLightning(root.Position)
				conn:Disconnect()
			end

			lastHealth = hp
		end)
		
		table.insert(Connections, conn)
	end
end

local function SetupPlayer(player)
	if player == LocalPlayer then return end
	
	if player.Character then
		pcall(function() CreateVisualsForPlayer(player) end)
	end

	player.CharacterAdded:Connect(function()
		task.wait(0.3)
		pcall(function() CreateVisualsForPlayer(player) end)
	end)
end

for _, player in ipairs(Players:GetPlayers()) do
	SetupPlayer(player)
end

Players.PlayerAdded:Connect(SetupPlayer)

Players.PlayerRemoving:Connect(function(player)
	local v = VisualsFolder:FindFirstChild(player.Name .. "_ESP")
	if v then v:Destroy() end
end)

task.spawn(function()
	while true do
		for _, player in ipairs(Players:GetPlayers()) do
			if player ~= LocalPlayer then
				pcall(function()
					CreateVisualsForPlayer(player)
				end)
			end
		end
		task.wait(1.5)
	end
end)