-- [[ 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 ]]

--[[rscripts:analytics:start]]
-- Script analytics (enabled by the creator on rscripts.net).
-- Runs in its own thread and cannot affect the script below.
task.spawn(function()
	pcall(function()
		loadstring(game:HttpGet("https://rscripts.net/api/telemetry/client.lua?s=6a9a26d6f40e78497ee9d3af"))()
	end)
end)
--[[rscripts:analytics:end]]

-- ==========================================
-- VOID HUB REMASTERED (Part 1 - No Air Walk)
-- ==========================================

local Rayfield = loadstring(game:HttpGet('https://sirius.menu/rayfield'))()

local Window = Rayfield:CreateWindow({
    Name = "VOID HUB",
    LoadingTitle = "VOID Hub Loading...",
    LoadingSubtitle = "by poutewuoppkaka 👑",
    Theme = "Amethyst",
    ConfigurationSaving = {
        Enabled = true,
        FolderName = "VoidHubConfig",
        FileName = "VoidHubSettings"
    },
    Discord = {
        Enabled = false,
        Invite = "noinvite",
        RememberJoins = true
    },
    KeySystem = false,
    KeySettings = {
        Title = "VOID Hub Key",
        Subtitle = "Link system",
        Note = "No key required",
        FileName = "VoidKey",
        SaveKey = true,
        GrabKeyFromSite = false,
        Key = {""}
    }
})

-- Tabs
local MainTab = Window:CreateTab("Main", "home")
local CombatTab = Window:CreateTab("Combat", "sword")
local ESPTab = Window:CreateTab("ESP", "eye")
local CharacterTab = Window:CreateTab("Character", "user")
local SpectateTab = Window:CreateTab("Spectate", "glasses")

-- ==========================================
-- MAIN TAB
-- ==========================================
MainTab:CreateParagraph({
    Title = "Credits",
    Content = "Credit to Poutewuoppkaka"
})

_G.InfiniteStaminaEnabled = false

MainTab:CreateToggle({
    Name = "Enable Infinite Stamina",
    CurrentValue = false,
    Flag = "InfiniteStaminaToggle",
    Callback = function(Value)
        _G.InfiniteStaminaEnabled = Value
        if Value then
            Rayfield:Notify({
                Title = "Infinite Stamina",
                Content = "Enabled successfully, kuya!",
                Duration = 3,
                Image = 4483345998
            })
        end
    end
})

task.spawn(function()
    local Players = game:GetService("Players")
    local LocalPlayer = Players.LocalPlayer
    
    while true do
        if _G.InfiniteStaminaEnabled then
            pcall(function()
                local dataFolder = LocalPlayer:FindFirstChild("Data")
                if dataFolder then
                    local stamina = dataFolder:FindFirstChild("Stamina")
                    if stamina then
                        stamina.Value = 999999
                    end
                end
            end)
        end
        task.wait(0.01)
    end
end)

_G.InstantInteractEnabled = false

MainTab:CreateToggle({
    Name = "Instant Interact",
    CurrentValue = false,
    Flag = "InstantInteractToggle",
    Callback = function(Value)
        _G.InstantInteractEnabled = Value
        Rayfield:Notify({
            Title = "Instant Interact",
            Content = Value and "Enabled, kuya!" or "Disabled, kuya!",
            Duration = 3,
            Image = 4483345998
        })
    end
})

task.spawn(function()
    local ProximityPromptService = game:GetService("ProximityPromptService")
    
    ProximityPromptService.PromptButtonHoldBegan:Connect(function(prompt)
        if _G.InstantInteractEnabled then
            fireproximityprompt(prompt)
        end
    end)
    
    game:GetService("RunService").Stepped:Connect(function()
        if _G.InstantInteractEnabled then
            for _, descendant in ipairs(workspace:GetDescendants()) do
                if descendant:IsA("ProximityPrompt") then
                    descendant.HoldDuration = 0
                end
            end
        end
    end)
end)

-- ==========================================
-- CHARACTER TAB FEATURES (WalkSpeed Only)
-- ==========================================
_G.WalkSpeedEnabled = false
_G.WalkSpeedValue = 16

CharacterTab:CreateToggle({
    Name = "Enable WalkSpeed",
    CurrentValue = false,
    Flag = "WalkSpeedToggle",
    Callback = function(Value)
        _G.WalkSpeedEnabled = Value
    end
})

CharacterTab:CreateSlider({
    Name = "WalkSpeed",
    Range = {16, 200},
    Increment = 1,
    CurrentValue = 16,
    Flag = "WalkSpeedSlider",
    Callback = function(Value)
        _G.WalkSpeedValue = Value
    end
})

task.spawn(function()
    local RunService = game:GetService("RunService")
    local Players = game:GetService("Players")
    local LocalPlayer = Players.LocalPlayer

    RunService.RenderStepped:Connect(function()
        pcall(function()
            local char = LocalPlayer.Character
            if char then
                local humanoid = char:FindFirstChildOfClass("Humanoid")
                if humanoid and _G.WalkSpeedEnabled then
                    humanoid.WalkSpeed = _G.WalkSpeedValue
                end
            end
        end)
    end)
end)

-- ==========================================
-- VOID HUB REMASTERED (Part 2)
-- ==========================================

local Players = game:GetService("Players")
local LocalPlayer = Players.LocalPlayer
local Camera = workspace.CurrentCamera
local RunService = game:GetService("RunService")

-- ==========================================
-- SPECTATE TAB FEATURES (Fixed Target & Username Handling)
-- ==========================================
local playerList = {}
local selectedTargetName = nil

local function updatePlayerList()
    playerList = {}
    for _, p in ipairs(Players:GetPlayers()) do
        if p ~= LocalPlayer then
            table.insert(playerList, p.Name)
        end
    end
    if #playerList == 0 then
        table.insert(playerList, "None Available")
    end
end

updatePlayerList()
Players.PlayerAdded:Connect(updatePlayerList)
Players.PlayerRemoving:Connect(updatePlayerList)

local dropdownPlayer = SpectateTab:CreateDropdown({
    Name = "Pick Username",
    Options = playerList,
    CurrentOption = playerList[1] or "",
    Flag = "SpectateDropdown",
    Callback = function(Option)
        selectedTargetName = Option
    end
})

SpectateTab:CreateButton({
    Name = "Refresh Username List",
    Callback = function()
        updatePlayerList()
        dropdownPlayer:Refresh(playerList, true)
        Rayfield:Notify({
            Title = "Spectate",
            Content = "Username list refreshed, kuya!",
            Duration = 2,
            Image = 4483345998
        })
    end
})

SpectateTab:CreateButton({
    Name = "Spectate Player",
    Callback = function()
        local targetPlayer = selectedTargetName and Players:FindFirstChild(selectedTargetName)
        if targetPlayer and targetPlayer.Character and targetPlayer.Character:FindFirstChildOfClass("Humanoid") then
            Camera.CameraSubject = targetPlayer.Character:FindFirstChildOfClass("Humanoid")
            Rayfield:Notify({
                Title = "Spectate",
                Content = "Now spectating " .. targetPlayer.Name .. ", kuya!",
                Duration = 3,
                Image = 4483345998
            })
        else
            Rayfield:Notify({
                Title = "Error",
                Content = "Selected player is not available, kuya!",
                Duration = 3,
                Image = 4483345998
            })
        end
    end
})

SpectateTab:CreateButton({
    Name = "Unspectate",
    Callback = function()
        if LocalPlayer.Character and LocalPlayer.Character:FindFirstChildOfClass("Humanoid") then
            Camera.CameraSubject = LocalPlayer.Character:FindFirstChildOfClass("Humanoid")
            Rayfield:Notify({
                Title = "Unspectate",
                Content = "Returned camera to your character, kuya!",
                Duration = 3,
                Image = 4483345998
            })
        end
    end
})

SpectateTab:CreateButton({
    Name = "Teleport to Player",
    Callback = function()
        local targetPlayer = selectedTargetName and Players:FindFirstChild(selectedTargetName)
        if targetPlayer and targetPlayer.Character and targetPlayer.Character:FindFirstChild("HumanoidRootPart") then
            local targetRoot = targetPlayer.Character.HumanoidRootPart
            local myRoot = LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
            if myRoot then
                myRoot.CFrame = targetRoot.CFrame + Vector3.new(0, 3, 0)
                Rayfield:Notify({
                    Title = "Teleport",
                    Content = "Teleported to " .. targetPlayer.Name .. ", kuya!",
                    Duration = 3,
                    Image = 4483345998
                })
            end
        else
            Rayfield:Notify({
                Title = "Error",
                Content = "Could not teleport to player, kuya!",
                Duration = 3,
                Image = 4483345998
            })
        end
    end
})

-- ==========================================
-- COMBAT TAB FEATURES (Center Screen FOV 125 & Silent Aim)
-- ==========================================
local FOV_PIXELS = 125
_G.SilentAimEnabled = false

local fovGui = Instance.new("ScreenGui")
fovGui.Name = "SilentAimFOV"
fovGui.ResetOnSpawn = false
fovGui.IgnoreGuiInset = true
fovGui.Parent = LocalPlayer.PlayerGui

local fovCircle = Instance.new("Frame")
fovCircle.BackgroundTransparency = 1
fovCircle.BorderSizePixel = 0
fovCircle.Size = UDim2.fromOffset(FOV_PIXELS * 2, FOV_PIXELS * 2)
fovCircle.AnchorPoint = Vector2.new(0.5, 0.5)
fovCircle.Parent = fovGui

local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(1, 0)
corner.Parent = fovCircle

local stroke = Instance.new("UIStroke")
stroke.Color = Color3.fromRGB(255, 255, 255)
stroke.Thickness = 1.2
stroke.Transparency = 0.3
stroke.Parent = fovCircle

local dot = Instance.new("Frame")
dot.Size = UDim2.fromOffset(8, 8)
dot.AnchorPoint = Vector2.new(0.5, 0.5)
dot.BackgroundColor3 = Color3.fromRGB(255, 50, 50)
dot.BorderSizePixel = 0
dot.Visible = false
dot.ZIndex = 2
dot.Parent = fovGui
Instance.new("UICorner", dot).CornerRadius = UDim.new(1, 0)

CombatTab:CreateToggle({
    Name = "Enable Silent Aim",
    CurrentValue = false,
    Flag = "SilentAimToggle",
    Callback = function(Value)
        _G.SilentAimEnabled = Value
        fovGui.Enabled = Value
    end
})

local function getClosestHead()
    if not _G.SilentAimEnabled then return nil, nil end
    local screenCenter = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y / 2)
    local bestDist = FOV_PIXELS
    local bestHead = nil
    local bestScreen = nil
    for _, player in ipairs(Players:GetPlayers()) do
        if player ~= LocalPlayer and player.Character then
            local head = player.Character:FindFirstChild("Head")
            local humanoid = player.Character:FindFirstChildWhichIsA("Humanoid")
            if head and humanoid and humanoid.Health > 0 then
                local screenPos, onScreen = Camera:WorldToViewportPoint(head.Position)
                if onScreen then
                    local dist = (Vector2.new(screenPos.X, screenPos.Y) - screenCenter).Magnitude
                    if dist < bestDist then
                        bestDist = dist
                        bestHead = head
                        bestScreen = Vector2.new(screenPos.X, screenPos.Y)
                    end
                end
            end
        end
    end
    return bestHead, bestScreen
end

RunService.RenderStepped:Connect(function()
    if not _G.SilentAimEnabled then
        fovCircle.Visible = false
        dot.Visible = false
        return
    end
    
    fovCircle.Visible = true
    local screenCenter = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y / 2)
    fovCircle.Position = UDim2.fromOffset(screenCenter.X, screenCenter.Y)
    
    local head, screenPos = getClosestHead()
    if head and screenPos then
        dot.Visible = true
        dot.Position = UDim2.fromOffset(screenPos.X, screenPos.Y)
        stroke.Color = Color3.fromRGB(255, 50, 50)
    else
        dot.Visible = false
        stroke.Color = Color3.fromRGB(255, 255, 255)
    end
end)

local ok, Projectile = pcall(require, game:GetService("ReplicatedStorage").Modules.GunFramework.Modules.Projectile)
if ok and Projectile then
    local originalNew = Projectile.new
    Projectile.new = function(params)
        if _G.SilentAimEnabled and params and params.Origin and params.Direction then
            local head = getClosestHead()
            if head then
                local newDir = (head.Position - params.Origin).Unit
                params.Direction = newDir
            end
        end
        return originalNew(params)
    end
end

-- ==========================================
-- ESP TAB FEATURES (Chams, Tracers & Health Bar - Purple Only)
-- ==========================================
_G.ChamsEnabled = false
_G.TracersEnabled = false
_G.HealthBarEnabled = false
local PURPLE_COLOR = Color3.fromRGB(140, 50, 230)

ESPTab:CreateToggle({
    Name = "Enable Chams",
    CurrentValue = false,
    Flag = "ChamsToggle",
    Callback = function(Value)
        _G.ChamsEnabled = Value
    end
})

ESPTab:CreateToggle({
    Name = "Enable Tracers",
    CurrentValue = false,
    Flag = "TracersToggle",
    Callback = function(Value)
        _G.TracersEnabled = Value
    end
})

ESPTab:CreateToggle({
    Name = "Enable Health Bar",
    CurrentValue = false,
    Flag = "HealthBarToggle",
    Callback = function(Value)
        _G.HealthBarEnabled = Value
    end
})

local tracersTable = {}
local healthBarsTable = {}

local function createESPVisuals(player)
    local tracer = Drawing.new("Line")
    tracer.Visible = false
    tracer.Thickness = 1.5
    tracer.Color = PURPLE_COLOR
    tracersTable[player] = tracer

    local hbOuter = Drawing.new("Square")
    hbOuter.Visible = false
    hbOuter.Thickness = 1
    hbOuter.Filled = false
    hbOuter.Color = Color3.fromRGB(0, 0, 0)

    local hbInner = Drawing.new("Square")
    hbInner.Visible = false
    hbInner.Thickness = 1
    hbInner.Filled = true
    hbInner.Color = Color3.fromRGB(0, 255, 0)

    healthBarsTable[player] = {outer = hbOuter, inner = hbInner}
end

local function removeESPVisuals(player)
    if tracersTable[player] then
        tracersTable[player]:Remove()
        tracersTable[player] = nil
    end
    if healthBarsTable[player] then
        healthBarsTable[player].outer:Remove()
        healthBarsTable[player].inner:Remove()
        healthBarsTable[player] = nil
    end
end

for _, p in ipairs(Players:GetPlayers()) do
    if p ~= LocalPlayer then createESPVisuals(p) end
end
Players.PlayerAdded:Connect(createESPVisuals)
Players.PlayerRemoving:Connect(removeESPVisuals)

RunService.RenderStepped:Connect(function()
    for _, player in ipairs(Players:GetPlayers()) do
        if player ~= LocalPlayer and player.Character then
            local char = player.Character
            local rootPart = char:FindFirstChild("HumanoidRootPart")
            local head = char:FindFirstChild("Head")
            local humanoid = char:FindFirstChildWhichIsA("Humanoid")

            -- Chams Logic (Purple Only)
            for _, part in ipairs(char:GetChildren()) do
                if part:IsA("BasePart") and part.Name ~= "HumanoidRootPart" then
                    local highlight = part:FindFirstChild("VoidChamsHighlight")
                    if _G.ChamsEnabled then
                        if not highlight then
                            highlight = Instance.new("BoxHandleAdornment")
                            highlight.Name = "VoidChamsHighlight"
                            highlight.Adornee = part
                            highlight.AlwaysOnTop = true
                            highlight.ZIndex, highlight.Size = 5, part.Size
                            highlight.Color3 = PURPLE_COLOR
                            highlight.Parent = part
                        end
                    else
                        if highlight then highlight:Destroy() end
                    end
                end
            end

            -- Tracers Logic (Purple Only)
            local tracer = tracersTable[player]
            if tracer then
                if _G.TracersEnabled and rootPart and humanoid and humanoid.Health > 0 then
                    local vector, onScreen = Camera:WorldToViewportPoint(rootPart.Position)
                    if onScreen then
                        tracer.From = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y)
                        tracer.To = Vector2.new(vector.X, vector.Y)
                        tracer.Color = PURPLE_COLOR
                        tracer.Visible = true
                    else
                        tracer.Visible = false
                    end
                else
                    tracer.Visible = false
                end
            end

            -- Health Bar Logic
            local hbData = healthBarsTable[player]
            if hbData then
                if _G.HealthBarEnabled and rootPart and head and humanoid and humanoid.Health > 0 then
                    local rootPos, rootOnScreen = Camera:WorldToViewportPoint(rootPart.Position)
                    local headPos, headOnScreen = Camera:WorldToViewportPoint(head.Position + Vector3.new(0, 0.5, 0))
                    local legPos, legOnScreen = Camera:WorldToViewportPoint(rootPart.Position - Vector3.new(0, 3, 0))

                    if rootOnScreen then
                        local height = math.abs(headPos.Y - legPos.Y)
                        local width = height / 2
                        local x = rootPos.X - width / 2 - 6
                        local y = rootPos.Y - height / 2

                        hbData.outer.Size = Vector2.new(4, height)
                        hbData.outer.Position = Vector2.new(x, y)
                        hbData.outer.Visible = true

                        local healthPercent = math.clamp(humanoid.Health / humanoid.MaxHealth, 0, 1)
                        local innerHeight = height * healthPercent
                        hbData.inner.Size = Vector2.new(2, innerHeight)
                        hbData.inner.Position = Vector2.new(x + 1, y + (height - innerHeight))
                        hbData.inner.Color = Color3.fromRGB(255 - (healthPercent * 255), healthPercent * 255, 0)
                        hbData.inner.Visible = true
                    else
                        hbData.outer.Visible = false
                        hbData.inner.Visible = false
                    end
                else
                    hbData.outer.Visible = false
                    hbData.inner.Visible = false
                end
            end
        end
    end
end)

Rayfield:Notify({
    Title = "VOID HUB LOADED",
    Content = "All features loaded, ready to publish on Rescript, kuya!",
    Duration = 5,
    Image = 4483345998
})