--[[
    Brookhaven Prop Magnet Wings + UI for Delta Executor
    Features: Draggable UI, On/Off Toggle, Adjustable Radius TextBox, Prop Attraction.
]]

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local CoreGui = game:GetService("CoreGui")
local player = Players.LocalPlayer

-- ==========================================
-- ⚙️ BASE CONFIGURATION (Defaults)
-- ==========================================
local CONFIG = {
    AttractRadius = 150,         -- Default radius (can be changed in UI)
    StealGameProps = true,       -- Suck up unanchored game props
    PropSnapping = true,         -- Align stolen props perfectly

    SpawnFakeProps = true,       -- Spawn glowing neon base wings
    PropColor = Color3.fromRGB(150, 50, 255), -- Purple base color
    PropMaterial = Enum.Material.Neon,
    PropSize = Vector3.new(0.2, 3, 0.5),
    
    PropsPerWing = 12,           
    WingSpan = 6,                
    WingDrop = 2.5,              
    FanAngle = 60,               
    FlapSpeed = 6,               
    FlapWidth = 40,              
}

-- State Variables
local IsActive = false
_G.WingProps = { Left = {}, Right = {} }
local stolenProps = {} 

-- ==========================================
-- 🧹 CLEANUP OLD EXECUTIONS
-- ==========================================
if _G.WingConnection then _G.WingConnection:Disconnect() end
if _G.PropScanner then task.cancel(_G.PropScanner) end
if _G.WingProps then
    for _, prop in pairs(_G.WingProps.Left) do if prop then prop:Destroy() end end
    for _, prop in pairs(_G.WingProps.Right) do if prop then prop:Destroy() end end
end

-- Find safe UI parent (CoreGui hides it from game anti-cheats)
local UI_PARENT = pcall(function() return CoreGui.Name end) and CoreGui or player:WaitForChild("PlayerGui")
if UI_PARENT:FindFirstChild("PropWingGUI") then
    UI_PARENT.PropWingGUI:Destroy()
end

-- ==========================================
-- 🎨 CREATE USER INTERFACE (GUI)
-- ==========================================
local ScreenGui = Instance.new("ScreenGui")
ScreenGui.Name = "PropWingGUI"
ScreenGui.ResetOnSpawn = false
ScreenGui.Parent = UI_PARENT

local MainFrame = Instance.new("Frame")
MainFrame.Size = UDim2.new(0, 220, 0, 150)
MainFrame.Position = UDim2.new(0.5, -110, 0.8, -75)
MainFrame.BackgroundColor3 = Color3.fromRGB(30, 30, 35)
MainFrame.BorderSizePixel = 0
MainFrame.Parent = ScreenGui

local UICorner = Instance.new("UICorner")
UICorner.CornerRadius = UDim.new(0, 10)
UICorner.Parent = MainFrame

local Title = Instance.new("TextLabel")
Title.Size = UDim2.new(1, 0, 0, 30)
Title.BackgroundTransparency = 1
Title.Text = "🧲 Magnet Wings"
Title.TextColor3 = Color3.fromRGB(255, 255, 255)
Title.Font = Enum.Font.GothamBold
Title.TextSize = 16
Title.Parent = MainFrame

local ToggleBtn = Instance.new("TextButton")
ToggleBtn.Size = UDim2.new(0.8, 0, 0, 40)
ToggleBtn.Position = UDim2.new(0.1, 0, 0, 40)
ToggleBtn.BackgroundColor3 = Color3.fromRGB(200, 50, 50)
ToggleBtn.Text = "Wings: OFF"
ToggleBtn.TextColor3 = Color3.fromRGB(255, 255, 255)
ToggleBtn.Font = Enum.Font.GothamBold
ToggleBtn.TextSize = 18
ToggleBtn.Parent = MainFrame

local BtnCorner = Instance.new("UICorner")
BtnCorner.CornerRadius = UDim.new(0, 6)
BtnCorner.Parent = ToggleBtn

local RadiusLabel = Instance.new("TextLabel")
RadiusLabel.Size = UDim2.new(0.5, 0, 0, 30)
RadiusLabel.Position = UDim2.new(0.1, 0, 0, 95)
RadiusLabel.BackgroundTransparency = 1
RadiusLabel.Text = "Radius:"
RadiusLabel.TextColor3 = Color3.fromRGB(200, 200, 200)
RadiusLabel.Font = Enum.Font.Gotham
RadiusLabel.TextSize = 14
RadiusLabel.TextXAlignment = Enum.TextXAlignment.Left
RadiusLabel.Parent = MainFrame

local RadiusBox = Instance.new("TextBox")
RadiusBox.Size = UDim2.new(0.3, 0, 0, 30)
RadiusBox.Position = UDim2.new(0.6, 0, 0, 95)
RadiusBox.BackgroundColor3 = Color3.fromRGB(50, 50, 55)
RadiusBox.Text = tostring(CONFIG.AttractRadius)
RadiusBox.TextColor3 = Color3.fromRGB(255, 255, 255)
RadiusBox.Font = Enum.Font.GothamBold
RadiusBox.TextSize = 14
RadiusBox.Parent = MainFrame

local BoxCorner = Instance.new("UICorner")
BoxCorner.CornerRadius = UDim.new(0, 4)
BoxCorner.Parent = RadiusBox

-- UI Dragging Logic
local dragging, dragInput, dragStart, startPos
MainFrame.InputBegan:Connect(function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
        dragging = true
        dragStart = input.Position
        startPos = MainFrame.Position
        input.Changed:Connect(function()
            if input.UserInputState == Enum.UserInputState.End then dragging = false end
        end)
    end
end)
MainFrame.InputChanged:Connect(function(input)
    if input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch then dragInput = input end
end)
UserInputService.InputChanged:Connect(function(input)
    if input == dragInput and dragging then
        local delta = input.Position - dragStart
        MainFrame.Position = UDim2.new(startPos.X.Scale, startPos.X.Offset + delta.X, startPos.Y.Scale, startPos.Y.Offset + delta.Y)
    end
end)

-- ==========================================
-- 🛠️ WING LOGIC & FUNCTIONS
-- ==========================================
local function createFakeWings()
    local function makeProp()
        local part = Instance.new("Part")
        part.Size = CONFIG.PropSize
        part.Anchored = true
        part.CanCollide = false
        part.Locked = true
        part.Massless = true
        part.Color = CONFIG.PropColor
        part.Material = CONFIG.PropMaterial
        part.Parent = workspace
        return part
    end

    _G.WingProps = { Left = {}, Right = {} }
    if CONFIG.SpawnFakeProps then
        for i = 1, CONFIG.PropsPerWing do
            table.insert(_G.WingProps.Left, makeProp())
            table.insert(_G.WingProps.Right, makeProp())
        end
    end
end

local function destroyWingsAndRelease()
    -- Destroy fake wings
    for _, prop in ipairs(_G.WingProps.Left) do if prop then prop:Destroy() end end
    for _, prop in ipairs(_G.WingProps.Right) do if prop then prop:Destroy() end end
    _G.WingProps = { Left = {}, Right = {} }
    
    -- Drop stolen game props
    for _, prop in ipairs(stolenProps) do
        if prop and prop.Parent then
            pcall(function() prop.CanCollide = true end)
        end
    end
    stolenProps = {}
end

-- ==========================================
-- 🎮 UI BUTTON EVENT LISTENERS
-- ==========================================
ToggleBtn.MouseButton1Click:Connect(function()
    IsActive = not IsActive
    if IsActive then
        ToggleBtn.Text = "Wings: ON"
        ToggleBtn.BackgroundColor3 = Color3.fromRGB(50, 200, 50)
        createFakeWings()
    else
        ToggleBtn.Text = "Wings: OFF"
        ToggleBtn.BackgroundColor3 = Color3.fromRGB(200, 50, 50)
        destroyWingsAndRelease()
    end
end)

RadiusBox.FocusLost:Connect(function()
    local newRadius = tonumber(RadiusBox.Text)
    if newRadius then
        -- Keep the radius between 10 and 1000 so the game doesn't break
        CONFIG.AttractRadius = math.clamp(newRadius, 10, 1000) 
        RadiusBox.Text = tostring(CONFIG.AttractRadius)
    else
        RadiusBox.Text = tostring(CONFIG.AttractRadius) -- Reset if user types text instead of a number
    end
end)

-- ==========================================
-- 🧲 PROP SCANNER LOOP
-- ==========================================
_G.PropScanner = task.spawn(function()
    while task.wait(0.2) do -- Fast scan
        if not IsActive then continue end
        
        local char = player.Character
        if char and char:FindFirstChild("HumanoidRootPart") then
            local hrp = char.HumanoidRootPart
            
            for _, part in ipairs(workspace:GetDescendants()) do
                if part:IsA("BasePart") and not part.Anchored and not part:IsDescendantOf(char) then
                    -- Check if inside user-defined radius
                    if (part.Position - hrp.Position).Magnitude <= CONFIG.AttractRadius then
                        if not table.find(stolenProps, part) then
                            table.insert(stolenProps, part)
                            pcall(function() part.CanCollide = false end)
                        end
                    end
                end
            end
        end
        
        -- Clean up lost props
        for i = #stolenProps, 1, -1 do
            if not stolenProps[i] or not stolenProps[i].Parent then
                table.remove(stolenProps, i)
            end
        end
    end
end)

-- ==========================================
-- 🔄 WING ANIMATION LOOP
-- ==========================================
local tickCount = 0

_G.WingConnection = RunService.Heartbeat:Connect(function(deltaTime)
    if not IsActive then return end
    
    local character = player.Character
    if not character or not character:FindFirstChild("HumanoidRootPart") then return end
    
    local hrp = character.HumanoidRootPart
    tickCount = tickCount + (deltaTime * CONFIG.FlapSpeed)
    local currentFlap = math.sin(tickCount) * math.rad(CONFIG.FlapWidth)
    
    local leftSlots, rightSlots = {}, {}
    
    -- Calculate slots
    local function calculateSlots(isLeft, slotTable)
        local sideMult = isLeft and -1 or 1
        local backHingeCFrame = hrp.CFrame * CFrame.new(sideMult * 0.5, 0.5, 0.6)
        local animatedHinge = backHingeCFrame * CFrame.Angles(0, sideMult * currentFlap, 0)
        
        for i = 1, CONFIG.PropsPerWing do
            local progress = (i - 1) / (CONFIG.PropsPerWing - 1)
            if progress ~= progress then progress = 0 end 
            
            local targetCFrame = animatedHinge 
                * CFrame.new(sideMult * (progress * CONFIG.WingSpan), -(progress * CONFIG.WingDrop), 0) 
                * CFrame.Angles(math.rad(15), 0, sideMult * math.rad(CONFIG.FanAngle) * progress)
                
            table.insert(slotTable, targetCFrame)
        end
    end

    calculateSlots(true, leftSlots)
    calculateSlots(false, rightSlots)

    -- Place fake props
    if CONFIG.SpawnFakeProps then
        for i, prop in ipairs(_G.WingProps.Left) do prop.CFrame = leftSlots[i] end
        for i, prop in ipairs(_G.WingProps.Right) do prop.CFrame = rightSlots[i] end
    end

    -- Magnetize game props
    if CONFIG.StealGameProps and #stolenProps > 0 then
        local totalSlots = CONFIG.PropsPerWing
        for i, gamePart in ipairs(stolenProps) do
            local slotArray = (i % 2 == 0) and leftSlots or rightSlots
            local slotIndex = (math.floor(i / 2) % totalSlots) + 1
            local targetCFrame = slotArray[slotIndex]
            
            pcall(function()
                if not CONFIG.PropSnapping then
                    targetCFrame = targetCFrame * CFrame.Angles(math.rad(math.random(-20, 20)), math.rad(math.random(-20, 20)), 0)
                end
                gamePart.CFrame = targetCFrame
                gamePart.Velocity = Vector3.new(0,0,0)
                gamePart.RotVelocity = Vector3.new(0,0,0)
            end)
        end
    end
end)