HD Admin Explode ALL spam script

--// Explode All Players - Rayfield GUI
--// Fires ";explode [username]" via HD Admin cmdbar when a player spawns or moves

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

--// Services
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local TextChatService = game:GetService("TextChatService")
local LocalPlayer = Players.LocalPlayer

--// State
local Enabled = false
local Connections = {} -- store per-player connections
local SingleTargetMode = false -- when true, only target a specific player
local TargetPlayerName = "" -- the name of the player to target
local MovementCooldown = 5 -- configurable cooldown

--// Round Robin State
local RoundRobinEnabled = false
local RoundRobinCooldown = 3 -- seconds between each explosion in the cycle
local RoundRobinThread = nil -- the coroutine/thread running the loop

--// HR Spam State
local HRSpamEnabled = false
local HRSpamCooldown = 3 -- seconds between each ;hr message
local HRSpamThread = nil
local HRSpamMessage = ";hr 清理服务器"

--// ============================================================
--// COMMAND EXECUTION (HD Admin cmdbar)
--// HD Admin cmdbar is opened with the ' key. We find the cmdbar
--// TextBox in PlayerGui, set the command text, and simulate Enter.
--// Falls back to chat-based methods if cmdbar GUI is not found.
--// ============================================================

--// Find the HD Admin cmdbar TextBox in PlayerGui
local function findCmdbarTextBox()
    local playerGui = LocalPlayer:FindFirstChild("PlayerGui")
    if not playerGui then return nil end

    -- Search for HD Admin GUI and its cmdbar TextBox
    for _, gui in ipairs(playerGui:GetChildren()) do
        if gui:IsA("ScreenGui") then
            local guiName = gui.Name:lower()
            -- HD Admin GUI names vary: "HDAdmin", "HDAdminGUI", "Cmdbar", etc.
            if guiName:find("hdadmin") or guiName:find("hd admin") or guiName:find("cmdbar") then
                for _, desc in ipairs(gui:GetDescendants()) do
                    if desc:IsA("TextBox") then
                        return desc
                    end
                end
            end
        end
    end

    -- Broader search: look for any TextBox named cmdbar-like in PlayerGui
    for _, desc in ipairs(playerGui:GetDescendants()) do
        if desc:IsA("TextBox") then
            local name = desc.Name:lower()
            if name:find("cmdbar") or name:find("commandbar") or name:find("cmd_bar") then
                return desc
            end
        end
    end

    return nil
end

local function sendCommand(command)
    local sent = false

    -- Method 1: Find HD Admin cmdbar TextBox, set text, simulate Enter
    pcall(function()
        local cmdbar = findCmdbarTextBox()
        if cmdbar then
            cmdbar.Text = command
            -- Simulate pressing Enter by focusing and then releasing focus
            cmdbar:CaptureFocus()
            task.wait(0.05)
            cmdbar:ReleaseFocus(true) -- true = simulate Enter press
            sent = true
        end
    end)
    if sent then return end

    -- Method 2: Fire any HD Admin remote found in HDAdminFolder
    pcall(function()
        local hdFolder = ReplicatedStorage:FindFirstChild("HDAdminFolder")
        if hdFolder then
            for _, desc in ipairs(hdFolder:GetDescendants()) do
                if desc:IsA("RemoteEvent") then
                    desc:FireServer(command)
                    sent = true
                    return
                end
            end
        end
    end)
    if sent then return end

    -- Method 3: TextChatService (modern Roblox chat)
    pcall(function()
        local textChannels = TextChatService:FindFirstChild("TextChannels")
        if textChannels then
            local channel = textChannels:FindFirstChild("RBXGeneral")
            if channel then
                channel:SendAsync(command)
                sent = true
            end
        end
    end)
    if sent then return end

    -- Method 4: Legacy chat (SayMessageRequest)
    pcall(function()
        local defaultChat = ReplicatedStorage:FindFirstChild("DefaultChatSystemChatEvents")
        if defaultChat then
            local sayMsg = defaultChat:FindFirstChild("SayMessageRequest")
            if sayMsg then
                sayMsg:FireServer(command, "All")
                sent = true
            end
        end
    end)
    if sent then return end

    warn("[ExplodeExploit] No method worked to send command: " .. command)
end

--// Explode a target player by sending the chat command
local function explodePlayer(targetPlayer)
    if not Enabled then return end
    if targetPlayer == LocalPlayer then return end -- don't explode yourself

    -- If single target mode is on, only explode the specified player
    if SingleTargetMode and TargetPlayerName ~= "" then
        if targetPlayer.Name:lower() ~= TargetPlayerName:lower() then
            return -- skip, not our target
        end
    end

    local command = ";explode " .. targetPlayer.Name
    sendCommand(command)
end

--// Hook into a player's character (spawn & movement detection)
local function hookCharacter(player, character)
    -- Clean up old connections for this player
    if Connections[player.UserId] then
        for _, conn in pairs(Connections[player.UserId]) do
            conn:Disconnect()
        end
    end
    Connections[player.UserId] = {}

    -- Wait for the HumanoidRootPart
    local hrp = character:WaitForChild("HumanoidRootPart", 10)
    if not hrp then return end

    -- On Spawn: explode immediately
    task.defer(function()
        if Enabled then
            explodePlayer(player)
        end
    end)

    -- On Move: detect position change
    local lastExplodeTime = 0

    local moveConn
    moveConn = hrp:GetPropertyChangedSignal("CFrame"):Connect(function()
        if not Enabled then return end
        local now = tick()
        if now - lastExplodeTime >= MovementCooldown then
            lastExplodeTime = now
            explodePlayer(player)
        end
    end)

    table.insert(Connections[player.UserId], moveConn)
end

--// Hook into a player (listen for their character spawning)
local function hookPlayer(player)
    if player == LocalPlayer then return end

    -- If they already have a character, hook it
    if player.Character then
        task.spawn(function()
            hookCharacter(player, player.Character)
        end)
    end

    -- Listen for future respawns
    local charConn = player.CharacterAdded:Connect(function(character)
        task.spawn(function()
            hookCharacter(player, character)
        end)
    end)

    if not Connections[player.UserId] then
        Connections[player.UserId] = {}
    end
    table.insert(Connections[player.UserId], charConn)
end

--// Cleanup all connections
local function cleanupAll()
    for userId, conns in pairs(Connections) do
        for _, conn in pairs(conns) do
            conn:Disconnect()
        end
    end
    Connections = {}
end

--// Start hooking all current & future players
local function startExploit()

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

    -- Store the PlayerAdded connection
    if not Connections["_playerAdded"] then
        Connections["_playerAdded"] = {}
    end
    local addedConn = Players.PlayerAdded:Connect(function(player)
        hookPlayer(player)
    end)
    table.insert(Connections["_playerAdded"], addedConn)

    -- Cleanup when a player leaves
    local removingConn = Players.PlayerRemoving:Connect(function(player)
        if Connections[player.UserId] then
            for _, conn in pairs(Connections[player.UserId]) do
                conn:Disconnect()
            end
            Connections[player.UserId] = nil
        end
    end)
    table.insert(Connections["_playerAdded"], removingConn)
end

--// ============================================================
--// ROUND ROBIN LOGIC
--// Cycles through all players one-by-one, exploding each in turn
--// with a configurable cooldown between explosions.
--// ============================================================

local function stopRoundRobin()
    RoundRobinEnabled = false
    if RoundRobinThread then
        pcall(function() task.cancel(RoundRobinThread) end)
        RoundRobinThread = nil
    end
end

local function startRoundRobin()
    -- Stop any existing round robin loop first
    stopRoundRobin()
    RoundRobinEnabled = true

    RoundRobinThread = task.spawn(function()
        while RoundRobinEnabled do
            local players = Players:GetPlayers()
            for _, player in ipairs(players) do
                if not RoundRobinEnabled then break end
                if player ~= LocalPlayer then
                    local command = ";explode " .. player.Name
                    sendCommand(command)
                    task.wait(RoundRobinCooldown)
                end
            end
            -- Small safety wait before starting the next cycle
            if RoundRobinEnabled then
                task.wait(0.5)
            end
        end
    end)
end

--// ============================================================
--// HR SPAM LOGIC
--// Repeatedly sends ;hr message with a configurable cooldown.
--// ============================================================

local function stopHRSpam()
    HRSpamEnabled = false
    if HRSpamThread then
        pcall(function() task.cancel(HRSpamThread) end)
        HRSpamThread = nil
    end
end

local function startHRSpam()
    stopHRSpam()
    HRSpamEnabled = true

    HRSpamThread = task.spawn(function()
        while HRSpamEnabled do
            sendCommand(HRSpamMessage)
            task.wait(HRSpamCooldown)
        end
    end)
end

--// ============================================================
--// RAYFIELD GUI
--// ============================================================

local Window = Rayfield:CreateWindow({
    Name = "💥 Explode Exploit",
    Icon = 0,
    LoadingTitle = "Explode Exploit",
    LoadingSubtitle = "by Script",
    Theme = "Default",
    ToggleUIKeybind = "K",
    DisableRayfieldPrompts = false,
    DisableBuildWarnings = false,

    ConfigurationSaving = {
        Enabled = true,
        FolderName = "ExplodeExploitConfig",
        FileName = "ExplodeExploit"
    },

    KeySystem = false,
})

local MainTab = Window:CreateTab("Main", "bomb")
local SettingsTab = Window:CreateTab("Settings", "settings")

--// Main Tab Elements

MainTab:CreateSection("Explode Control")

local MainToggle = MainTab:CreateToggle({
    Name = "Enable Auto Explode",
    CurrentValue = false,
    Flag = "AutoExplodeToggle",
    Callback = function(Value)
        Enabled = Value
        if Value then
            startExploit()
            Rayfield:Notify({
                Title = "Exploit Enabled",
                Content = "Auto explode is now active. Players will be exploded on spawn and movement.",
                Duration = 3,
                Image = "bomb",
            })
        else
            cleanupAll()
            Rayfield:Notify({
                Title = "Exploit Disabled",
                Content = "Auto explode has been turned off.",
                Duration = 3,
                Image = "shield",
            })
        end
    end,
})

MainTab:CreateSection("Single Player Target")

--// Helper: get list of player names (excluding local player)
local function getPlayerNames()
    local names = {}
    for _, player in ipairs(Players:GetPlayers()) do
        if player ~= LocalPlayer then
            table.insert(names, player.Name)
        end
    end
    if #names == 0 then
        table.insert(names, "No players")
    end
    return names
end

local TargetToggle = MainTab:CreateToggle({
    Name = "Single Player Mode",
    CurrentValue = false,
    Flag = "SingleTargetToggle",
    Callback = function(Value)
        SingleTargetMode = Value
        if Value then
            if TargetPlayerName == "" then
                Rayfield:Notify({
                    Title = "Select a Target",
                    Content = "Single target mode is ON. Pick a player from the dropdown below.",
                    Duration = 4,
                    Image = "crosshair",
                })
            else
                Rayfield:Notify({
                    Title = "Single Target ON",
                    Content = "Only targeting: " .. TargetPlayerName,
                    Duration = 3,
                    Image = "crosshair",
                })
            end
        else
            Rayfield:Notify({
                Title = "Single Target OFF",
                Content = "All players will be targeted again.",
                Duration = 3,
                Image = "users",
            })
        end
    end,
})

local TargetDropdown = MainTab:CreateDropdown({
    Name = "Select Target Player",
    Options = getPlayerNames(),
    CurrentOption = {},
    MultiSelection = false,
    Flag = "TargetPlayerDropdown",
    Callback = function(Option)
        TargetPlayerName = Option
        Rayfield:Notify({
            Title = "Target Set",
            Content = "Now targeting: " .. Option,
            Duration = 3,
            Image = "crosshair",
        })
    end,
})

MainTab:CreateButton({
    Name = "🔄 Refresh Player List",
    Callback = function()
        TargetDropdown:Set("")
        TargetDropdown:Refresh(getPlayerNames(), true)
        Rayfield:Notify({
            Title = "Refreshed",
            Content = "Player list updated.",
            Duration = 2,
            Image = "refresh-cw",
        })
    end,
})

MainTab:CreateSection("Round Robin")

local RoundRobinToggle = MainTab:CreateToggle({
    Name = "Enable Round Robin",
    CurrentValue = false,
    Flag = "RoundRobinToggle",
    Callback = function(Value)
        if Value then
            startRoundRobin()
            Rayfield:Notify({
                Title = "Round Robin ON",
                Content = "Cycling through all players. Cooldown: " .. RoundRobinCooldown .. "s per player.",
                Duration = 4,
                Image = "repeat",
            })
        else
            stopRoundRobin()
            Rayfield:Notify({
                Title = "Round Robin OFF",
                Content = "Round robin exploding stopped.",
                Duration = 3,
                Image = "shield",
            })
        end
    end,
})

MainTab:CreateSection("HR Spam")

local HRSpamToggle = MainTab:CreateToggle({
    Name = "Enable HR Spam",
    CurrentValue = false,
    Flag = "HRSpamToggle",
    Callback = function(Value)
        if Value then
            startHRSpam()
            Rayfield:Notify({
                Title = "HR Spam ON",
                Content = "Spamming ;hr message every " .. HRSpamCooldown .. "s.",
                Duration = 4,
                Image = "message-circle",
            })
        else
            stopHRSpam()
            Rayfield:Notify({
                Title = "HR Spam OFF",
                Content = "HR spam stopped.",
                Duration = 3,
                Image = "shield",
            })
        end
    end,
})

MainTab:CreateSection("Manual Actions")

MainTab:CreateButton({
    Name = "Explode All Players Now",
    Callback = function()
        for _, player in ipairs(Players:GetPlayers()) do
            if player ~= LocalPlayer then
                local command = ";explode " .. player.Name
                sendCommand(command)
                task.wait(0.3) -- small delay to avoid throttle
            end
        end
        Rayfield:Notify({
            Title = "Exploded All",
            Content = "Sent ;explode via HD Admin for all players.",
            Duration = 3,
            Image = "zap",
        })
    end,
})

MainTab:CreateButton({
    Name = "Explode Nearest Player",
    Callback = function()
        local myChar = LocalPlayer.Character
        if not myChar or not myChar:FindFirstChild("HumanoidRootPart") then
            Rayfield:Notify({
                Title = "Error",
                Content = "Your character is not loaded.",
                Duration = 3,
                Image = "alert-triangle",
            })
            return
        end

        local myPos = myChar.HumanoidRootPart.Position
        local nearest = nil
        local nearestDist = math.huge

        for _, player in ipairs(Players:GetPlayers()) do
            if player ~= LocalPlayer and player.Character and player.Character:FindFirstChild("HumanoidRootPart") then
                local dist = (player.Character.HumanoidRootPart.Position - myPos).Magnitude
                if dist < nearestDist then
                    nearestDist = dist
                    nearest = player
                end
            end
        end

        if nearest then
            sendCommand(";explode " .. nearest.Name)
            Rayfield:Notify({
                Title = "Exploded Nearest",
                Content = "Sent ;explode for " .. nearest.Name .. " (" .. math.floor(nearestDist) .. " studs away)",
                Duration = 3,
                Image = "target",
            })
        else
            Rayfield:Notify({
                Title = "No Target",
                Content = "No other players found.",
                Duration = 3,
                Image = "alert-triangle",
            })
        end
    end,
})

--// Settings Tab Elements

SettingsTab:CreateSection("Configuration")

local CooldownSlider = SettingsTab:CreateSlider({
    Name = "Movement Cooldown (seconds)",
    Range = {0.1, 30},
    Increment = 0.1,
    Suffix = "s",
    CurrentValue = 5,
    Flag = "CooldownSlider",
    Callback = function(Value)
        MovementCooldown = Value
        Rayfield:Notify({
            Title = "Cooldown Updated",
            Content = "Movement cooldown set to " .. Value .. "s.",
            Duration = 3,
            Image = "clock",
        })
    end,
})

local RoundRobinCooldownSlider = SettingsTab:CreateSlider({
    Name = "Round Robin Cooldown (seconds)",
    Range = {0.1, 30},
    Increment = 0.1,
    Suffix = "s",
    CurrentValue = 3,
    Flag = "RoundRobinCooldownSlider",
    Callback = function(Value)
        RoundRobinCooldown = Value
        Rayfield:Notify({
            Title = "RR Cooldown Updated",
            Content = "Round robin cooldown set to " .. Value .. "s per player.",
            Duration = 3,
            Image = "clock",
        })
    end,
})

local HRSpamCooldownSlider = SettingsTab:CreateSlider({
    Name = "HR Spam Cooldown (seconds)",
    Range = {0.1, 30},
    Increment = 0.1,
    Suffix = "s",
    CurrentValue = 3,
    Flag = "HRSpamCooldownSlider",
    Callback = function(Value)
        HRSpamCooldown = Value
        Rayfield:Notify({
            Title = "HR Cooldown Updated",
            Content = "HR spam cooldown set to " .. Value .. "s.",
            Duration = 3,
            Image = "clock",
        })
    end,
})

SettingsTab:CreateSection("Config Management")

SettingsTab:CreateButton({
    Name = "💾 Save Config",
    Callback = function()
        pcall(function()
            Rayfield:SaveConfiguration()
        end)
        Rayfield:Notify({
            Title = "Config Saved",
            Content = "All settings have been saved.",
            Duration = 3,
            Image = "save",
        })
    end,
})

SettingsTab:CreateButton({
    Name = "📂 Load Config",
    Callback = function()
        pcall(function()
            Rayfield:LoadConfiguration()
        end)
        Rayfield:Notify({
            Title = "Config Loaded",
            Content = "Settings have been loaded from file.",
            Duration = 3,
            Image = "download",
        })
    end,
})

SettingsTab:CreateButton({
    Name = "Destroy GUI",
    Callback = function()
        cleanupAll()
        stopRoundRobin()
        stopHRSpam()
        Enabled = false
        Rayfield:Destroy()
    end,
})