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

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

local function getChar()
    local char = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()
    char:WaitForChild("HumanoidRootPart")
    return char
end

local function getMap(timeout)
    return workspace:FindFirstChild("Map") or workspace:WaitForChild("Map", timeout or 15)
end

-- // Window
local Window = Rayfield:CreateWindow({
    Name = "Brothers Vow",
    Icon = 0,
    LoadingTitle = "Brothers Vow",
    LoadingSubtitle = "by sally",
    ShowText = "Rayfield",
    Theme = "Ocean",
    ToggleUIKeybind = "K",
    ConfigurationSaving = {
        Enabled = true,
        FolderName = nil,
        FileName = "Big Hub"
    },
    Discord = { Enabled = false },
    KeySystem = false
})

-------------------------------------------------
--                 LOOT SYSTEM                  --
-------------------------------------------------
local function listItems()
    local map = getMap(10)
    local items, seen = {}, {}
    if not map then return items end

    for _, obj in ipairs(map:GetChildren()) do
        if obj:FindFirstChild("CollectPrompt") then
            if not seen[obj.Name] then
                seen[obj.Name] = true
                table.insert(items, obj.Name)
            end
        end
    end

    -- Garantir opções no menu
    if not seen["Chips"] then table.insert(items, "Chips") end
    if not seen["CandyBar"] then table.insert(items, "CandyBar") end
    if not seen["M1911"] then table.insert(items, "M1911") end

    table.sort(items)
    return items
end

local function findNearestItem(name)
    local map = getMap(5)
    if not map then return nil end
    local char = getChar()
    local hrp = char.HumanoidRootPart
    local nearest, bestDist

    for _, obj in ipairs(map:GetChildren()) do
        if obj.Name == name and obj:FindFirstChild("CollectPrompt") then
            local cf = (obj:IsA("Model") and obj:GetPivot()) or (obj:IsA("BasePart") and obj.CFrame)
            if cf then
                local dist = (hrp.Position - cf.Position).Magnitude
                if not bestDist or dist < bestDist then
                    bestDist = dist
                    nearest = {root = obj, prompt = obj.CollectPrompt, cf = cf}
                end
            end
        end
    end
    return nearest
end

local function useItem(name)
    local data = findNearestItem(name)
    if not data then
        Rayfield:Notify({Title="Item not found", Content=name.." could not be found.", Duration=5})
        return
    end
    local hrp = getChar().HumanoidRootPart
    local oldCFrame = hrp.CFrame

    hrp.CFrame = data.cf + Vector3.new(0, 3, 0)
    task.wait(0.2)
    if typeof(fireproximityprompt) == "function" then
        pcall(function() fireproximityprompt(data.prompt, 1) end) -- instant
    else
        task.wait(2) -- fallback
    end
    task.wait(0.2)
    hrp.CFrame = oldCFrame
end

-------------------------------------------------
--                  UI LOOT TAB                 --
-------------------------------------------------
local LootTab = Window:CreateTab("Loot", 4483362458)
LootTab:CreateSection("Item Picker")

local currentItems = listItems()
local LootDropdown = LootTab:CreateDropdown({
    Name = "Choose item",
    Options = currentItems,
    CurrentOption = currentItems[1],
    MultipleOptions = false,
    Flag = "LootDropdown",
    Callback = function(opt)
        local choice = type(opt) == "table" and opt[1] or opt
        if choice then useItem(choice) end
    end
})

LootTab:CreateButton({
    Name = "🔁 Refresh Items",
    Callback = function()
        local newItems = listItems()
        if LootDropdown and LootDropdown.Set then
            LootDropdown:Set(newItems)
        end
        currentItems = newItems
        Rayfield:Notify({Title="List refreshed", Content="Items found: "..#newItems, Duration=5})
    end
})

-------------------------------------------------
--                   TELEPORTS                  --
-------------------------------------------------
local TeleportTab = Window:CreateTab("Teleports", 4483362458)
TeleportTab:CreateSection("Main Spots")

TeleportTab:CreateButton({
    Name = "Teleport to Exit",
    Callback = function()
        local map = getMap(5)
        if not map then
            Rayfield:Notify({Title="Map not found", Content="Workspace.Map is missing.", Duration=5})
            return
        end
        local exit = map:FindFirstChild("ExitPart")
        if exit and exit:IsA("BasePart") then
            local hrp = getChar().HumanoidRootPart
            hrp.CFrame = exit.CFrame + Vector3.new(0, 3, 0)
        else
            Rayfield:Notify({Title="Not found", Content="ExitPart not available in map.", Duration=5})
        end
    end
})

-------------------------------------------------
--                    VISUALS                   --
-------------------------------------------------
local VisualsTab = Window:CreateTab("Visuals", 4483362458)
VisualsTab:CreateSection("ESP / Highlight")

-- ESP (Enemies)
local espOn, conEnemyAdded
local function isEnemy(model)
    return model and model:IsA("Model") and model.Name == "Enemy"
end

local function addESP(model)
    if model:FindFirstChild("EnemyESP") then return end
    local hl = Instance.new("Highlight")
    hl.Name = "EnemyESP"
    hl.FillTransparency = 0.75
    hl.OutlineTransparency = 0
    hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    hl.Parent = model

    local hum = model:FindFirstChildOfClass("Humanoid")
    if hum then
        hum.Died:Connect(function()
            if hl then hl:Destroy() end
        end)
    end
end

local function removeESP(model)
    local hl = model:FindFirstChild("EnemyESP")
    if hl then hl:Destroy() end
end

local function startESP()
    if espOn then return end
    espOn = true
    for _, d in ipairs(workspace:GetChildren()) do
        if isEnemy(d) then addESP(d) end
    end
    conEnemyAdded = workspace.ChildAdded:Connect(function(inst)
        if espOn and isEnemy(inst) then addESP(inst) end
    end)
end

local function stopESP()
    espOn = false
    if conEnemyAdded then conEnemyAdded:Disconnect() conEnemyAdded = nil end
    for _, d in ipairs(workspace:GetChildren()) do
        if isEnemy(d) then removeESP(d) end
    end
end

VisualsTab:CreateToggle({
    Name = "Enemy ESP",
    CurrentValue = false,
    Flag = "EnemyESP",
    Callback = function(state)
        if state then startESP() else stopESP() end
    end
})

VisualsTab:CreateSection("Weather / Atmosphere")

-- ====== Remove Fog (robusto) ======
local noFogOn = false
local savedFog = {
    FogStart = Lighting.FogStart,
    FogEnd   = Lighting.FogEnd,
}
local savedAtmos, savedBlur

local function setNoFog(state)
    noFogOn = state
    if state then
        savedFog.FogStart = Lighting.FogStart
        savedFog.FogEnd   = Lighting.FogEnd
        Lighting.FogStart = 0
        Lighting.FogEnd   = 1e7
    else
        Lighting.FogStart = savedFog.FogStart or 0
        Lighting.FogEnd   = savedFog.FogEnd   or 1000
    end

    local atm = Lighting:FindFirstChildOfClass("Atmosphere")
    if atm then
        if state then
            savedAtmos = {
                Density = atm.Density,
                Haze    = atm.Haze,
                Glare   = atm.Glare,
                Offset  = atm.Offset,
            }
            atm.Density = 0
            atm.Haze    = 0
            atm.Glare   = 0
            atm.Offset  = 0
        else
            if savedAtmos then
                pcall(function()
                    atm.Density = savedAtmos.Density
                    atm.Haze    = savedAtmos.Haze
                    atm.Glare   = savedAtmos.Glare
                    atm.Offset  = savedAtmos.Offset
                end)
            end
        end
    end

    local blur = Lighting:FindFirstChild("Blur")
    if blur and blur:IsA("BlurEffect") then
        if state then
            savedBlur = {Enabled = blur.Enabled, Size = blur.Size}
            blur.Enabled = false
            blur.Size = 0
        else
            if savedBlur then
                blur.Enabled = savedBlur.Enabled
                blur.Size    = savedBlur.Size
            end
        end
    end
end

VisualsTab:CreateToggle({
    Name = "Remove Fog",
    CurrentValue = false,
    Flag = "NoFog",
    Callback = function(state)
        setNoFog(state)
    end
})

-- ====== Remove Rain (incluindo Workspace.Camera._RainEmitter) ======
local noRainOn = false
local trackedRain = {}
local rainCon

local function isRainInstance(inst)
    local n = inst.Name and inst.Name:lower() or ""
    if inst:IsA("ParticleEmitter") or inst:IsA("Trail") or inst:IsA("Beam") then
        if n:find("rain") or inst.Name == "_RainEmitter" then return true end
    elseif inst:IsA("Sound") then
        if n:find("rain") or n:find("thunder") then return true end
    elseif inst:IsA("Folder") then
        if n == "rain" then return true end
    end
    return false
end

local function applyNoRainTo(inst)
    if inst:IsA("ParticleEmitter") then
        trackedRain[inst] = trackedRain[inst] or {Enabled = inst.Enabled, Rate = inst.Rate}
        inst.Enabled = false
        inst.Rate = 0
    elseif inst:IsA("Trail") or inst:IsA("Beam") then
        trackedRain[inst] = trackedRain[inst] or {Enabled = inst.Enabled}
        inst.Enabled = false
    elseif inst:IsA("Sound") then
        trackedRain[inst] = trackedRain[inst] or {Playing = inst.Playing, Volume = inst.Volume}
        inst.Playing = false
        inst.Volume  = 0
    elseif inst:IsA("Folder") then
        for _, d in ipairs(inst:GetDescendants()) do
            if isRainInstance(d) then
                applyNoRainTo(d)
            end
        end
    end
end

local function restoreRainFor(inst)
    local saved = trackedRain[inst]
    if not saved then return end
    if inst:IsA("ParticleEmitter") then
        inst.Rate = saved.Rate
        inst.Enabled = saved.Enabled
    elseif inst:IsA("Trail") or inst:IsA("Beam") then
        inst.Enabled = saved.Enabled
    elseif inst:IsA("Sound") then
        inst.Volume = saved.Volume
        if saved.Playing then inst.Playing = true end
    end
    trackedRain[inst] = nil
end

local function setNoRain(state)
    noRainOn = state
    if state then
        -- desativa existentes
        for _, d in ipairs(workspace:GetDescendants()) do
            if isRainInstance(d) then
                applyNoRainTo(d)
            end
        end
        -- caso especial: Workspace.Camera._RainEmitter
        local cam = workspace:FindFirstChild("Camera")
        if cam and cam:FindFirstChild("_RainEmitter") then
            applyNoRainTo(cam._RainEmitter)
        end

        rainCon = workspace.DescendantAdded:Connect(function(inst)
            if noRainOn and isRainInstance(inst) then
                applyNoRainTo(inst)
            end
        end)
    else
        if rainCon then rainCon:Disconnect() rainCon = nil end
        for inst, _ in pairs(trackedRain) do
            if inst and inst.Parent then
                restoreRainFor(inst)
            end
        end
        trackedRain = {}
    end
end

VisualsTab:CreateToggle({
    Name = "Remove Rain",
    CurrentValue = false,
    Flag = "NoRain",
    Callback = function(state)
        setNoRain(state)
    end
})


local Button = Tab:CreateButton({
   Name = "Button Example",
   Callback = function()
   -- The function that takes place when the button is pressed
   end,
})