--  Services
local Players           = game:GetService("Players")
local StarterGui        = game:GetService("StarterGui")
local RunService        = game:GetService("RunService")
local UserInputService  = game:GetService("UserInputService")
local Workspace         = game:GetService("Workspace")
local CoreGui           = game:GetService("CoreGui")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local notification      = game:GetService("NotificationService")

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


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

local Window = Rayfield:CreateWindow({
    Name                = "its everything N0IR",
    LoadingTitle        = "its everyday bro",
    LoadingSubtitle     = "loading dicks on ur mouth trust me",
    Theme               = "Light",
    ConfigurationSaving = { Enabled = true, FolderName = "OP1 N0IR", FileName = "Config" },
    Discord             = { Enabled = true, Invite = ".gg/JGDAWjhWzp", Required = false },
    KeySystem           = false,
})

task.spawn(function()
    pcall(function()
        local sg
        for _ = 1, 40 do
            sg = CoreGui:FindFirstChild("Rayfield")
            if sg then break end
            task.wait(0.1)
        end
        if not sg then return end

        local OFFWHITE = Color3.fromRGB(245, 245, 245)
        local BLACK    = Color3.fromRGB(20, 20, 20)

        local function isDark(c)
            return (c.R * 0.299 + c.G * 0.587 + c.B * 0.114) < 0.45
        end

        for _, d in ipairs(sg:GetDescendants()) do
            if d:IsA("Frame") or d:IsA("ScrollingFrame") then
                if isDark(d.BackgroundColor3) then d.BackgroundColor3 = OFFWHITE end
            elseif d:IsA("TextLabel") or d:IsA("TextButton") or d:IsA("TextBox") then
                if not isDark(d.TextColor3) then d.TextColor3 = BLACK end
                if d:IsA("TextButton") and isDark(d.BackgroundColor3) then
                    d.BackgroundColor3 = OFFWHITE
                end
            elseif d:IsA("ImageLabel") or d:IsA("ImageButton") then
                if isDark(d.ImageColor3) then d.ImageColor3 = BLACK end
            end
        end
    end)
end)


--  Tabs
local TabSilent   = Window:CreateTab("Silent Aim",  4483362458)
local TabFirerate = Window:CreateTab("Firerate",    4483362458)
local TabESP      = Window:CreateTab("ESP",         4483362458)
local TabChams    = Window:CreateTab("Chams",       4483362458)


--  Actor lib helper
local function runOnActor(src)
    if not getactors or not run_on_actor then
        warn("[op1] executor missing getactors / run_on_actor")
        return false
    end
    local actors = getactors()
    local actor  = actors and actors[1]
    if not actor then warn("[op1] no actor found") return false end
    local ok, err = pcall(run_on_actor, actor, src)
    if not ok then warn("[op1] run_on_actor: " .. tostring(err)) end
    return ok
end


local function canPenetrate(instance)
    if not instance or not instance:IsA("BasePart") then return true end
    local parent = instance.Parent

    local isHard = instance:GetAttribute("Hard")
        or (parent and parent:GetAttribute("Hard"))

    local isSoft = instance:GetAttribute("Soft")
        or (parent and parent:GetAttribute("Soft"))

    -- Transparent / no-collide parts are always passable
    if instance.Transparency >= 1 or not instance.CanCollide then
        return true
    end

    if isSoft  then return true  end
    if isHard  then
        -- Hard parts still bangable if thin enough (game rule)
        local dims = { instance.Size.X, instance.Size.Y, instance.Size.Z }
        table.sort(dims)
        if dims[2] > 0.5 then return false end
        return true
    end

    -- Normal solid part: bangable only if middle dimension < 1.45
    local dims = { instance.Size.X, instance.Size.Y, instance.Size.Z }
    table.sort(dims)

    if instance:HasTag("WallPart") then
        return dims[2] <= 0.5
    end

    return dims[2] < 1.45
end

-- Raycast from origin toward target, returns true if every
-- part between them is penetrable (or the target is visible)
local function isWallbangable(origin, targetPos, ignoreList)
    local direction = targetPos - origin
    local params    = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Exclude
    params.FilterDescendantsInstances = ignoreList or {}

    local remaining = direction
    local pos       = origin

    for _ = 1, 12 do  -- max 12 wall penetrations (generous)
        local result = Workspace:Raycast(pos, remaining, params)
        if not result then return true end  -- clear line of sight

        if not canPenetrate(result.Instance) then
            return false  -- solid wall, no bang
        end

        -- Step past this instance and keep casting
        params:AddToFilter(result.Instance)
        local traveled = result.Position - origin
        remaining = direction - traveled
        pos = result.Position + remaining.Unit * 0.01

        if remaining.Magnitude < 0.1 then return true end
    end

    return true
end


--  Viewmodel helper
local function isVMModel(m)
    return m and m:IsA("Model") and m:GetAttribute("Viewmodels") == true
end

local PlayerToVM = {}  -- [player] = viewmodel model

local function watchCharacter(plr, char)
    if plr == LocalPlayer then return end
    task.spawn(function()
        local torso = char:WaitForChild("torso", 8)
        if not torso then return end

        if isVMModel(torso.Parent) then
            PlayerToVM[plr] = torso.Parent
            return
        end

        local conn
        conn = torso.AncestryChanged:Connect(function()
            conn:Disconnect()
            local vm = torso.Parent
            if isVMModel(vm) then
                PlayerToVM[plr] = vm
            end
        end)

        char.AncestryChanged:Connect(function()
            if not char:IsDescendantOf(game) and conn then
                conn:Disconnect(); conn = nil
            end
        end)
    end)
end

local function hookPlayer(plr)
    if plr == LocalPlayer then return end
    if plr.Character then watchCharacter(plr, plr.Character) end
    plr.CharacterAdded:Connect(function(c) watchCharacter(plr, c) end)
    plr.CharacterRemoving:Connect(function()
        PlayerToVM[plr] = nil
    end)
end

for _, p in ipairs(Players:GetPlayers()) do hookPlayer(p) end
Players.PlayerAdded:Connect(hookPlayer)
Players.PlayerRemoving:Connect(function(p) PlayerToVM[p] = nil end)


-- Silent aim & autoshoot (autoshoot dont work)
local SA = {
    Enabled     = false,
    AutoShoot   = false,
    FOV         = 200,
    TargetPart  = "head",
    TeamCheck   = true,
    WallbangOnly = false,  -- if true: autoshoot ONLY fires through bangable walls
}

-- FOV circle drawing (doesnt work aswell)
local fovCircle       = Drawing.new("Circle")
fovCircle.Visible     = false
fovCircle.Thickness   = 1.5
fovCircle.Color       = Color3.fromRGB(255, 255, 255)
fovCircle.Filled      = false
fovCircle.NumSides    = 64
fovCircle.Transparency = 1

RunService.RenderStepped:Connect(function()
    Camera = Workspace.CurrentCamera
    local center = Camera.ViewportSize / 2
    fovCircle.Position = center
    fovCircle.Radius   = SA.FOV
    fovCircle.Visible  = SA.Enabled
end)

local CUSTOM_PARTS = {
    "head","torso","shoulder1","shoulder2",
    "arm1","arm2","hip1","hip2","leg1","leg2",
}

local function isTeammate(plr)
    if not SA.TeamCheck then return false end
    local a, b = LocalPlayer.Team, plr.Team
    return a and b and a == b
end

local function getMouseCenter()
    return UserInputService:GetMouseLocation()
end

local function getVMParts(vm)
    local parts = {}
    if SA.TargetPart == "head" then
        local h = vm:FindFirstChild("head")
        if h then parts[#parts+1] = h end
    else
        for _, name in ipairs(CUSTOM_PARTS) do
            local p = vm:FindFirstChild(name)
            if p then parts[#parts+1] = p end
        end
    end
    return parts
end

local function findTarget()
    local mouse     = UserInputService:GetMouseLocation()
    local cam       = Workspace.CurrentCamera
    local best      = nil
    local bestDist2 = SA.FOV * SA.FOV

    local vms = Workspace:FindFirstChild("Viewmodels")
    if not vms then return nil end

    for _, vm in ipairs(vms:GetChildren()) do
        if vm.Name == "LocalViewmodel" then continue end
        if not vm:IsA("Model") then continue end

        local torso = vm:FindFirstChild("torso")
        if not torso or torso.Transparency >= 1 then continue end

        local head = vm:FindFirstChild("head")
        if not head or not head:IsA("BasePart") then continue end

        local screenPos, onScreen = cam:WorldToViewportPoint(head.Position)
        if not onScreen or screenPos.Z <= 0 then continue end

        local dx = screenPos.X - mouse.X
        local dy = screenPos.Y - mouse.Y
        local d2 = dx*dx + dy*dy

        if d2 < bestDist2 then
            bestDist2 = d2
            best      = head
        end
    end

    return best
end

-- Patch gun silent aim on actor — LO's working version
local SILENT_SRC = [==[
    local rs    = game:GetService("ReplicatedStorage")
    local input = game:GetService("UserInputService")
    local world = game:GetService("Workspace")

    local gunClass = require(rs.Modules.Items.Item.Gun)

    if gunClass._silent_aim_patched then return end
    gunClass._silent_aim_patched = true

    local oldLook = gunClass.get_shoot_look

    local radius     = 1000
    local radius_sq  = radius * radius
    local targetMode = "head_only"
    local customParts = {
        "head","torso","shoulder1","shoulder2",
        "arm1","arm2","hip1","hip2","leg1","leg2",
    }

    local mouse = input:GetMouseLocation()
    local cam   = world.CurrentCamera
    input.InputChanged:Connect(function()
        mouse = input:GetMouseLocation()
    end)

    local function getPartList()
        if targetMode == "head_only" then return { "head" } end
        return customParts
    end

    local function pickAimPart()
        local best, best_d2 = nil, math.huge
        local function consider(p)
            if not p or not p:IsA("BasePart") then return end
            local v2, ok = cam:WorldToViewportPoint(p.Position)
            if not ok then return end
            local dx, dy = v2.X - mouse.X, v2.Y - mouse.Y
            local d2 = dx*dx + dy*dy
            if d2 <= radius_sq and d2 < best_d2 then
                best, best_d2 = p, d2
            end
        end
        local vms = world:FindFirstChild("Viewmodels")
        if vms then
            for _, vm in ipairs(vms:GetChildren()) do
                if vm.Name ~= "Viewmodel" then continue end
                local torso = vm:FindFirstChild("torso")
                if torso and torso.Transparency == 1 then continue end
                for _, name in ipairs(getPartList()) do
                    consider(vm:FindFirstChild(name))
                end
            end
        end
        return best
    end

    local probed = false

    gunClass.get_shoot_look = function(self, ...)
        local look   = oldLook(self, ...)
        local target = pickAimPart()

        if not probed then
            probed = true
            print("[silent-aim] oldLook returned:", typeof(look), tostring(look))
        end

        if not target then return look end

        if typeof(look) == "CFrame" then
            return CFrame.lookAt(look.Position, target.Position)
        elseif typeof(look) == "Vector3" then
            return (target.Position - cam.CFrame.Position).Unit
        elseif type(look) == "table" then
            if look[1] and look[2] and typeof(look[1]) == "Vector3" then
                return { look[1], (target.Position - look[1]).Unit }
            end
            if look.origin and look.direction then
                return {
                    origin    = look.origin,
                    direction = (target.Position - look.origin).Unit,
                }
            end
        end

        return look
    end

    print("[silent-aim] patched, now you can shoot without looking at them.")
]==]

-- autoshoot = hold mouse1 when target valid, no actor patch needed

local silentLoaded = false

local function ensureSilentAim()
    if silentLoaded then return end
    silentLoaded = true
    run_on_actor(getactors()[1], SILENT_SRC)
end

local function reloadSilentAim()
    silentLoaded = false
    -- clear patch flag so actor re-runs it
    run_on_actor(getactors()[1], [==[
        local rs = game:GetService("ReplicatedStorage")
        local g  = require(rs.Modules.Items.Item.Gun)
        g._silent_aim_patched = nil
    ]==])
    ensureSilentAim()
end

local isHoldingM1 = false

local function pressM1()
    if isHoldingM1 then return end
    isHoldingM1 = true
    mouse1press()
end

local function releaseM1()
    if not isHoldingM1 then return end
    isHoldingM1 = false
    mouse1release()
end

-- Main loop
RunService.Heartbeat:Connect(function(dt)
    if not SA.Enabled then
        releaseM1()
        return
    end

    ensureSilentAim()

    if not SA.AutoShoot then
        releaseM1()
        return
    end

    local target = findTarget()

    if not target then
        releaseM1()
        return
    end

    local camPos    = Camera.CFrame.Position
    local targetPos = target.Position

    local ignore = {}
    if LocalPlayer.Character then
        for _, v in ipairs(LocalPlayer.Character:GetDescendants()) do
            if v:IsA("BasePart") then ignore[#ignore+1] = v end
        end
    end

    -- LOS check: visible head = shoot, blocked = check wallbang
    local losParams = RaycastParams.new()
    losParams.FilterType = Enum.RaycastFilterType.Exclude
    losParams.FilterDescendantsInstances = ignore

    local losResult = Workspace:Raycast(camPos, targetPos - camPos, losParams)
    local shootable = not losResult or isWallbangable(camPos, targetPos, ignore)

    if shootable then
        pressM1()
    else
        releaseM1()
    end
end)


--  Rapid fire
local FIRERATE_SRC = [==[
    local rs = game:GetService("ReplicatedStorage")
    local sg = game:GetService("StarterGui")

    local MULTIPLIER = __MULT__

    local gunClass = require(rs.Modules.Items.Item.Gun)

    if gunClass._op1_firerate_patched then
        if gunClass._op1_firerate_set_mult then
            gunClass._op1_firerate_set_mult(MULTIPLIER)
        end
        return
    end
    gunClass._op1_firerate_patched = true

    local multiplier       = MULTIPLIER
    local lastSendTime     = 0
    local measuredInterval = 0.1

    gunClass._op1_firerate_set_mult = function(m)
        multiplier = m
    end

    local oldSend = gunClass.send_shoot
    if type(oldSend) ~= "function" then
        warn("[op1-firerate] send_shoot not a function")
        return
    end

    gunClass.send_shoot = function(self, ...)
        local args = { ... }
        local now  = tick()

        if lastSendTime > 0 then
            local d = now - lastSendTime
            if d > 0.005 and d < 2 then
                measuredInterval = d
            end
        end
        lastSendTime = now

        local r = oldSend(self, ...)

        if multiplier > 1 then
            local step = math.max(measuredInterval / multiplier, 0.02)
            for i = 1, multiplier - 1 do
                task.delay(step * i, function()
                    pcall(oldSend, self, table.unpack(args))
                end)
            end
        end

        return r
    end

    pcall(function()
        sg:SetCore("SendNotification", {
            Title = "Firerate", Text = "x" .. tostring(multiplier) .. " loaded", Duration = 3
        })
    end)
    print("[op1-firerate] patched x" .. tostring(multiplier))
]==]

local FR = { enabled = false, mult = 2 }

local function applyFirerate(mult)
    local src = string.gsub(FIRERATE_SRC, "__MULT__", tostring(mult))
    runOnActor(src)
end


--  ESP
local ESPCfg = {
    Enabled       = false,
    TeamCheck     = true,
    MaxDist       = 850,
    ShowDead      = false,

    EnemyFill     = Color3.fromRGB(220, 50, 50),
    EnemyOutline  = Color3.fromRGB(255, 90, 90),
    TeamFill      = Color3.fromRGB(50, 130, 220),
    TeamOutline   = Color3.fromRGB(80, 170, 255),
    FillTransp    = 0.60,
    OutlineTransp = 0,

    BoxEnabled    = true,
    BoxColor      = Color3.fromRGB(255, 255, 255),
    BoxThickness  = 1.5,

    Names         = true,
    NameColor     = Color3.fromRGB(255, 255, 255),
    Distance      = true,
    DistColor     = Color3.fromRGB(185, 185, 185),
    HealthBar     = true,
    HPHigh        = Color3.fromRGB(40, 215, 80),
    HPMid         = Color3.fromRGB(235, 195, 30),
    HPLow         = Color3.fromRGB(230, 45, 45),

    -- Team check runs every N frames (10 = default)
    TeamCheckFrames = 10,
}

local ESPTrack = {}  -- [player] = { hl, bb, box={}, vmConn }
local frameCounter = 0

local function hpColor(pct)
    if pct > 0.60 then return ESPCfg.HPHigh end
    if pct > 0.30 then return ESPCfg.HPMid  end
    return ESPCfg.HPLow
end

local function isESPTeammate(plr)
    if not ESPCfg.TeamCheck then return false end
    return LocalPlayer.Team ~= nil
        and plr.Team ~= nil
        and LocalPlayer.Team == plr.Team
end

-- Box drawings per player
local function createBoxDrawings()
    local lines = {}
    for i = 1, 4 do
        local l = Drawing.new("Line")
        l.Visible   = false
        l.Thickness = ESPCfg.BoxThickness
        l.Color     = ESPCfg.BoxColor
        l.Transparency = 1
        lines[i] = l
    end
    return lines
end

local function destroyBoxDrawings(lines)
    if not lines then return end
    for _, l in ipairs(lines) do pcall(function() l:Remove() end) end
end

local function hideBox(lines)
    if not lines then return end
    for _, l in ipairs(lines) do l.Visible = false end
end

local function updateBox(lines, vm)
    if not lines or not vm then return end
    local cam = Workspace.CurrentCamera
    if not cam then return end

    local ok, cf, size = pcall(function() return vm:GetBoundingBox() end)
    if not ok or not cf or not size then hideBox(lines) return end

    local half = size / 2
    local corners3D = {
        Vector3.new(-half.X, -half.Y, -half.Z),
        Vector3.new(-half.X, -half.Y,  half.Z),
        Vector3.new(-half.X,  half.Y, -half.Z),
        Vector3.new(-half.X,  half.Y,  half.Z),
        Vector3.new( half.X, -half.Y, -half.Z),
        Vector3.new( half.X, -half.Y,  half.Z),
        Vector3.new( half.X,  half.Y, -half.Z),
        Vector3.new( half.X,  half.Y,  half.Z),
    }

    local minX, minY =  math.huge,  math.huge
    local maxX, maxY = -math.huge, -math.huge
    local anyVisible = false

    for _, pt in ipairs(corners3D) do
        local s = cam:WorldToViewportPoint(cf:PointToWorldSpace(pt))
        if s.Z > 0 then
            anyVisible = true
            if s.X < minX then minX = s.X end
            if s.Y < minY then minY = s.Y end
            if s.X > maxX then maxX = s.X end
            if s.Y > maxY then maxY = s.Y end
        end
    end

    if not anyVisible or (maxX - minX) < 2 or (maxY - minY) < 2 then
        hideBox(lines) return
    end

    -- 4 lines = top, bottom, left, right
    local tl = Vector2.new(minX, minY)
    local tr = Vector2.new(maxX, minY)
    local bl = Vector2.new(minX, maxY)
    local br = Vector2.new(maxX, maxY)

    lines[1].From = tl; lines[1].To = tr; lines[1].Visible = true  -- top
    lines[2].From = bl; lines[2].To = br; lines[2].Visible = true  -- bottom
    lines[3].From = tl; lines[3].To = bl; lines[3].Visible = true  -- left
    lines[4].From = tr; lines[4].To = br; lines[4].Visible = true  -- right

    for _, l in ipairs(lines) do
        l.Color     = ESPCfg.BoxColor
        l.Thickness = ESPCfg.BoxThickness
    end
end

-- Billboard helpers
local function safeRemoveBB(t)
    if t and t.bb then
        pcall(function() t.bb:Destroy() end)
        t.bb = nil
    end
end

local function buildBB(plr)
    local t = ESPTrack[plr]
    if not t then return end
    safeRemoveBB(t)

    local char = plr.Character
    local root = char and char:FindFirstChild("HumanoidRootPart")
    if not root then return end

    local bb = Instance.new("BillboardGui")
    bb.Name           = "ESP_" .. plr.UserId
    bb.Size           = UDim2.fromOffset(150, 52)
    bb.StudsOffset    = Vector3.new(0, 3.6, 0)
    bb.AlwaysOnTop    = true
    bb.ResetOnSpawn   = false
    bb.LightInfluence = 0
    bb.Adornee        = root
    bb.Enabled        = false
    bb.Parent         = CoreGui

    local function lbl(name, sz, yPos, font)
        local l = Instance.new("TextLabel")
        l.Name                   = name
        l.Size                   = UDim2.new(1,0,0,sz)
        l.Position               = UDim2.fromOffset(0, yPos)
        l.BackgroundTransparency = 1
        l.Font                   = font or Enum.Font.GothamBold
        l.TextSize               = sz
        l.TextStrokeTransparency = 0.25
        l.TextStrokeColor3       = Color3.new(0,0,0)
        l.Text                   = ""
        l.Parent                 = bb
        return l
    end

    lbl("Name", 13, 0)
    lbl("Dist", 11, 15, Enum.Font.Gotham)

    local hpBg = Instance.new("Frame")
    hpBg.Name             = "HPBg"
    hpBg.Size             = UDim2.new(1,0,0,6)
    hpBg.Position         = UDim2.fromOffset(0, 28)
    hpBg.BackgroundColor3 = Color3.fromRGB(25,25,25)
    hpBg.BorderSizePixel  = 0
    hpBg.Parent           = bb
    Instance.new("UICorner", hpBg).CornerRadius = UDim.new(1,0)

    local hpFg = Instance.new("Frame")
    hpFg.Name             = "HPFg"
    hpFg.Size             = UDim2.fromScale(1,1)
    hpFg.BackgroundColor3 = ESPCfg.HPHigh
    hpFg.BorderSizePixel  = 0
    hpFg.Parent           = hpBg
    Instance.new("UICorner", hpFg).CornerRadius = UDim.new(1,0)

    t.bb = bb
end

local function destroyESPEntry(plr)
    local t = ESPTrack[plr]
    if not t then return end
    if t.vmConn  then pcall(function() t.vmConn:Disconnect() end) end
    if t.bb      then pcall(function() t.bb:Destroy() end) end
    if t.hl      then pcall(function() t.hl:Destroy() end) end
    destroyBoxDrawings(t.box)
    ESPTrack[plr] = nil
end

local function setupESPHighlight(plr, vm)
    destroyESPEntry(plr)

    local team = isESPTeammate(plr)
    local hl   = Instance.new("Highlight")
    hl.FillColor           = team and ESPCfg.TeamFill    or ESPCfg.EnemyFill
    hl.OutlineColor        = team and ESPCfg.TeamOutline or ESPCfg.EnemyOutline
    hl.FillTransparency    = ESPCfg.FillTransp
    hl.OutlineTransparency = ESPCfg.OutlineTransp
    hl.DepthMode           = Enum.HighlightDepthMode.AlwaysOnTop
    hl.Enabled             = false
    hl.Parent              = vm

    ESPTrack[plr] = {
        hl     = hl,
        bb     = nil,
        box    = createBoxDrawings(),
        vmConn = nil,
    }

    buildBB(plr)

    local vmConn
    vmConn = vm.AncestryChanged:Connect(function()
        if not vm:IsDescendantOf(Workspace) then
            vmConn:Disconnect()
            local t = ESPTrack[plr]
            if t and t.vmConn == vmConn then
                safeRemoveBB(t)
                hideBox(t.box)
                t.hl = nil
            end
        end
    end)

    ESPTrack[plr].vmConn = vmConn
end

local function watchESPCharacter(plr, char)
    if plr == LocalPlayer then return end
    task.spawn(function()
        local torso = char:WaitForChild("torso", 8)
        if not torso then return end

        if isVMModel(torso.Parent) then
            setupESPHighlight(plr, torso.Parent)
            return
        end

        local conn
        conn = torso.AncestryChanged:Connect(function()
            conn:Disconnect()
            local vm = torso.Parent
            if isVMModel(vm) then
                setupESPHighlight(plr, vm)
            end
        end)

        char.AncestryChanged:Connect(function()
            if not char:IsDescendantOf(game) and conn then
                conn:Disconnect(); conn = nil
            end
        end)
    end)
end

local function hookESPPlayer(plr)
    if plr == LocalPlayer then return end
    if plr.Character then watchESPCharacter(plr, plr.Character) end
    plr.CharacterAdded:Connect(function(c)
        task.delay(0.05, function()
            if ESPTrack[plr] then buildBB(plr) end
        end)
        watchESPCharacter(plr, c)
    end)
    plr.CharacterRemoving:Connect(function()
        local t = ESPTrack[plr]
        if t and t.bb then t.bb.Enabled = false end
        hideBox(t and t.box)
    end)
end

for _, p in ipairs(Players:GetPlayers()) do hookESPPlayer(p) end
Players.PlayerAdded:Connect(hookESPPlayer)
Players.PlayerRemoving:Connect(destroyESPEntry)

-- ESP render loop
RunService.RenderStepped:Connect(function()
    frameCounter += 1
    local cam = Workspace.CurrentCamera

    for plr, t in pairs(ESPTrack) do
        local hl  = t.hl
        local bb  = t.bb
        local box = t.box

        if not plr.Parent then
            destroyESPEntry(plr)
            continue
        end

        if not hl or not hl.Parent then
            if hl then t.hl = nil end
            if bb then bb.Enabled = false end
            hideBox(box)
            continue
        end

        local char = plr.Character
        local hum  = char and char:FindFirstChildOfClass("Humanoid")
        local root = char and char:FindFirstChild("HumanoidRootPart")

        -- Team check runs every TeamCheckFrames frames
        local team = false
        if frameCounter % ESPCfg.TeamCheckFrames == 0 then
            team = isESPTeammate(plr)
        else
            -- Read cached from highlight color (quick approximation)
            team = hl.FillColor == ESPCfg.TeamFill
        end

        local alive = hum and hum.Health > 0
        local show  = ESPCfg.Enabled
            and (ESPCfg.ShowDead or alive)
            and (not ESPCfg.TeamCheck or not team)

        if show and root and cam then
            local d = (cam.CFrame.Position - root.Position).Magnitude
            if d > ESPCfg.MaxDist then show = false end
        end

        if not show then
            hl.Enabled = false
            if bb then bb.Enabled = false end
            hideBox(box)
            continue
        end

        -- Update highlight
        hl.Enabled             = true
        hl.FillColor           = team and ESPCfg.TeamFill    or ESPCfg.EnemyFill
        hl.OutlineColor        = team and ESPCfg.TeamOutline or ESPCfg.EnemyOutline
        hl.FillTransparency    = ESPCfg.FillTransp
        hl.OutlineTransparency = ESPCfg.OutlineTransp

        -- Box
        if ESPCfg.BoxEnabled then
            updateBox(box, hl.Parent)
        else
            hideBox(box)
        end

        -- Billboard
        if bb and root then
            if bb.Adornee ~= root then bb.Adornee = root end
            bb.Enabled = true

            local dist    = (cam.CFrame.Position - root.Position).Magnitude
            local nameLbl = bb:FindFirstChild("Name")
            local distLbl = bb:FindFirstChild("Dist")
            local hpBg    = bb:FindFirstChild("HPBg")

            if nameLbl then
                nameLbl.Visible    = ESPCfg.Names
                nameLbl.Text       = plr.DisplayName
                nameLbl.TextColor3 = ESPCfg.NameColor
            end
            if distLbl then
                distLbl.Visible    = ESPCfg.Distance
                distLbl.Text       = string.format("[ %dm ]", math.floor(dist))
                distLbl.TextColor3 = ESPCfg.DistColor
            end
            if hpBg then
                hpBg.Visible = ESPCfg.HealthBar
                if ESPCfg.HealthBar and hum then
                    local pct = math.clamp(hum.Health / math.max(hum.MaxHealth,1), 0, 1)
                    local fg  = hpBg:FindFirstChild("HPFg")
                    if fg then
                        fg.Size             = UDim2.fromScale(pct, 1)
                        fg.BackgroundColor3 = hpColor(pct)
                    end
                end
            end
        end
    end
end)


--  Gun chams
local ChamsCfg = {
    Enabled      = false,
    Rainbow      = false,
    Metallic     = false,
    Pulse        = false,
    Color        = Color3.fromRGB(255, 255, 255),
    Transparency = 0,
    RainbowSpeed = 1,
}

local ChamsHL  = nil
local ChamsVM  = nil
local ChamsHue = 0

local function getLocalVM()
    local vms = Workspace:FindFirstChild("Viewmodels")
    return vms and vms:FindFirstChild("LocalViewmodel")
end

local function destroyChams()
    if ChamsHL then pcall(function() ChamsHL:Destroy() end) end
    ChamsHL = nil; ChamsVM = nil
end

local function ensureChams()
    local vm = getLocalVM()
    if not ChamsCfg.Enabled or not vm then destroyChams() return end
    if ChamsHL and ChamsVM == vm then return end
    destroyChams()

    local hl = Instance.new("Highlight")
    hl.Name       = "Op1GunChams"
    hl.Adornee    = vm
    hl.DepthMode  = Enum.HighlightDepthMode.AlwaysOnTop
    hl.Parent     = CoreGui
    ChamsHL = hl; ChamsVM = vm
end

RunService.RenderStepped:Connect(function(dt)
    ensureChams()
    if not ChamsHL then return end

    if ChamsCfg.Rainbow then
        ChamsHue = (ChamsHue + dt * ChamsCfg.RainbowSpeed * 0.1) % 1
        local c = Color3.fromHSV(ChamsHue, 1, 1)
        ChamsHL.FillColor    = c
        ChamsHL.OutlineColor = c
    else
        ChamsHL.FillColor    = ChamsCfg.Color
        ChamsHL.OutlineColor = ChamsCfg.Color
    end

    if ChamsCfg.Metallic then
        ChamsHL.FillColor = ChamsHL.FillColor:Lerp(Color3.new(1,1,1), 0.3)
    end

    ChamsHL.FillTransparency =
        ChamsCfg.Pulse
        and math.abs(math.sin(os.clock() * 2))
        or ChamsCfg.Transparency

    ChamsHL.OutlineTransparency = 0
end)


--  Silent aim tab
TabSilent:CreateSection("Silent Aim")

TabSilent:CreateToggle({
    Name         = "Enable Silent Aim",
    CurrentValue = false,
    Flag         = "sa_enabled",
    Callback     = function(v)
        SA.Enabled = v
        fovCircle.Visible = v
        if v then ensureSilentAim() end
    end,
})

TabSilent:CreateToggle({
    Name         = "Auto Shoot",
    CurrentValue = false,
    Flag         = "sa_autoshoot",
    Callback     = function(v)
        SA.AutoShoot = v
        if not v then releaseM1() end
    end,
})

TabSilent:CreateToggle({
    Name         = "Wallbang Only",
    CurrentValue = false,
    Flag         = "sa_wallbang_only",
    Callback     = function(v)
        SA.WallbangOnly = v
    end,
})

TabSilent:CreateToggle({
    Name         = "Team Check",
    CurrentValue = true,
    Flag         = "sa_teamcheck",
    Callback     = function(v)
        SA.TeamCheck = v
    end,
})

TabSilent:CreateSlider({
    Name         = "FOV Radius",
    Range        = {20, 800},
    Increment    = 10,
    Suffix       = "px",
    CurrentValue = 200,
    Flag         = "sa_fov",
    Callback     = function(v)
        SA.FOV = v
        if SA.Enabled then reloadSilentAim() end
    end,
})

TabSilent:CreateDropdown({
    Name          = "Target Part",
    Options       = {"head", "custom_parts"},
    CurrentOption = {"head"},
    Flag          = "sa_targetpart",
    Callback      = function(opt)
        SA.TargetPart = (type(opt) == "table") and opt[1] or opt
        if SA.Enabled then reloadSilentAim() end
    end,
})

TabSilent:CreateLabel("Auto Shoot fires when target is in FOV + penetrable wall (or clear LOS).")


--  Firerate tab
TabFirerate:CreateSection("Rapid Fire")

TabFirerate:CreateToggle({
    Name         = "Enable Rapid Fire",
    CurrentValue = false,
    Flag         = "fr_enabled",
    Callback     = function(v)
        FR.enabled = v
        applyFirerate(v and FR.mult or 1)
    end,
})

TabFirerate:CreateSlider({
    Name         = "Multiplier",
    Range        = {1, 20},
    Increment    = 1,
    Suffix       = "x",
    CurrentValue = 2,
    Flag         = "fr_mult",
    Callback     = function(v)
        FR.mult = v
        if FR.enabled then applyFirerate(v) end
    end,
})


--  Esp tab
TabESP:CreateSection("Player ESP")

TabESP:CreateToggle({
    Name         = "Enable ESP",
    CurrentValue = false,
    Flag         = "esp_enabled",
    Callback     = function(v) ESPCfg.Enabled = v end,
})

TabESP:CreateToggle({
    Name         = "Team Check",
    CurrentValue = true,
    Flag         = "esp_teamcheck",
    Callback     = function(v) ESPCfg.TeamCheck = v end,
})

TabESP:CreateToggle({
    Name         = "Show Dead",
    CurrentValue = false,
    Flag         = "esp_showdead",
    Callback     = function(v) ESPCfg.ShowDead = v end,
})

TabESP:CreateSection("Box ESP")

TabESP:CreateToggle({
    Name         = "Enable Box",
    CurrentValue = true,
    Flag         = "esp_box",
    Callback     = function(v) ESPCfg.BoxEnabled = v end,
})

TabESP:CreateColorPicker({
    Name     = "Box Color",
    Color    = Color3.fromRGB(255, 255, 255),
    Flag     = "esp_boxcolor",
    Callback = function(c) ESPCfg.BoxColor = c end,
})

TabESP:CreateSection("Labels")

TabESP:CreateToggle({
    Name         = "Names",
    CurrentValue = true,
    Flag         = "esp_names",
    Callback     = function(v) ESPCfg.Names = v end,
})

TabESP:CreateToggle({
    Name         = "Distance",
    CurrentValue = true,
    Flag         = "esp_dist",
    Callback     = function(v) ESPCfg.Distance = v end,
})

TabESP:CreateToggle({
    Name         = "Health Bar",
    CurrentValue = true,
    Flag         = "esp_hp",
    Callback     = function(v) ESPCfg.HealthBar = v end,
})

TabESP:CreateSlider({
    Name         = "Max Distance",
    Range        = {100, 2000},
    Increment    = 50,
    Suffix       = "m",
    CurrentValue = 850,
    Flag         = "esp_maxdist",
    Callback     = function(v) ESPCfg.MaxDist = v end,
})

--  Chams tab
local TabChamsUI = TabChams

TabChamsUI:CreateSection("Gun Chams")

TabChamsUI:CreateToggle({
    Name         = "Enable Chams",
    CurrentValue = false,
    Flag         = "chams_enabled",
    Callback     = function(v)
        ChamsCfg.Enabled = v
        if v then ensureChams() else destroyChams() end
    end,
})

TabChamsUI:CreateColorPicker({
    Name     = "Color",
    Color    = Color3.fromRGB(255, 255, 255),
    Flag     = "chams_color",
    Callback = function(c) ChamsCfg.Color = c end,
})

TabChamsUI:CreateSlider({
    Name         = "Transparency",
    Range        = {0, 100},
    Increment    = 1,
    Suffix       = "%",
    CurrentValue = 0,
    Flag         = "chams_transp",
    Callback     = function(v) ChamsCfg.Transparency = v / 100 end,
})

TabChamsUI:CreateSection("Effects")

TabChamsUI:CreateToggle({
    Name         = "Rainbow",
    CurrentValue = false,
    Flag         = "chams_rainbow",
    Callback     = function(v) ChamsCfg.Rainbow = v end,
})

TabChamsUI:CreateToggle({
    Name         = "Metallic",
    CurrentValue = false,
    Flag         = "chams_metallic",
    Callback     = function(v) ChamsCfg.Metallic = v end,
})

TabChamsUI:CreateToggle({
    Name         = "Pulse",
    CurrentValue = false,
    Flag         = "chams_pulse",
    Callback     = function(v) ChamsCfg.Pulse = v end,
})

TabChamsUI:CreateSlider({
    Name         = "Rainbow Speed",
    Range        = {1, 10},
    Increment    = 1,
    Suffix       = "x",
    CurrentValue = 1,
    Flag         = "chams_rainbowspeed",
    Callback     = function(v) ChamsCfg.RainbowSpeed = v end,
})

Rayfield:LoadConfiguration()

getgenv().Op1Config = { SA = SA, FR = FR, ESP = ESPCfg, Chams = ChamsCfg }


local COPY_LINK = "discord.gg/JGDAWjhWzp"

local function notifyCopied()
    pcall(function()
        StarterGui:SetCore("SendNotification", {
            Title    = "N0IR",
            Text     = "Discord link copied to your clipboard.",
            Duration = 10,
        })
    end)
end

local function sendYesNoNotification()
    pcall(function()
        StarterGui:SetCore("SendNotification", {
            Title    = "N0IR",
            Text     = "Copy the invite link to your clipboard?",
            Duration = 8,
            Button1  = "Yes i will copy i really wanna see your ass.",
            Button2  = "No nigga fuck off.",
            Callback = function(btn)
                local isYes = (btn == 1) or (btn == "Yes") or (btn == "Button1")
                local isNo  = (btn == 2) or (btn == "No")  or (btn == "Button2")

                if isYes then
                    if setclipboard then
                        pcall(setclipboard, COPY_LINK)
                    elseif toclipboard then
                        pcall(toclipboard, COPY_LINK)
                    else
                        warn("no clipboard function available")
                        return
                    end
                    notifyCopied()
                elseif isNo then
                end
            end,
        })
    end)
end

sendYesNoNotification()