Open Source I Silent Aim I Auto Shoot I Detailed ESP & More

Script source Luau

Copy Script

-- [[ BloxScripts Risk Notice ]]
-- This script has not been verified by BloxScripts.fun. 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 BloxScripts Risk Notice ]]

local Fluent = loadstring(game:HttpGet("https://github.com/dawid-scripts/Fluent/releases/latest/download/main.lua"))()
local SaveManager = loadstring(game:HttpGet("https://raw.githubusercontent.com/dawid-scripts/Fluent/master/Addons/SaveManager.lua"))()
local InterfaceManager = loadstring(game:HttpGet("https://raw.githubusercontent.com/dawid-scripts/Fluent/master/Addons/InterfaceManager.lua"))()

local Window = Fluent:CreateWindow({
    Title = "Hood Rivals",
    SubTitle = "By luhscripter",
    TabWidth = 160,
    Size = UDim2.fromOffset(580, 460),
    Acrylic = false, 
    Theme = "Dark",
    MinimizeKey = Enum.KeyCode.LeftControl 
})

local Tabs = {
    Combat = Window:AddTab({ Title = "Combat", Icon = "crosshair" }),
    Visuals = Window:AddTab({ Title = "Visuals", Icon = "eye" }),
    Settings = Window:AddTab({ Title = "Settings", Icon = "settings" })
}

Tabs.Combat:AddParagraph({
    Title = "Aim Settings",
    Content = "Adjust combat configuration options below."
})

local SilentAimToggle = Tabs.Combat:AddToggle("SilentAim", {Title = "Silent Aim", Default = true})
local AutoShootToggle = Tabs.Combat:AddToggle("AutoShoot", {Title = "Auto Shoot", Default = false})

local ShootSlider = Tabs.Combat:AddSlider("ShootDelay", {
    Title = "Click Delay",
    Description = "Time between clicks for auto-shoot.",
    Default = 0.01,
    Min = 0.01,
    Max = 0.50,
    Rounding = 2,
    Callback = function(Value) end
})

local TeamCheckToggle = Tabs.Combat:AddToggle("TeamCheck", {Title = "Team Check", Default = true})
local WallCheckToggle = Tabs.Combat:AddToggle("WallCheck", {Title = "Wall Check", Default = true})

Tabs.Visuals:AddParagraph({
    Title = "ESP Settings",
    Content = "Configure visuals and player rendering options."
})

local EspMasterToggle = Tabs.Visuals:AddToggle("EspMaster", {Title = "Enable ESP", Default = true})
local EspBoxToggle = Tabs.Visuals:AddToggle("EspBox", {Title = "Box ESP", Default = true})
local EspChamsToggle = Tabs.Visuals:AddToggle("EspChams", {Title = "Chams", Default = true})
local EspDistanceToggle = Tabs.Visuals:AddToggle("EspDistance", {Title = "Distance", Default = true})

local EspColorPicker = Tabs.Visuals:AddColorpicker("EspColor", {
    Title = "ESP Color",
    Default = Color3.fromRGB(255, 255, 255)
})

local TargetColorPicker = Tabs.Visuals:AddColorpicker("TargetColor", {
    Title = "Target Color",
    Default = Color3.fromRGB(255, 0, 0)
})

local game = game
local Workspace = game:GetService("Workspace")
local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")
local RunService = game:GetService("RunService")
local VirtualInputManager = game:GetService("VirtualInputManager")
local CoreGui = game:GetService("CoreGui")

local LocalPlayer = Players.LocalPlayer
local Camera = Workspace.CurrentCamera

local Vector3_new = Vector3.new
local Vector2_new = Vector2.new
local CFrame_new = CFrame.new
local Color3_fromRGB = Color3.fromRGB
local Color3_fromHSV = Color3.fromHSV
local math_clamp = math.clamp
local math_floor = math.floor
local math_huge = math.huge
local pairs = pairs
local next = next
local typeof = typeof

local main_utils = {
    target = nil,
    Players = Players,
    UserInputService = UserInputService,
    Workspace = Workspace,
    RunService = RunService,
    VirtualInputManager = VirtualInputManager,
    CoreGui = CoreGui,
    LocalPlayer = LocalPlayer,
    Camera = Camera,
    hook = nil,
    GetAimDirection = nil,
}

local container = (gethui and gethui()) or main_utils.CoreGui
local espObjects = {}

local edges = {
    {"f1", "f2"}, {"f2", "f3"}, {"f3", "f4"}, {"f4", "f1"},
    {"b1", "b2"}, {"b2", "b3"}, {"b3", "b4"}, {"b4", "b1"},
    {"f1", "b1"}, {"f2", "b2"}, {"f3", "b3"}, {"f4", "b4"}
}

main_utils.isVisible = function(self, t)
    local cam = self.Camera
    local lp = self.LocalPlayer
    if not cam or not lp or not lp.Character then return false end
    
    local char = lp.Character
    local localHrp = char:FindFirstChild("HumanoidRootPart")
    if not localHrp then return false end
    
    local camOrigin = cam.CFrame.Position
    local bodyOrigin = localHrp.Position
    local targetPos = t.Position

    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Exclude
    params.FilterDescendantsInstances = {char}
    params.IgnoreWater = true

    local camResult = self.Workspace:Raycast(camOrigin, (targetPos - camOrigin), params)
    if camResult and camResult.Instance then
        local ancestorModel = camResult.Instance:FindFirstAncestorOfClass("Model")
        if ancestorModel and self.Players:GetPlayerFromCharacter(ancestorModel) ~= nil then
            local bodyResult = self.Workspace:Raycast(bodyOrigin, (targetPos - bodyOrigin), params)
            if bodyResult and bodyResult.Instance then
                local bodyAncestor = bodyResult.Instance:FindFirstAncestorOfClass("Model")
                if bodyAncestor and self.Players:GetPlayerFromCharacter(bodyAncestor) ~= nil then
                    return true 
                end
            end
        end
    end
    return false
end

main_utils.isPredictivelyVisible = function(self, head, hrp)
    if self:isVisible(head) then 
        return true 
    end
    
    if not (Fluent.Options.WallCheck and Fluent.Options.WallCheck.Value) then
        return true
    end

    local velocity = hrp.AssemblyLinearVelocity
    if velocity.Magnitude < 5 then return false end 

    local predictedPosition = head.Position + (velocity * 0.18)
    
    local cam = self.Camera
    local lp = self.LocalPlayer
    if not cam or not lp or not lp.Character then return false end
    
    local char = lp.Character
    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Exclude
    params.FilterDescendantsInstances = {char}
    params.IgnoreWater = true

    local camOrigin = cam.CFrame.Position
    local castResult = self.Workspace:Raycast(camOrigin, (predictedPosition - camOrigin), params)
    
    if castResult and castResult.Instance then
        local model = castResult.Instance:FindFirstAncestorOfClass("Model")
        if model and self.Players:GetPlayerFromCharacter(model) ~= nil then
            return true 
        end
    end

    return false
end

main_utils.GetClosestPlayer = function(self)
    local lp = self.LocalPlayer
    local cam = self.Camera
    if not lp or not cam then return nil end
    
    local closestDistance = math_huge
    local closest = nil
    local mouseLoc = self.UserInputService:GetMouseLocation()

    for _, v in pairs(self.Players:GetPlayers()) do
        if v == lp then continue end
        
        local char = v.Character
        if not char then continue end
        local hrp = char:FindFirstChild("HumanoidRootPart")
        if not hrp then continue end
        local hum = char:FindFirstChild("Humanoid")
        if not hum or hum.Health <= 0 then continue end

        if Fluent.Options.TeamCheck and Fluent.Options.TeamCheck.Value then
            local myteam = lp.Team and lp.Team.Name
            local theirTeam = v.Team and v.Team.Name
            if myteam and theirTeam and myteam ~= "" and myteam == theirTeam then continue end
        end

        local head = char:FindFirstChild("Head")
        if not head then continue end
        
        local screenPos, onScreen = cam:WorldToViewportPoint(hrp.Position)
        if onScreen then
            local distance = (Vector2_new(screenPos.X, screenPos.Y) - mouseLoc).Magnitude
            if distance < closestDistance then
                if not self:isPredictivelyVisible(head, hrp) then continue end
                closestDistance = distance
                closest = head
            end
        end
    end

    return closest
end

local function create3DEsp(p)
    local id = "esp_" .. p.UserId
    local g = container:FindFirstChild(id) or Instance.new("Folder")
    g.Name = id
    g.Parent = container

    local cache = {}
    local terrain = main_utils.Workspace:FindFirstChildOfClass("Terrain")

    for _, pair in next, edges do
        local name = pair[1] .. pair[2]
        
        local out = g:FindFirstChild(name .. "_o") or Instance.new("LineHandleAdornment")
        out.Name = name .. "_o"
        out.Thickness = 2.4 
        out.AlwaysOnTop = true
        out.ZIndex = 1
        out.Color3 = Color3_fromRGB(0, 0, 0)
        out.Adornee = terrain
        out.Parent = g

        local main = g:FindFirstChild(name .. "_m") or Instance.new("LineHandleAdornment")
        main.Name = name .. "_m"
        main.Thickness = 1.8 
        main.AlwaysOnTop = true
        main.ZIndex = 2
        main.Color3 = Color3_fromRGB(255, 255, 255)
        main.Adornee = terrain
        main.Parent = g

        cache[name] = {m = main, o = out}
    end

    local hl = g:FindFirstChild("EspHighlight") or Instance.new("Highlight")
    hl.Name = "EspHighlight"
    hl.FillTransparency = 0.6
    hl.OutlineTransparency = 0.2
    hl.OutlineColor = Color3_fromRGB(0, 0, 0)
    hl.Enabled = false
    hl.Parent = g

    local bb = g:FindFirstChild("TagGui") or Instance.new("BillboardGui")
    bb.Name = "TagGui"
    bb.Size = UDim2.new(0, 100, 0, 20)
    bb.AlwaysOnTop = true
    bb.Parent = g

    local tagLabel = bb:FindFirstChild("TagLabel") or Instance.new("TextLabel")
    tagLabel.Name = "TagLabel"
    tagLabel.Size = UDim2.new(1, 0, 1, 0)
    tagLabel.BackgroundTransparency = 1
    tagLabel.TextColor3 = Color3_fromRGB(255, 255, 255)
    tagLabel.TextSize = 12
    tagLabel.Font = Enum.Font.SourceSansBold
    tagLabel.TextStrokeTransparency = 0
    tagLabel.TextStrokeColor3 = Color3_fromRGB(0, 0, 0)
    tagLabel.Parent = bb

    local function step()
        local espMaster = Fluent.Options.EspMaster and Fluent.Options.EspMaster.Value
        local char = p.Character
        local root = char and char:FindFirstChild("HumanoidRootPart")
        local hum = char and char:FindFirstChildOfClass("Humanoid")
        local head = char and char:FindFirstChild("Head")
        local lpChar = main_utils.LocalPlayer.Character
        local localHrp = lpChar and lpChar:FindFirstChild("HumanoidRootPart")

if espMaster and root and hum and hum.Health > 0 and head and localHrp then
local cf = root.CFrame
local extentsSize = char:GetExtentsSize()
local s = Vector3_new(extentsSize.X * 1.1, extentsSize.Y * 0.95, extentsSize.Z * 1.1) / 2
local pts = {
f1 = (cf * CFrame_new(-s.X,  s.Y,  s.Z)).Position,
f2 = (cf * CFrame_new( s.X,  s.Y,  s.Z)).Position,
f3 = (cf * CFrame_new( s.X, -s.Y,  s.Z)).Position,
f4 = (cf * CFrame_new(-s.X, -s.Y,  s.Z)).Position,
b1 = (cf * CFrame_new(-s.X,  s.Y, -s.Z)).Position,
b2 = (cf * CFrame_new( s.X,  s.Y, -s.Z)).Position,
b3 = (cf * CFrame_new( s.X, -s.Y, -s.Z)).Position,
b4 = (cf * CFrame_new(-s.X, -s.Y, -s.Z)).Position
}
local currentTarget = (main_utils.target and main_utils.target.Parent == char)
local targetCol = Fluent.Options.TargetColor and Fluent.Options.TargetColor.Value or Color3_fromRGB(255, 0, 0)
local espCol = Fluent.Options.EspColor and Fluent.Options.EspColor.Value or Color3_fromRGB(255, 255, 255)
local baseColor = currentTarget and targetCol or espCol
local distance = math_floor((root.Position - localHrp.Position).Magnitude)
local showBox = Fluent.Options.EspBox and Fluent.Options.EspBox.Value
for _, pair in next, edges do
local name = pair[1] .. pair[2]
local c = cache[name]
if showBox then
local p1, p2 = pts[pair[1]], pts[pair[2]]
local look = CFrame_new(p1, p2)
local mag = (p1 - p2).Magnitude
c.m.CFrame, c.o.CFrame = look, look
c.m.Length, c.o.Length = mag, mag
c.m.Color3 = baseColor
c.m.Visible, c.o.Visible = true, true
else
c.m.Visible, c.o.Visible = false, false
end
end
if Fluent.Options.EspChams and Fluent.Options.EspChams.Value then
hl.Adornee = char
hl.FillColor = baseColor
hl.Enabled = true
else
hl.Enabled = false
end
if Fluent.Options.EspDistance and Fluent.Options.EspDistance.Value then
bb.Adornee = root
bb.ExtentsOffset = Vector3_new(0, -(s.Y * 1.3), 0)
tagLabel.Text = string.format("%d studs", distance)
tagLabel.TextColor3 = currentTarget and targetCol or Color3_fromRGB(255, 255, 255)
bb.Enabled = true
else
bb.Enabled = false
end
else
hl.Enabled = false
bb.Enabled = false
for _, pair in next, edges do
local name = pair[1] .. pair[2]
local c = cache[name]
if c then c.m.Visible, c.o.Visible = false, false end
end
end
end
local conn = main_utils.RunService.RenderStepped:Connect(step)
espObjects[p] = {folder = g, connection = conn}
end
local function remove3DEsp(p)
if espObjects[p] then
espObjects[p].connection:Disconnect()
if espObjects[p].folder then espObjects[p].folder:Destroy() end
espObjects[p] = nil
end
end
main_utils.Players.PlayerAdded:Connect(create3DEsp)
main_utils.Players.PlayerRemoving:Connect(remove3DEsp)
for _, v in next, main_utils.Players:GetPlayers() do
if v ~= main_utils.LocalPlayer then create3DEsp(v) end
end
main_utils.RunConn = main_utils.RunService.RenderStepped:Connect(function()
main_utils.Camera = Workspace.CurrentCamera
main_utils.target = main_utils:GetClosestPlayer()
end)
local lastClick = 0
main_utils.AutoShootConn = main_utils.RunService.RenderStepped:Connect(function()
local screenCenter = main_utils.Camera.ViewportSize / 2
if UserInputService.MouseBehavior == Enum.MouseBehavior.Default or not (Fluent.Options.AutoShoot and Fluent.Options.AutoShoot.Value) then
return
end
local target = main_utils.target
local lp = main_utils.LocalPlayer
local vim = main_utils.VirtualInputManager
if target and lp and lp.Character and vim then
local weapon = lp.Character:FindFirstChildOfClass("Tool")
if weapon then
local now = os.clock()
local delayValue = Fluent.Options.ShootDelay and Fluent.Options.ShootDelay.Value or 0.001
if now - lastClick >= delayValue then
vim:SendMouseButtonEvent(screenCenter.X, screenCenter.Y, 0, true, game, 1)
vim:SendMouseButtonEvent(screenCenter.X, screenCenter.Y, 0, false, game, 1)
lastClick = now
end
end
end
end)
local findAimFunction = function()
if typeof(filtergc) == "function" then
local searchParams = {Name = "GetAimDirection"}
local typeString = "function"
local searchBoolean = true
local success, res = pcall(filtergc, typeString, searchParams, searchBoolean)
if success and res then return res end
end
if typeof(getgc) == "function" then
for _, v in pairs(getgc()) do
if typeof(v) == "function" and not checkcaller() then
local info = debug.getinfo(v)
local name = info.name or ""
if string.lower(name):find("aimdirection") or name == "GetAim" or name == "getAim" then
return v
end
if typeof(debug.getconstants) == "function" then
local constants = debug.getconstants(v)
if table.find(constants, "GetAimDirection") or (table.find(constants, "FireServer") and table.find(constants, "Unit")) then
return v
end
end
end
end
end
return nil
end
local function applySilentAimHook()
local targetFunc = findAimFunction()
if not targetFunc or targetFunc == main_utils.GetAimDirection then return end
main_utils.GetAimDirection = targetFunc
local _, err = pcall(function()
main_utils.hook = hookfunction(main_utils.GetAimDirection, function(...)
if Fluent.Options.SilentAim and Fluent.Options.SilentAim.Value then
local target = main_utils.target
if target then
local char = main_utils.LocalPlayer.Character
if char then
local head = char:FindFirstChild("Head")
if head then
return (target.Position - head.Position).Unit , head.Position
end
end
end
end
return main_utils.hook(...)
end)
end)
end
task.spawn(function()
while task.wait(3) do
pcall(applySilentAimHook)
end
end)
applySilentAimHook()
SaveManager:SetLibrary(Fluent)
InterfaceManager:SetLibrary(Fluent)
SaveManager:IgnoreThemeSettings()
SaveManager:SetIgnoreIndexes({})
InterfaceManager:SetFolder("sum_dif_config")
SaveManager:SetFolder("sum_dif_config/configs")
InterfaceManager:BuildInterfaceSection(Tabs.Settings)
SaveManager:BuildConfigSection(Tabs.Settings)
Window:SelectTab(1)
Fluent:Notify({
Title = "Loaded(:",
Content = "(follow me on rscripts pls)",
Duration = 5
})
SaveManager:LoadAutoloadConfig()

Review the source before using it. Executions count successful copies, capped at 10 per user and network per script in 24 hours.