Ruby Hub Murderer Vs Sheriff Duels Script Sh New Review

Title: "Showdown in the Wild West: A Comparative Analysis of Ruby Hub Murderer vs Sheriff Duels Script in SH"

Abstract:

The Wild West has long been a staple of American folklore, with its rugged landscape, rough-riding cowboys, and deadly showdowns. In the realm of coding, a similar showdown has been brewing between Ruby Hub Murderer and Sheriff Duels Script in SH. This paper aims to provide a comprehensive analysis of both scripts, highlighting their strengths, weaknesses, and use cases. We will delve into the design principles, performance, and security implications of each script, ultimately providing a verdict on which one emerges victorious.

Introduction:

Ruby Hub Murderer and Sheriff Duels Script in SH are two popular scripts used for creating interactive and dynamic web applications. Ruby Hub Murderer, a Ruby-based script, is known for its simplicity and ease of use, while Sheriff Duels Script in SH, a shell-based script, boasts high performance and flexibility. Both scripts have gained significant traction in the developer community, with each having its own set of loyal followers.

Design Principles:

Ruby Hub Murderer is built on the principles of simplicity and readability. Its syntax is designed to be easy to learn and understand, making it an excellent choice for beginners. The script uses a modular approach, allowing developers to easily extend and customize its functionality.

On the other hand, Sheriff Duels Script in SH takes a more performance-oriented approach. It uses a compiled language, which provides a significant boost in speed and efficiency. The script also employs a more complex syntax, which can be daunting for beginners but provides advanced features for experienced developers.

Performance:

In terms of performance, Sheriff Duels Script in SH has a clear advantage. Its compiled nature allows it to execute tasks faster and more efficiently, making it well-suited for high-traffic applications. Ruby Hub Murderer, while still performant, lags behind in this regard.

Security:

Security is a critical aspect of any script, and both Ruby Hub Murderer and Sheriff Duels Script in SH have their strengths and weaknesses. Ruby Hub Murderer's modular design makes it easier to identify and patch vulnerabilities, while Sheriff Duels Script in SH's compiled nature makes it more difficult to reverse-engineer and exploit.

Use Cases:

Ruby Hub Murderer is ideal for:

Sheriff Duels Script in SH is ideal for:

Conclusion:

In conclusion, both Ruby Hub Murderer and Sheriff Duels Script in SH have their strengths and weaknesses. While Ruby Hub Murderer excels in simplicity and ease of use, Sheriff Duels Script in SH boasts high performance and flexibility. Ultimately, the choice between the two scripts depends on the specific needs and goals of the project.

Verdict:

Based on our analysis, we declare Sheriff Duels Script in SH the winner in terms of performance and flexibility. However, Ruby Hub Murderer remains a strong contender, particularly for smaller projects and development teams with varying levels of experience.

Future Work:

Future research should focus on exploring the use of hybrid approaches, combining the strengths of both scripts to create a new generation of high-performance, secure, and easy-to-use scripts.

References:

Murderers VS Sheriffs DUELS on Roblox, a "deep feature" for a script hub like

generally refers to advanced automation that goes beyond basic ESP or Aimbot. Based on the game's unique mechanics, such as ability management projectile physics

, here are advanced feature concepts often found in premium scripts: Predictive Projectile Aimbot

Unlike standard hitscan aimbots, deep features in MVSD must account for knife and revolver travel time. Velocity Prediction

: High-tier scripts calculate the opponent's current velocity and latency to "lead" the shot, ensuring the knife or bullet hits where the player Drop Compensation

: Adjusts for gravity over long distances, which is critical for long-range knife throws. Ability Auto-Manager

MVSD relies heavily on unique abilities like Speed, Jump-Dash, or Shroud. Counter-Ability Logic

: Automatically triggers a defensive ability (like a dash) the millisecond an opponent activates a "Shroud" or aggressive ability. Optimal Cycle

: Scripting the perfect timing for abilities to maximize uptime and movement speed during 1v1s. Environmental & Tactical Automation

Deep features often leverage the map layout and player "visibility" bugs. Anti-Peeking/Wall-Shot

: Detects when an opponent's arm is clipping through a crate or wall and automatically fires at the exposed hitbox. Auto-Parkour

: Uses Dash and Jump abilities to automatically reach high-vantage points (like on top of crates or sofas) for a superior line of sight. Visual & Social Stealth (Script Hub Standard) I Won with EVERY ABILITY in Murderers VS Sheriffs Duels!

The intersection of Ruby Hub, the high-stakes environment of Murderer vs Sheriff Duels (MVS), and the use of SH scripts (specifically Shell or Lua-based executors) represents a controversial shift in the Roblox gaming landscape. This essay explores the impact of automation on competitive gaming and the ethical divide it creates within the community. The Mechanics of the Advantage

At its core, Murderer vs Sheriff Duels is a game of reflexes, prediction, and psychological warfare. When players introduce scripts like Ruby Hub, they are essentially bypassing the skill gap. These scripts often provide features like Auto-Farm, Kill Aura, and Esp (Extra Sensory Perception). While the "new" versions of these scripts aim for better optimization and bypasses against anti-cheat systems, they fundamentally alter the game's DNA from a test of skill to a battle of software. The Appeal of the "New" Script

The demand for "new" scripts—often distributed as .sh or .lua files—stems from a desire for efficiency. In a digital economy where skins and ranks carry social capital, players feel pressured to keep up. Ruby Hub has gained a reputation for being a "reliable" interface, offering a clean UI that makes complex exploits accessible to the average player. For the user, it transforms a difficult grind into a streamlined process of resource accumulation. The Ethical and Community Impact

The use of such scripts is a double-edged sword. On one hand, it allows players to explore the game’s limits and bypass repetitive tasks. On the other, it creates a toxic environment for "legit" players. When a Sheriff can hit an impossible shot via an aimbot, or a Murderer can teleport across the map, the competitive integrity of the duel vanishes. This lead to a "cat-and-mouse" game between developers and scripters, where game updates are immediately followed by script patches. Conclusion

Ruby Hub and its contemporary scripts represent the "gray market" of Roblox gaming. While they offer an undeniable shortcut to power and aesthetics within Murderer vs Sheriff Duels, they come at the cost of the game’s fair-play ecosystem. As scripting becomes more sophisticated, the community is left to decide whether they value the achievement of the win or the efficiency of the code.

How are you planning to use the script—are you looking to test its features in a private lobby or just curious about the latest updates?

Ruby Hub is a script executor/hub for the Roblox game Murderer vs Sheriff Duels

. While it offers several gameplay advantages, it is important to understand its features and the significant risks associated with using it. Core Features ruby hub murderer vs sheriff duels script sh new

Ruby Hub typically includes a variety of automated and enhanced gameplay tools designed to give players an edge: Silent Aim & Aimbot

: Automatically targets opponents, allowing you to hit shots or throw knives with perfect accuracy without manually aiming.

: Automatically attacks any player within a certain radius of your character. ESP (Extra Sensory Perception)

: Highlights other players through walls, often displaying their names, distances, and whether they are a Murderer or Sheriff.

: Automatically completes tasks or wins rounds to quickly gain in-game currency or experience. Speed & Jump Hacks

: Increases your character's movement speed or jump height to evade attacks or reach vantage points quickly. Infinite Stamina

: Allows you to run or perform actions without being limited by the game's stamina bar. Performance and Usability

: Ruby Hub generally features a graphical user interface (GUI) that allows you to toggle specific cheats on and off easily.

: To use it, you need a third-party Roblox executor (like Synapse X, Fluxus, or Hydrogen). The script is typically provided as a "loadstring" that you paste into the executor. Critical Risks and Considerations

Before using Ruby Hub, you should be aware of the following dangers: Account Banning : Using scripts like Ruby Hub is a direct violation of Roblox's Terms of Service

. Modern anti-cheat systems can detect many of these functions, leading to permanent account bans. Security Vulnerabilities

: Third-party scripts and executors often come from unverified sources. They can contain malware, keyloggers, or backdoors

that can compromise your computer or steal your personal information. Game Stability

: These scripts can cause the game to crash, lag, or behave unpredictably, often ruining the experience for you and everyone else in the server. Moral Impact

: Using an "unfair advantage" is widely shamed within the gaming community as it disrupts the competitive balance of the game. Developer Forum | Roblox Recommendation

: If you choose to explore this, never use your main account. Use an "alt" (alternative) account to protect your primary progress and skins, and ensure you have up-to-date antivirus software running. specific executors

are currently compatible with the newest version of this script?

Exploit Allowed? - Education Support - Developer Forum | Roblox 3 Jan 2025 —

Searching for the "Ruby Hub" script for Murderer vs Sheriff Duels

typically points toward a specific Roblox exploit script known for its combat-heavy features. Script Features

The Ruby Hub or similar scripts for this game usually include a variety of "combat" and "visual" enhancements designed to give players a massive advantage in shootouts:

Combat: Silent Aim, Auto-Shoot, Hitbox Expander (makes enemies easier to hit), and Shoot Through Walls.

Visuals (ESP): Enables "Wallhacks" to see player names, distance, and health through obstacles.

Movement: Speed hacks, Infinite Jump, and No-Clip (walking through walls). How to Use (Standard Process)

To run these types of scripts, users typically follow these steps:

Executor: You need a working Roblox executor (e.g., JJSploit, Fluxus, or Delta).

Loadstring: Most Ruby Hub versions use a loadstring command, which fetches the script directly from a repository like GitHub or Pastebin.

Injection: Open Roblox, join Murderer vs Sheriff Duels, and "inject" or "attach" your executor.

Execute: Paste the script into the executor's window and click Run/Execute to bring up the GUI. Risks & Safety

Account Bans: Using scripts is a violation of Roblox's Terms of Service. Anti-cheat updates can lead to temporary or permanent bans.

Malware: Be extremely cautious when downloading executors or copying scripts from unknown sources, as they may contain hidden viruses or "loggers" meant to steal your account info.

Outdated Scripts: Many scripts found on sites like Pastebin may be patched or broken after a game update.

Warning: It is highly recommended to use an "alt" (alternative) account if you decide to test scripts to protect your main account from being banned. Murderers VS Sheriffs Duels Scirpt - Pastebin.com

Not a member of Pastebin yet? Sign Up, it unlocks many cool features! text 0.25 KB | None | 0 0. loadstring(game:HttpGet("https://

Ruby Hub Murderer vs Sheriff Duels Script SH New

Get Ready for the Wildest Duels in Ruby Hub!

The battle for justice has begun in Ruby Hub! A notorious murderer has been terrorizing the town, and it's up to the Sheriff to bring them to justice. But in this twist, the murderer and the Sheriff will face off in epic duels to determine who will reign supreme.

Features:

Gameplay:

Get Ready to Join the Battle for Ruby Hub!

Don't miss out on this thrilling experience! Join the battle for Ruby Hub and witness the ultimate showdown between good and evil. Title: "Showdown in the Wild West: A Comparative

The Ruby Hub script for the Roblox game Murderers VS Sheriffs Duels

is an automated utility designed to provide players with significant competitive advantages, such as Auto Farm and Kill All capabilities. It is part of a larger community of script hubs that centralize various automation features for Roblox titles. Key Features of Ruby Hub

The script primarily focuses on efficiency and rapid progression through the following "overpowered" (OP) features:

Kill All Players: Automatically neutralizes all opponents in a match to secure quick wins.

Loop Kill All: Continuously executes the kill command every time opponents respawn.

Auto Farm: Automates the process of entering matches and winning them to accumulate rewards and experience without manual input.

UI Settings: A graphical user interface (GUI) that allows users to toggle specific features on or off during gameplay. Technical Context and Execution

The script is written in Lua, the standard programming language for the Roblox engine. Users typically execute it using a "loadstring" command in a third-party script executor:

loadstring(game:HttpGet("https://raw.githubusercontent.com/Deni210/murdersvssherrifsduels/main/rubyhub", true))() Risks and Considerations

While hubs like Ruby Hub offer rapid progression, they carry substantial risks:

Will i get banned for this? - Scripting Support - Developer Forum | Roblox

The topic seems to relate to a duel or confrontational scenario between two characters: the "Ruby Hub Murderer" and "Sheriff." This could be part of a game, a story, or even a script for a video or film. The mention of "Ruby Hub" could refer to a specific location within a game or narrative, possibly related to the popular game Roblox, given that "Ruby Hub" is a known game development and hub platform.

Running a smooth “Murderer vs Sheriff” duel script with Ruby Hub requires attention to:

Why use Ruby Hub? Ruby Hub provides pre-built UI elements (health bars, ability cooldown wheels, duel start countdowns, and leaderboards) that save you 500+ lines of raw XML/Lua. The latest "SH New" update (as of late 2025) introduces three revolutionary features for duels:

The “new” SH script’s true power lies in its modular events. You can create historical scenarios:

Here's a quick example of adding a special ability:

class Sheriff < Character
  def shoot_bullet(other)
    other.take_damage(50)
    puts "#name used Shoot Bullet!"
  end
end
class Duel
  def self.start(duelist1, duelist2)
    puts "Duel starting between #duelist1.name and #duelist2.name!"
    while duelist1.is_alive? && duelist2.is_alive?
      puts "#duelist1.name's turn:"
      action = gets.chomp.downcase
      if action == "shoot"
        if duelist1.is_a?(Sheriff)
          duelist1.shoot_bullet(duelist2)
        else
          duelist1.deal_damage(duelist2)
        end
      else
        duelist1.deal_damage(duelist2)
      end
      if duelist2.is_alive?
        duelist2.deal_damage(duelist1)
      end
      puts "---------"
    end
    # ... rest of the duel logic

This guide provides a basic framework. You can enhance it with more features, character abilities, and complexity as per your requirements.

The Ruby Hub script for Murderer vs Sheriff Duels is a popular utility within the Roblox community designed to enhance gameplay by automating various combat mechanics. This "sh new" version refers to the latest optimized iteration of the script hub, specifically tailored for the game's fast-paced 1v1 and team-based duel formats. Key Features of Ruby Hub

Script hubs like Ruby Hub typically offer a suite of features that provide players with a competitive edge. Common functionalities found in this specific hub include:

Kill Aura: Automatically attacks nearby opponents without the need for manual clicking or aiming.

Silent Aim: Ensures that projectiles like knives or bullets hit targets even if your crosshair isn't perfectly aligned.

ESP (Extra Sensory Perception): Highlights player locations, names, and distances through walls, allowing you to track the Murderer or Sheriff at all times.

Auto-Parry: A defensive feature that automatically blocks or counters incoming melee attacks.

Speed & Jump Modifiers: Adjusts character movement properties to dodge attacks more effectively. How to Use the Script

To run the Ruby Hub script, you generally need a compatible Roblox executor (such as Delta or Hydrogen). Launch the Game: Open Murderer vs Sheriff Duels on Roblox.

Execute the Code: Copy the script code (often found on platforms like Pastebin) and paste it into your executor's editor window.

Activate the GUI: Click "Execute" to bring up the Ruby Hub graphical user interface (GUI) within your game window.

Configure Settings: Toggle your desired cheats and adjustments directly from the on-screen menu. Risks and Safety Considerations

While these scripts can be entertaining, they carry significant risks:

Account Bans: Using third-party scripts to gain an unfair advantage violates Roblox's Terms of Service and can lead to permanent account suspension.

Security Vulnerabilities: Downloading scripts or executors from unverified sources can expose your computer to malware or result in stolen login credentials. Always use an "alt account" if you choose to experiment with scripting to protect your main profile. HOW TO PLAY MVS ‍♀️ USING A PC!! | Murder Vs Sheriff

, exploring why it’s trending and the impact it has on the game's competitive scene. 🔴 The Ruby Hub Edge Ruby Hub is a popular Roblox script hub often utilized in Murderers VS Sheriffs DUELS

to automate combat mechanics and visual clarity. In a game where reaction time is everything, players look to these scripts to bridge the gap between skill and technical advantage. ⚔️ Key "Deep" Script Features While specific code for files is frequently updated on platforms like Discord or GitHub , the core "Ruby Hub" experience typically focuses on: Silent Aim & Aimbot:

Automatically locking onto opponents, crucial for the Sheriff's revolver or the Murderer's throwing knife. Kill Aura:

Dealing damage to anyone within a specific radius without manual input. ESP (Extra Sensory Perception):

Highlighting players through walls so you are never caught off guard by a camper. Auto-Parry:

Specifically for duels, this feature helps time blocks against incoming knife throws or shots perfectly. ⚖️ The Competitive Conflict

Using these scripts creates a "meta" shift. Authentic players rely on the game settings to customize knife throws , while script users bypass these learning curves entirely.

However, it is important to remember that exploiting is against the Roblox Terms of Service

. Using "new" script versions like the one you're looking for carries a high risk of account termination or bans, as game developers constantly update their anti-cheat measures. Developer Forum | Roblox 🛠️ Seeking a "New" Script? If you are searching for the latest

loader, you will typically find it through community-driven script repositories or specialized Roblox script hubs Sheriff Duels Script in SH is ideal for:

. Always be cautious of "new" files, as they can sometimes contain malicious code aimed at the user rather than the game. legit gameplay settings for mastering knife throws, or are you looking for anti-cheat updates for this game? Rob Visual Script Hub - ROBLOX EXPLOITING

The Ruby Hub script for Murderers vs Sheriffs Duels is a community-created tool for Roblox, featuring capabilities like Auto Farm and Hitbox Expander, often accessed through GitHub or Discord. The script, typically in Luau, requires a third-party executor. Scripts for this game can be found on GitHub or Discord.

For a visual guide on how these scripts are generally applied in-game:

-- DuelManager
local DuelManager = {}
DuelManager.__index = DuelManager
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local REQUEST_DUEL = ReplicatedStorage:WaitForChild("DuelSystem"):WaitForChild("RequestDuel")
local DUEL_UPDATE = ReplicatedStorage:WaitForChild("DuelSystem"):WaitForChild("DuelUpdate")
local DUEL_RESULT = ReplicatedStorage:WaitForChild("DuelSystem"):WaitForChild("DuelResult")
-- configuration
local DUEL_COOLDOWN = 30 -- seconds between duels per player
local ROUND_COUNTDOWN = 5 -- seconds before duel starts
local SPECTATE_DISTANCE = 60
local MAX_QUEUE = 8
-- internal state
local queue = {}
local activeDuels = {} -- duelId -> duelData
local lastDuelTimes = {} -- player.UserId -> timestamp
local function now() return os.time() end
local function makeDuelId(a,b) return tostring(a) .. "-" .. tostring(b) end
local function validatePlayer(p)
    return p and p.Parent == Players and p.Character and p.Character:FindFirstChild("Humanoid") and p.Character.Humanoid.Health > 0
end
function DuelManager:GetQueue()
    return queue
end
function DuelManager:CanDuel(player)
    local lt = lastDuelTimes[player.UserId]
    if lt and now() - lt < DUEL_COOLDOWN then
        return false, DUEL_COOLDOWN - (now() - lt)
    end
    return true
end
function DuelManager:Enqueue(player)
    if not validatePlayer(player) then return false, "Invalid player" end
    if #queue >= MAX_QUEUE then return false, "Queue full"
    for _,p in ipairs(queue) do if p == player then return false, "Already queued" end end
    local ok, waitTime = self:CanDuel(player)
    if not ok then return false, ("On cooldown: %ds"):format(waitTime) end
    table.insert(queue, player)
    REQUEST_DUEL:FireClient(player, "Queued")
    self:TryMatch()
    return true
end
function DuelManager:RemoveFromQueue(player)
    for i,p in ipairs(queue) do
        if p == player then table.remove(queue, i) break end
    end
end
function DuelManager:TryMatch()
    while #queue >= 2 do
        local p1 = table.remove(queue, 1)
        local p2 = table.remove(queue, 1)
        if validatePlayer(p1) and validatePlayer(p2) then
            self:StartDuel(p1, p2)
        else
            if validatePlayer(p1) then table.insert(queue, 1, p1) end
            if validatePlayer(p2) then table.insert(queue, 1, p2) end
            break
        end
    end
end
function DuelManager:StartDuel(playerA, playerB)
    local id = makeDuelId(playerA.UserId, playerB.UserId)
    local duelData = {
        id = id,
        players = playerA, playerB,
        startTime = now() + ROUND_COUNTDOWN,
        state = "starting",
        winner = nil,
        connections = {},
    }
    activeDuels[id] = duelData
    -- equip duel tools, strip other tools, set health
    for _,p in ipairs(duelData.players) do
        lastDuelTimes[p.UserId] = now()
        -- notify clients to set up HUD & tools
        DUEL_UPDATE:FireClient(p, action="start", opponent = (p==playerA and playerB.UserId or playerA.UserId), countdown = ROUND_COUNTDOWN, duelId = id)
    end
-- start countdown timer
    spawn(function()
        local t = ROUND_COUNTDOWN
        while t > 0 do
            for _,p in ipairs(duelData.players) do
                if validatePlayer(p) then
                    DUEL_UPDATE:FireClient(p, action="countdown", time = t)
                end
            end
            wait(1)
            t = t - 1
        end
        -- grant tools and set health
        duelData.state = "active"
        for i,p in ipairs(duelData.players) do
            if validatePlayer(p) then
                DUEL_UPDATE:FireClient(p, action="begin", duelId = id, roleIndex = i) -- roleIndex 1 vs 2; client will assign murderer/sheriff randomly
            end
        end
        -- monitor duel
        self:MonitorDuel(duelData)
    end)
end
function DuelManager:MonitorDuel(duelData)
    local pA, pB = duelData.players[1], duelData.players[2]
    local function endDuel(winner, reason)
        if not duelData then return end
        duelData.state = "ended"
        duelData.winner = winner
        for _,p in ipairs(duelData.players) do
            if validatePlayer(p) then
                DUEL_RESULT:FireClient(p, winner = winner and winner.UserId or nil, reason = reason, duelId = duelData.id)
            end
        end
        activeDuels[duelData.id] = nil
    end
-- simple health watch loop
    local loopConn
    loopConn = RunService.Heartbeat:Connect(function()
        local aAlive = validatePlayer(pA)
        local bAlive = validatePlayer(pB)
        if not aAlive and not bAlive then
            endDuel(nil, "both_down")
            loopConn:Disconnect()
            return
        elseif not aAlive then
            endDuel(pB, "opponent_down")
            loopConn:Disconnect()
            return
        elseif not bAlive then
            endDuel(pA, "opponent_down")
            loopConn:Disconnect()
            return
        end
    end)
-- safety timeout (max 90s)
    delay(90, function()
        if duelData and duelData.state == "active" then
            -- determine by remaining health or tie
            local aHum = pA.Character and pA.Character:FindFirstChild("Humanoid")
            local bHum = pB.Character and pB.Character:FindFirstChild("Humanoid")
            local aHealth = aHum and aHum.Health or 0
            local bHealth = bHum and bHum.Health or 0
            if aHealth > bHealth then endDuel(pA, "timeout_health")
            elseif bHealth > aHealth then endDuel(pB, "timeout_health")
            else endDuel(nil, "timeout_tie") end
    end)
end
-- Public API: cancel duels when player leaves
Players.PlayerRemoving:Connect(function(player)
    DuelManager:RemoveFromQueue(player)
    -- end active duel if present
    for id,duel in pairs(activeDuels) do
        for _,p in ipairs(duel.players) do
            if p == player then
                -- other player wins
                for _,op in ipairs(duel.players) do
                    if op ~= player and validatePlayer(op) then
                        DUEL_RESULT:FireClient(op, winner = op.UserId, reason = "opponent_left", duelId = id)
                    end
                end
                activeDuels[id] = nil
                break
            end
        end
    end
end)
return DuelManager

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RS = ReplicatedStorage:WaitForChild("DuelSystem")
local RequestJoin = RS:WaitForChild("RequestJoinDuel") -- RemoteFunction
local RequestDuelEvent = RS:WaitForChild("RequestDuel")
local DuelManager = require(script:WaitForChild("DuelManager"))
-- RemoteFunction handler for join/leave
RequestJoin.OnServerInvoke = function(player, action)
    action = action or "join"
    if action == "join" then
        local ok, msg = DuelManager:Enqueue(player)
        return ok = ok, message = msg
    elseif action == "leave" then
        DuelManager:RemoveFromQueue(player)
        return ok = true
    else
        return ok = false, message = "Unknown action"
    end
end
-- optional: allow client to request spectate target info
RS:WaitForChild("DuelUpdate").OnServerEvent:Connect(function(player, data)
    -- handle client requests like "spectate" etc if needed
end)

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local player = Players.LocalPlayer
local RS = ReplicatedStorage:WaitForChild("DuelSystem")
local RequestJoin = RS:WaitForChild("RequestJoinDuel")
local DUEL_UPDATE = RS:WaitForChild("DuelUpdate")
local DUEL_RESULT = RS:WaitForChild("DuelResult")
local NotificationService = game:GetService("StarterGui")
local currentDuel = nil
-- helper equipping (assumes tools in ServerStorage/DuelAssets)
local ServerStorage = game:GetService("ServerStorage")
local DuelAssets = ServerStorage:WaitForChild("DuelAssets")
local knifeTemplate = DuelAssets:WaitForChild("Knife")
local sheriffTemplate = DuelAssets:WaitForChild("Sheriff")
-- UI helpers (simplified): you'll likely replace with real GUI
local function showMsg(text)
    -- simple hint
    game.StarterGui:SetCore("ChatMakeSystemMessage", Text = text)
end
DUEL_UPDATE.OnClientEvent:Connect(function(payload)
    if payload.action == "Queued" then
        showMsg("Queued for duel.")
    elseif payload.action == "start" then
        showMsg("Duel found. Starting in " .. tostring(payload.countdown))
    elseif payload.action == "countdown" then
        showMsg("Duel starts in " .. tostring(payload.time))
    elseif payload.action == "begin" then
        -- assign roles randomly by server order: roleIndex 1 = murderer, 2 = sheriff (swap for fairness)
        currentDuel = payload.duelId
        local roleIdx = payload.roleIndex
        local isMurderer = (roleIdx == 1) -- deterministic; server assigned index 1/2 in StartDuel order
        -- give tools locally (server should actually give tools securely; this is visual)
        -- request server to give real tools or trust developer Server to clone tools to Backpack
        showMsg("Duel begun. You are " .. (isMurderer and "Murderer (knife)" or "Sheriff (1 bullet)"))
    end
end)
DUEL_RESULT.OnClientEvent:Connect(function(payload)
    if payload.duelId ~= currentDuel then return end
    if payload.winner == nil then
        showMsg("Duel ended: Draw ("..payload.reason..")")
    elseif payload.winner == player.UserId then
        showMsg("You won the duel! ("..payload.reason..")")
    else
        showMsg("You lost the duel. ("..payload.reason..")")
    end
    currentDuel = nil
end)
-- public UI bindings (for testing)
local function joinDuel()
    local res = RequestJoin:InvokeServer("join")
    if res.ok then
        showMsg("Joined queue.")
    else
        showMsg("Could not join: " .. tostring(res.message))
    end
end
local function leaveDuel()
    RequestJoin:InvokeServer("leave")
    showMsg("Left queue.")
end
-- Example keybinds for testing
local UserInputService = game:GetService("UserInputService")
UserInputService.InputBegan:Connect(function(input, gameProcessed)
    if gameProcessed then return end
    if input.KeyCode == Enum.KeyCode.J then joinDuel()
    if input.KeyCode == Enum.KeyCode.L then leaveDuel()
end)