Super Op script made by me that i gave up on

--// Town V1 — WindUI Executor Script (Enhanced)
--// Features: ESP (with presets + health bar), Rainbow mode, Aimbot (wallcheck, FOV circle, keybind), Player, Settings

local WindUI = loadstring(game:HttpGet("https://github.com/Footagesus/WindUI/releases/latest/download/main.lua"))()

local Window = WindUI:CreateWindow({
    Title = "Town V1",
    Icon = "rbxassetid://129260712070622",
    Author = "Made by Alex",
    Folder = "MyExecutor",
    Size = UDim2.fromOffset(580, 460),
    Transparent = true,
    Theme = "Dark",
    SideBarWidth = 200,
})

Window:EditOpenButton({
    Title = "Open Menu",
    Icon = "monitor",
    CornerRadius = UDim.new(0, 16),
    StrokeThickness = 2,
    Draggable = true,
})

local Tabs = {
    Main     = Window:Tab({ Title = "Main", Icon = "home" }),
    Player   = Window:Tab({ Title = "Player", Icon = "user" }),
    ESP      = Window:Tab({ Title = "ESP", Icon = "eye" }),
    Aimbot   = Window:Tab({ Title = "Aimbot", Icon = "crosshair" }),
    Misc     = Window:Tab({ Title = "Misc", Icon = "wrench" }),
    PlotCopy = Window:Tab({ Title = "PlotCopy", Icon = "copy" }),
    Settings = Window:Tab({ Title = "Settings", Icon = "settings" }),
}

local Players           = game:GetService("Players")
local RunService        = game:GetService("RunService")
local UserInputService  = game:GetService("UserInputService")
local LocalPlayer       = Players.LocalPlayer
local Camera            = workspace.CurrentCamera

--============================================================
--// RAINBOW ENGINE (shared)
--============================================================
local Rainbow = {
    Hue = 0,
    Speed = 0.4, -- hue cycles per second
    Color = Color3.fromRGB(255, 0, 0),
}

RunService.RenderStepped:Connect(function(dt)
    Rainbow.Hue = (Rainbow.Hue + dt * Rainbow.Speed) % 1
    Rainbow.Color = Color3.fromHSV(Rainbow.Hue, 1, 1)
end)

--============================================================
--// MAIN TAB
--============================================================
Tabs.Main:Section({ Title = "Welcome" })
Tabs.Main:Paragraph({
    Title = "Info",
    Desc = "Town V1 — full-featured ESP + Aimbot template. Configure everything from the tabs on the left.",
})
Tabs.Main:Button({
    Title = "Notify Me",
    Desc = "Show a test notification",
    Callback = function()
        WindUI:Notify({
            Title = "Hello!",
            Content = "WindUI is working correctly.",
            Duration = 5,
            Icon = "check",
        })
    end,
})

--============================================================
--// PLAYER TAB
--============================================================
Tabs.Player:Section({ Title = "Movement" })
local walkSpeed = 16
Tabs.Player:Slider({
    Title = "WalkSpeed",
    Value = { Min = 16, Max = 500, Default = 16 },
    Callback = function(value)
        walkSpeed = value
        local char = LocalPlayer.Character
        if char and char:FindFirstChildOfClass("Humanoid") then
            char:FindFirstChildOfClass("Humanoid").WalkSpeed = value
        end
    end,
})
local jumpPower = 50
Tabs.Player:Slider({
    Title = "JumpPower",
    Value = { Min = 50, Max = 500, Default = 50 },
    Callback = function(value)
        jumpPower = value
        local char = LocalPlayer.Character
        if char and char:FindFirstChildOfClass("Humanoid") then
            local hum = char:FindFirstChildOfClass("Humanoid")
            hum.UseJumpPower = true
            hum.JumpPower = value
        end
    end,
})
Tabs.Player:Toggle({
    Title = "Infinite Jump",
    Default = false,
    Callback = function(state) _G.InfiniteJump = state end,
})
UserInputService.JumpRequest:Connect(function()
    if _G.InfiniteJump then
        local char = LocalPlayer.Character
        if char and char:FindFirstChildOfClass("Humanoid") then
            char:FindFirstChildOfClass("Humanoid"):ChangeState(Enum.HumanoidStateType.Jumping)
        end
    end
end)
Tabs.Player:Button({
    Title = "Reset Character",
    Callback = function()
        if LocalPlayer.Character then LocalPlayer.Character:BreakJoints() end
    end,
})

--============================================================
--// ESP SYSTEM
--============================================================
local ESP = {
    Enabled     = false,
    Box         = false,
    Tracers     = false,
    Charms      = false,
    Health      = false,   -- text health
    HealthBar   = false,   -- graphical bar
    HealthBarSide = "Left", -- "Left" | "Right" | "Top" | "Bottom"
    Name        = false,
    Distance    = false,
    Rainbow     = false,    -- rainbow all ESP visuals
    Color       = Color3.fromRGB(0, 170, 255),
    TeamCheck   = false,
    TracerOrigin = "Bottom", -- "Bottom" | "Center" | "Mouse" | "Top"
}

-- Returns the active ESP color (rainbow overrides static)
local function espColor()
    if ESP.Rainbow then return Rainbow.Color end
    return ESP.Color
end

local ESPObjects = {} -- [player] = { drawings..., highlight }

local function newDrawing(class, props)
    local d = Drawing.new(class)
    for k, v in pairs(props) do d[k] = v end
    return d
end

local function createESP(player)
    if ESPObjects[player] then return end
    local objs = {}

    objs.Box = newDrawing("Square", {
        Thickness = 1, Filled = false, Color = ESP.Color, Transparency = 1, Visible = false,
    })
    objs.Tracer = newDrawing("Line", {
        Thickness = 1, Color = ESP.Color, Transparency = 1, Visible = false,
    })
    objs.Name = newDrawing("Text", {
        Size = 14, Center = true, Outline = true, Color = ESP.Color, Visible = false,
    })
    objs.Distance = newDrawing("Text", {
        Size = 13, Center = true, Outline = true, Color = ESP.Color, Visible = false,
    })
    objs.Health = newDrawing("Text", {
        Size = 13, Center = true, Outline = true, Color = Color3.fromRGB(0, 255, 0), Visible = false,
    })

    -- Health bar (two squares: background + fill)
    objs.HealthBarBG = newDrawing("Square", {
        Thickness = 1, Filled = true, Color = Color3.fromRGB(0, 0, 0), Transparency = 0.5, Visible = false,
    })
    objs.HealthBarFill = newDrawing("Square", {
        Thickness = 1, Filled = true, Color = Color3.fromRGB(0, 255, 0), Transparency = 1, Visible = false,
    })

    -- Charms = Highlight (body outline)
    local highlight = Instance.new("Highlight")
    highlight.Name = "ESP_Charm"
    highlight.FillTransparency = 0.5
    highlight.OutlineTransparency = 0
    highlight.FillColor = ESP.Color
    highlight.OutlineColor = ESP.Color
    highlight.Enabled = false
    highlight.Parent = game:GetService("CoreGui")
    objs.Highlight = highlight

    ESPObjects[player] = objs
end

local function removeESP(player)
    local objs = ESPObjects[player]
    if not objs then return end
    for _, obj in pairs(objs) do
        pcall(function() obj:Remove() end)
        pcall(function() obj:Destroy() end)
    end
    ESPObjects[player] = nil
end

local function hideObjs(objs)
    objs.Box.Visible = false
    objs.Tracer.Visible = false
    objs.Name.Visible = false
    objs.Distance.Visible = false
    objs.Health.Visible = false
    objs.HealthBarBG.Visible = false
    objs.HealthBarFill.Visible = false
    objs.Highlight.Enabled = false
end

RunService.RenderStepped:Connect(function()
    local col = espColor()
    for _, player in ipairs(Players:GetPlayers()) do
        if player ~= LocalPlayer then
            local objs = ESPObjects[player]
            if not objs then continue end

            local char = player.Character
            local hrp  = char and char:FindFirstChild("HumanoidRootPart")
            local head = char and char:FindFirstChild("Head")
            local hum  = char and char:FindFirstChildOfClass("Humanoid")

            if not ESP.Enabled or not char or not hrp or not hum or hum.Health <= 0 then
                hideObjs(objs); continue
            end
            if ESP.TeamCheck and player.Team == LocalPlayer.Team then
                hideObjs(objs); continue
            end

            local pos, onScreen = Camera:WorldToViewportPoint(hrp.Position)
            if not onScreen then hideObjs(objs); continue end

            local topPos    = Camera:WorldToViewportPoint((head and head.Position or hrp.Position) + Vector3.new(0, 1.5, 0))
            local bottomPos = Camera:WorldToViewportPoint(hrp.Position - Vector3.new(0, 3, 0))
            local height = math.abs(topPos.Y - bottomPos.Y)
            local width  = height / 2
            local boxX = pos.X - width / 2

            -- Box
            if ESP.Box then
                objs.Box.Size = Vector2.new(width, height)
                objs.Box.Position = Vector2.new(boxX, topPos.Y)
                objs.Box.Color = col
                objs.Box.Visible = true
            else objs.Box.Visible = false end

            -- Tracer (origin preset)
            if ESP.Tracers then
                local from
                local vp = Camera.ViewportSize
                if ESP.TracerOrigin == "Bottom" then
                    from = Vector2.new(vp.X / 2, vp.Y)
                elseif ESP.TracerOrigin == "Top" then
                    from = Vector2.new(vp.X / 2, 0)
                elseif ESP.TracerOrigin == "Center" then
                    from = Vector2.new(vp.X / 2, vp.Y / 2)
                elseif ESP.TracerOrigin == "Mouse" then
                    local m = UserInputService:GetMouseLocation()
                    from = Vector2.new(m.X, m.Y)
                else
                    from = Vector2.new(vp.X / 2, vp.Y)
                end
                objs.Tracer.From = from
                objs.Tracer.To = Vector2.new(pos.X, bottomPos.Y)
                objs.Tracer.Color = col
                objs.Tracer.Visible = true
            else objs.Tracer.Visible = false end

            -- Charms (Highlight)
            if ESP.Charms then
                objs.Highlight.Adornee = char
                objs.Highlight.FillColor = col
                objs.Highlight.OutlineColor = col
                objs.Highlight.Enabled = true
            else objs.Highlight.Enabled = false end

            -- Name
            if ESP.Name then
                objs.Name.Text = player.DisplayName or player.Name
                objs.Name.Position = Vector2.new(pos.X, topPos.Y - 16)
                objs.Name.Color = col
                objs.Name.Visible = true
            else objs.Name.Visible = false end

            -- Distance
            if ESP.Distance then
                local dist = (Camera.CFrame.Position - hrp.Position).Magnitude
                objs.Distance.Text = string.format("%.0fm", dist)
                objs.Distance.Position = Vector2.new(pos.X, bottomPos.Y + 2)
                objs.Distance.Color = col
                objs.Distance.Visible = true
            else objs.Distance.Visible = false end

            -- Health text
            if ESP.Health then
                objs.Health.Text = string.format("HP: %.0f", hum.Health)
                objs.Health.Position = Vector2.new(pos.X, bottomPos.Y + (ESP.Distance and 16 or 2))
                local ratio = hum.Health / math.max(hum.MaxHealth, 1)
                objs.Health.Color = Color3.fromRGB(255 * (1 - ratio), 255 * ratio, 0)
                objs.Health.Visible = true
            else objs.Health.Visible = false end

            -- Health BAR (preset side: Left/Right/Top/Bottom)
            if ESP.HealthBar then
                local ratio = math.clamp(hum.Health / math.max(hum.MaxHealth, 1), 0, 1)
                local barColor = Color3.fromRGB(255 * (1 - ratio), 255 * ratio, 0)
                local side = ESP.HealthBarSide

                if side == "Left" or side == "Right" then
                    local barW = 3
                    local barX = (side == "Left") and (boxX - barW - 3) or (boxX + width + 3)
                    objs.HealthBarBG.Size = Vector2.new(barW, height)
                    objs.HealthBarBG.Position = Vector2.new(barX, topPos.Y)
                    local fillH = height * ratio
                    objs.HealthBarFill.Size = Vector2.new(barW, fillH)
                    -- fill grows from bottom up
                    objs.HealthBarFill.Position = Vector2.new(barX, topPos.Y + (height - fillH))
                else -- Top or Bottom => horizontal bar
                    local barH = 3
                    local barY = (side == "Top") and (topPos.Y - barH - 3) or (topPos.Y + height + 3)
                    objs.HealthBarBG.Size = Vector2.new(width, barH)
                    objs.HealthBarBG.Position = Vector2.new(boxX, barY)
                    local fillW = width * ratio
                    objs.HealthBarFill.Size = Vector2.new(fillW, barH)
                    objs.HealthBarFill.Position = Vector2.new(boxX, barY)
                end
                objs.HealthBarFill.Color = barColor
                objs.HealthBarBG.Visible = true
                objs.HealthBarFill.Visible = true
            else
                objs.HealthBarBG.Visible = false
                objs.HealthBarFill.Visible = false
            end
        end
    end
end)

for _, player in ipairs(Players:GetPlayers()) do
    if player ~= LocalPlayer then createESP(player) end
end
Players.PlayerAdded:Connect(function(player)
    if player ~= LocalPlayer then createESP(player) end
end)
Players.PlayerRemoving:Connect(removeESP)

--============================================================
--// ESP TAB UI
--============================================================
Tabs.ESP:Section({ Title = "ESP Toggles" })
Tabs.ESP:Toggle({ Title = "Enable ESP", Desc = "Master switch for all ESP features", Default = false,
    Callback = function(s) ESP.Enabled = s end })
Tabs.ESP:Toggle({ Title = "Box", Desc = "Draw a 2D box around players", Default = false,
    Callback = function(s) ESP.Box = s end })
Tabs.ESP:Toggle({ Title = "Charms (Body Outline)", Desc = "Highlight the player's body", Default = false,
    Callback = function(s) ESP.Charms = s end })
Tabs.ESP:Toggle({ Title = "Tracers", Desc = "Draw lines to players", Default = false,
    Callback = function(s) ESP.Tracers = s end })
Tabs.ESP:Toggle({ Title = "Name", Desc = "Show player names", Default = false,
    Callback = function(s) ESP.Name = s end })
Tabs.ESP:Toggle({ Title = "Distance", Desc = "Show distance to players", Default = false,
    Callback = function(s) ESP.Distance = s end })
Tabs.ESP:Toggle({ Title = "Team Check", Desc = "Don't show ESP for teammates", Default = false,
    Callback = function(s) ESP.TeamCheck = s end })

Tabs.ESP:Section({ Title = "Health Presets" })
Tabs.ESP:Toggle({ Title = "Health (Text)", Desc = "Show numeric health", Default = false,
    Callback = function(s) ESP.Health = s end })
Tabs.ESP:Toggle({ Title = "Health Bar", Desc = "Show a graphical health bar", Default = false,
    Callback = function(s) ESP.HealthBar = s end })
Tabs.ESP:Dropdown({
    Title = "Health Bar Position",
    Desc = "Where the bar sits relative to the box",
    Values = { "Left", "Right", "Top", "Bottom" },
    Value = "Left",
    Callback = function(v) ESP.HealthBarSide = v end,
})

Tabs.ESP:Section({ Title = "Tracer Presets" })
Tabs.ESP:Dropdown({
    Title = "Tracer Origin",
    Desc = "Where tracer lines start from",
    Values = { "Bottom", "Center", "Top", "Mouse" },
    Value = "Bottom",
    Callback = function(v) ESP.TracerOrigin = v end,
})

Tabs.ESP:Section({ Title = "Color Customization" })
Tabs.ESP:Toggle({
    Title = "Rainbow ESP",
    Desc = "Cycle rainbow colors on all ESP visuals",
    Default = false,
    Callback = function(s) ESP.Rainbow = s end,
})
Tabs.ESP:Colorpicker({
    Title = "ESP Color",
    Desc = "Static color (ignored while Rainbow is on)",
    Default = ESP.Color,
    Callback = function(c) ESP.Color = c end,
})

--============================================================
--// AIMBOT SYSTEM
--============================================================
local Aimbot = {
    Enabled     = false,
    TeamCheck   = false,
    WallCheck   = false,
    Smoothness  = 0.15,        -- 0 = instant, higher = smoother
    TargetPart  = "Head",      -- "Head" | "HumanoidRootPart" | "Torso"
    -- FOV
    FOVEnabled  = true,
    FOVShow     = true,
    FOVRadius   = 120,
    FOVRainbow  = false,
    FOVColor    = Color3.fromRGB(255, 255, 255),
    -- Keybind
    Key         = Enum.UserInputType.MouseButton2, -- default right mouse
    Mode        = "Hold",      -- "Hold" | "Toggle"
    Active      = false,       -- current active state
}

-- FOV circle drawing
local FOVCircle = newDrawing("Circle", {
    Thickness = 1,
    NumSides = 64,
    Radius = Aimbot.FOVRadius,
    Filled = false,
    Color = Aimbot.FOVColor,
    Transparency = 1,
    Visible = false,
})

local function aimColor()
    if Aimbot.FOVRainbow then return Rainbow.Color end
    return Aimbot.FOVColor
end

local function getTargetPart(char)
    if not char then return nil end
    if Aimbot.TargetPart == "Head" then
        return char:FindFirstChild("Head")
    elseif Aimbot.TargetPart == "Torso" then
        return char:FindFirstChild("UpperTorso") or char:FindFirstChild("Torso") or char:FindFirstChild("HumanoidRootPart")
    else
        return char:FindFirstChild("HumanoidRootPart")
    end
end

-- Wall check: raycast from camera to target, ensure nothing blocks
local function isVisible(targetPart, char)
    if not Aimbot.WallCheck then return true end
    local origin = Camera.CFrame.Position
    local dir = (targetPart.Position - origin)
    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Exclude
    params.FilterDescendantsInstances = { LocalPlayer.Character, Camera }
    local result = workspace:Raycast(origin, dir, params)
    if not result then return true end
    -- if the hit instance is part of the target char, it's visible
    return result.Instance:IsDescendantOf(char)
end

-- Find best target within FOV
local function getClosestTarget()
    local best, bestDist = nil, math.huge
    local center = Camera.ViewportSize / 2
    if Aimbot.FOVEnabled then center = Vector2.new(center.X, center.Y) end

    for _, player in ipairs(Players:GetPlayers()) do
        if player ~= LocalPlayer then
            if Aimbot.TeamCheck and player.Team == LocalPlayer.Team then continue end
            local char = player.Character
            local hum = char and char:FindFirstChildOfClass("Humanoid")
            if not char or not hum or hum.Health <= 0 then continue end
            local part = getTargetPart(char)
            if not part then continue end

            local screenPos, onScreen = Camera:WorldToViewportPoint(part.Position)
            if not onScreen then continue end

            local dist = (Vector2.new(screenPos.X, screenPos.Y) - center).Magnitude
            if Aimbot.FOVEnabled and dist > Aimbot.FOVRadius then continue end

            if dist < bestDist then
                if isVisible(part, char) then
                    best, bestDist = part, dist
                end
            end
        end
    end
    return best
end

-- Keybind handling
UserInputService.InputBegan:Connect(function(input, gpe)
    if gpe then return end
    local matched = false
    if Aimbot.Key == input.UserInputType then matched = true end
    if input.KeyCode ~= Enum.KeyCode.Unknown and Aimbot.Key == input.KeyCode then matched = true end
    if matched then
        if Aimbot.Mode == "Hold" then
            Aimbot.Active = true
        else -- Toggle
            Aimbot.Active = not Aimbot.Active
        end
    end
end)

UserInputService.InputEnded:Connect(function(input)
    local matched = false
    if Aimbot.Key == input.UserInputType then matched = true end
    if input.KeyCode ~= Enum.KeyCode.Unknown and Aimbot.Key == input.KeyCode then matched = true end
    if matched and Aimbot.Mode == "Hold" then
        Aimbot.Active = false
    end
end)

-- Aimbot + FOV render loop
RunService.RenderStepped:Connect(function()
    -- FOV circle
    if Aimbot.FOVEnabled and Aimbot.FOVShow then
        local m = UserInputService:GetMouseLocation()
        FOVCircle.Position = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y / 2)
        FOVCircle.Radius = Aimbot.FOVRadius
        FOVCircle.Color = aimColor()
        FOVCircle.Visible = true
    else
        FOVCircle.Visible = false
    end

    -- Aiming
    if Aimbot.Enabled and Aimbot.Active then
        local target = getClosestTarget()
        if target then
            local screenPos = Camera:WorldToViewportPoint(target.Position)
            local targetScreen = Vector2.new(screenPos.X, screenPos.Y)
            local current = UserInputService:GetMouseLocation()
            -- smoothing via mousemoverel (requires exploit support)
            local delta = targetScreen - current
            if Aimbot.Smoothness > 0 then
                delta = delta * (1 - Aimbot.Smoothness)
            end
            pcall(function()
                mousemoverel(delta.X, delta.Y)
            end)
        end
    end
end)

--============================================================
--// AIMBOT TAB UI
--============================================================
Tabs.Aimbot:Section({ Title = "Aimbot" })
Tabs.Aimbot:Toggle({ Title = "Enable Aimbot", Desc = "Master switch", Default = false,
    Callback = function(s) Aimbot.Enabled = s end })
Tabs.Aimbot:Toggle({ Title = "Team Check", Desc = "Ignore teammates", Default = false,
    Callback = function(s) Aimbot.TeamCheck = s end })
Tabs.Aimbot:Toggle({ Title = "Wall Check", Desc = "Only target visible players", Default = false,
    Callback = function(s) Aimbot.WallCheck = s end })
Tabs.Aimbot:Dropdown({
    Title = "Target Part",
    Values = { "Head", "Torso", "HumanoidRootPart" },
    Value = "Head",
    Callback = function(v) Aimbot.TargetPart = v end,
})
Tabs.Aimbot:Slider({
    Title = "Smoothness",
    Desc = "0 = instant snap, higher = smoother",
    Value = { Min = 0, Max = 95, Default = 15 },
    Callback = function(v) Aimbot.Smoothness = v / 100 end,
})

Tabs.Aimbot:Section({ Title = "FOV" })
Tabs.Aimbot:Toggle({ Title = "FOV Enabled", Desc = "Restrict aim to FOV circle", Default = true,
    Callback = function(s) Aimbot.FOVEnabled = s end })
Tabs.Aimbot:Toggle({ Title = "Show FOV Circle", Desc = "Draw the FOV circle on screen", Default = true,
    Callback = function(s) Aimbot.FOVShow = s end })
Tabs.Aimbot:Slider({
    Title = "FOV Radius",
    Desc = "Size of the FOV circle",
    Value = { Min = 20, Max = 600, Default = 120 },
    Callback = function(v) Aimbot.FOVRadius = v end,
})
Tabs.Aimbot:Toggle({ Title = "Rainbow FOV Circle", Desc = "Cycle rainbow colors on the FOV circle", Default = false,
    Callback = function(s) Aimbot.FOVRainbow = s end })
Tabs.Aimbot:Colorpicker({
    Title = "FOV Color",
    Desc = "Static color (ignored while rainbow is on)",
    Default = Aimbot.FOVColor,
    Callback = function(c) Aimbot.FOVColor = c end,
})

Tabs.Aimbot:Section({ Title = "Keybind" })
Tabs.Aimbot:Dropdown({
    Title = "Activation Mode",
    Desc = "Hold to aim, or Toggle on/off",
    Values = { "Hold", "Toggle" },
    Value = "Hold",
    Callback = function(v) Aimbot.Mode = v; Aimbot.Active = false end,
})
Tabs.Aimbot:Keybind({
    Title = "Aimbot Key",
    Desc = "Key/mouse button to activate aimbot",
    Value = "MouseButton2",
    Callback = function(key)
        -- WindUI returns a key string; map common values
        if key == "MouseButton1" then
            Aimbot.Key = Enum.UserInputType.MouseButton1
        elseif key == "MouseButton2" then
            Aimbot.Key = Enum.UserInputType.MouseButton2
        elseif key == "MouseButton3" then
            Aimbot.Key = Enum.UserInputType.MouseButton3
        else
            local ok, code = pcall(function() return Enum.KeyCode[key] end)
            if ok and code then Aimbot.Key = code end
        end
    end,
})

Tabs.Aimbot:Section({ Title = "Rainbow" })
Tabs.Aimbot:Slider({
    Title = "Rainbow Speed",
    Desc = "Global rainbow cycle speed (affects ESP + FOV)",
    Value = { Min = 1, Max = 30, Default = 4 },
    Callback = function(v) Rainbow.Speed = v / 10 end,
})

--============================================================
--// MISC SYSTEM (Noclip / Fly / Fullbright)
--============================================================
local Misc = {
    Noclip      = false,
    Fly         = false,
    FlySpeed    = 50,
    Fullbright  = false,
}

-- Cache which parts we've set CanCollide=false on so we can restore
local noclipParts = {}
-- Anti-teleport tracking: the CFrame WE control, re-asserted every frame.
local noclipCF = nil       -- our authoritative position while noclipping
local TELEPORT_THRESHOLD = 6  -- studs; jumps bigger than this = pushback

--// NOCLIP (anti-teleport-back)
-- Town doesn't just block you with collisions -- it TELEPORTS you back after
-- it sees your character inside restricted geometry. So disabling CanCollide
-- alone isn't enough. This version ALSO takes authority over your position:
--   1. CanCollide=false every Stepped (pre-physics) so nothing pushes you.
--   2. We drive movement ourselves via CFrame from your input each frame.
--   3. If the game snaps your HRP backward (a pushback), we detect the jump
--      and immediately re-assert OUR position, cancelling the rubber-band.
-- NOTE: this only wins if the reset is client-side. If Town resets you from
-- the SERVER, you'll see jitter -- that can't be fully beaten from the client.
local function setNoclip(char)
    if not char then return end
    for _, part in ipairs(char:GetDescendants()) do
        if part:IsA("BasePart") and part.CanCollide then
            noclipParts[part] = true
            part.CanCollide = false
        end
    end
end

local function restoreNoclip()
    for part in pairs(noclipParts) do
        if part and part.Parent then
            pcall(function() part.CanCollide = true end)
        end
    end
    noclipParts = {}
    noclipCF = nil
end

-- Pre-physics: kill collisions so we never physically resolve into a wall.
RunService.Stepped:Connect(function()
    if Misc.Noclip then
        setNoclip(LocalPlayer.Character)
    end
end)

-- Post-anticheat: RenderStepped runs after the game's local reset logic, so
-- re-asserting here overwrites any client-side pushback the same frame.
RunService.RenderStepped:Connect(function(dt)
    if not Misc.Noclip then noclipCF = nil; return end

    local char = LocalPlayer.Character
    local hrp  = char and char:FindFirstChild("HumanoidRootPart")
    local hum  = char and char:FindFirstChildOfClass("Humanoid")
    if not hrp or not hum then noclipCF = nil; return end

    -- initialise our authoritative CFrame the first frame
    if not noclipCF then noclipCF = hrp.CFrame end

    -- detect a pushback: the game moved us far from where WE last put us
    local drift = (hrp.Position - noclipCF.Position).Magnitude
    if drift > TELEPORT_THRESHOLD then
        -- game teleported us back -> reclaim our position
        hrp.CFrame = noclipCF
        hrp.AssemblyLinearVelocity = Vector3.zero
    end

    -- move using YOUR input (Humanoid MoveDirection = WASD relative to camera)
    local moveDir = hum.MoveDirection
    local speed = (hum.WalkSpeed > 0 and hum.WalkSpeed or 16)
    if moveDir.Magnitude > 0 then
        -- advance our position, keep current rotation
        local rot = hrp.CFrame - hrp.CFrame.Position
        local newPos = noclipCF.Position + moveDir * speed * dt
        noclipCF = CFrame.new(newPos) * rot
        hrp.CFrame = noclipCF
        hrp.AssemblyLinearVelocity = Vector3.zero
    else
        -- standing still: follow the character so gravity/jump still works,
        -- but hold against small pushbacks
        noclipCF = hrp.CFrame
    end
end)

--// FLY (velocity-based, safer than CFrame teleport vs kick detection)
-- Uses BodyVelocity/BodyGyro so the server sees smooth continuous movement
-- instead of large position deltas that trip "speed"/"teleport" flags.
local flyBV, flyBG
local flyConn

local function startFly()
    local char = LocalPlayer.Character
    local hrp = char and char:FindFirstChild("HumanoidRootPart")
    local hum = char and char:FindFirstChildOfClass("Humanoid")
    if not hrp then return end

    if hum then hum.PlatformStand = true end

    flyBV = Instance.new("BodyVelocity")
    flyBV.MaxForce = Vector3.new(9e9, 9e9, 9e9)
    flyBV.Velocity = Vector3.zero
    flyBV.Parent = hrp

    flyBG = Instance.new("BodyGyro")
    flyBG.MaxTorque = Vector3.new(9e9, 9e9, 9e9)
    flyBG.P = 9e4
    flyBG.CFrame = hrp.CFrame
    flyBG.Parent = hrp

    flyConn = RunService.RenderStepped:Connect(function()
        if not Misc.Fly then return end
        local cam = Camera.CFrame
        local move = Vector3.zero
        if UserInputService:IsKeyDown(Enum.KeyCode.W) then move += cam.LookVector end
        if UserInputService:IsKeyDown(Enum.KeyCode.S) then move -= cam.LookVector end
        if UserInputService:IsKeyDown(Enum.KeyCode.A) then move -= cam.RightVector end
        if UserInputService:IsKeyDown(Enum.KeyCode.D) then move += cam.RightVector end
        if UserInputService:IsKeyDown(Enum.KeyCode.Space) then move += Vector3.new(0, 1, 0) end
        if UserInputService:IsKeyDown(Enum.KeyCode.LeftControl) then move -= Vector3.new(0, 1, 0) end

        if flyBV then
            if move.Magnitude > 0 then
                flyBV.Velocity = move.Unit * Misc.FlySpeed
            else
                flyBV.Velocity = Vector3.zero
            end
        end
        if flyBG then flyBG.CFrame = cam end
    end)
end

local function stopFly()
    local char = LocalPlayer.Character
    local hum = char and char:FindFirstChildOfClass("Humanoid")
    if hum then hum.PlatformStand = false end
    if flyConn then flyConn:Disconnect(); flyConn = nil end
    if flyBV then flyBV:Destroy(); flyBV = nil end
    if flyBG then flyBG:Destroy(); flyBG = nil end
end

-- Rebuild fly/noclip refs on respawn
LocalPlayer.CharacterAdded:Connect(function()
    task.wait(0.5)
    noclipParts = {}
    if Misc.Fly then stopFly(); startFly() end
end)

--// FULLBRIGHT
local Lighting = game:GetService("Lighting")
local fbSaved = nil
local function setFullbright(on)
    if on then
        if not fbSaved then
            fbSaved = {
                Brightness  = Lighting.Brightness,
                ClockTime   = Lighting.ClockTime,
                FogEnd      = Lighting.FogEnd,
                GlobalShadows = Lighting.GlobalShadows,
                Ambient     = Lighting.Ambient,
                OutdoorAmbient = Lighting.OutdoorAmbient,
            }
        end
        Lighting.Brightness = 2
        Lighting.ClockTime = 14
        Lighting.FogEnd = 1e9
        Lighting.GlobalShadows = false
        Lighting.Ambient = Color3.fromRGB(178, 178, 178)
        Lighting.OutdoorAmbient = Color3.fromRGB(178, 178, 178)
    else
        if fbSaved then
            Lighting.Brightness = fbSaved.Brightness
            Lighting.ClockTime = fbSaved.ClockTime
            Lighting.FogEnd = fbSaved.FogEnd
            Lighting.GlobalShadows = fbSaved.GlobalShadows
            Lighting.Ambient = fbSaved.Ambient
            Lighting.OutdoorAmbient = fbSaved.OutdoorAmbient
        end
    end
end

--============================================================
--// MISC TAB UI
--============================================================
Tabs.Misc:Section({ Title = "Movement" })
Tabs.Misc:Toggle({
    Title = "Noclip",
    Desc = "Walk through walls (hardened vs Town anti-noclip rubber-band)",
    Default = false,
    Callback = function(state)
        Misc.Noclip = state
        if not state then restoreNoclip() end
    end,
})
Tabs.Misc:Toggle({
    Title = "Fly",
    Desc = "Velocity-based fly (WASD + Space/Ctrl). Smooth to avoid teleport flags.",
    Default = false,
    Callback = function(state)
        Misc.Fly = state
        if state then startFly() else stopFly() end
    end,
})
Tabs.Misc:Slider({
    Title = "Fly Speed",
    Desc = "How fast you fly",
    Value = { Min = 10, Max = 500, Default = 50 },
    Callback = function(v) Misc.FlySpeed = v end,
})

Tabs.Misc:Section({ Title = "Visual" })
Tabs.Misc:Toggle({
    Title = "Fullbright",
    Desc = "Force daytime lighting (removes darkness/night)",
    Default = false,
    Callback = function(state)
        Misc.Fullbright = state
        setFullbright(state)
    end,
})

--============================================================
--// PLOT COPY SYSTEM
--============================================================
-- Copying a plot in Town = re-firing Town's placement RemoteEvent for every
-- item on the target plot, using Town's own furniture data format.
-- Since that remote/format is internal to the game, this tab does it in 3 parts:
--   1) Remote Spy  -> discovers the exact placement remote + arg format.
--   2) Plot Scan   -> finds & serializes the target player's plot items.
--   3) Rebuild     -> fires the placement remote to recreate them on your plot.
-- Fill in PLACEMENT_CONFIG once the spy reveals the remote, and copy will run.

local HttpService     = game:GetService("HttpService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local PlotCopy = {
    Target      = nil,   -- Player object to copy from
    SpyLog      = {},    -- captured remote calls
    Spying      = false,
    LastScan    = {},    -- serialized items from last scan
    PlaceDelay  = 0.1,   -- seconds between placements (anti-kick throttle)
}

-------------------------------------------------------------
-- CONFIG: fill these in from what the Remote Spy shows you.
-- Example (yours will differ): the spy prints something like
--   [SPY] RemoteEvent  "PlaceItem"  args: {"chair", CFrame, Color3}
-- Then set:
--   PLACEMENT_CONFIG.RemotePath = {"ReplicatedStorage","Remotes","PlaceItem"}
--   PLACEMENT_CONFIG.Method     = "FireServer"
--   and adapt buildArgs() to match the captured argument order.
-------------------------------------------------------------
local PLACEMENT_CONFIG = {
    RemotePath = nil,      -- e.g. {"ReplicatedStorage","Remotes","PlaceFurniture"}
    Method     = "FireServer",
    -- Turn one serialized item into the arg list Town expects.
    buildArgs  = function(item)
        -- DEFAULT GUESS — adjust to captured format:
        -- return item.Id, item.CFrame, item.Color
        return item.Id, item.CFrame
    end,
}

local function resolvePath(path)
    local node = game
    for _, name in ipairs(path) do
        node = node:FindFirstChild(name)
        if not node then return nil end
    end
    return node
end

-------------------------------------------------------------
-- 1) REMOTE DISCOVERY
-- Town's anti-cheat kicks for "InvokeServer function hooks detected", so the
-- DEFAULT method here is HOOK-FREE: it reads the game's own client scripts to
-- find the FireServer/InvokeServer call that places furniture. Nothing on
-- FireServer/__namecall is ever modified, so there is no hook to detect.
--
-- A hardened metamethod hook is still provided as an optional fallback, but it
-- CAN be detected -- only use it on executors with strong metatable spoofing.
-------------------------------------------------------------

-- Executor capability probe
local canReadScripts = (getgc or getscripts) and (decompile or getscriptbytecode or getsource)
local KEYWORDS = { "place", "plot", "furniture", "build", "spawnitem", "object", "save", "load" }

-- HOOK-FREE: scan loaded scripts for the placement remote call.
local function discoverRemotesNoHook()
    PlotCopy.SpyLog = {}
    local scriptList = {}
    if getscripts then
        for _, s in ipairs(getscripts()) do scriptList[#scriptList+1] = s end
    elseif getgc then
        for _, o in ipairs(getgc(true)) do
            if typeof(o) == "Instance" and (o:IsA("LocalScript") or o:IsA("ModuleScript")) then
                scriptList[#scriptList+1] = o
            end
        end
    end

    local decomp = decompile or getsource
    local hits = 0
    for _, s in ipairs(scriptList) do
        local ok, src = pcall(function() return decomp and decomp(s) end)
        if ok and type(src) == "string" then
            local low = src:lower()
            if low:find("fireserver") or low:find("invokeserver") then
                for _, kw in ipairs(KEYWORDS) do
                    if low:find(kw) then
                        print(string.format("[PlotCopy] Candidate script: %s (matched '%s')", s:GetFullName(), kw))
                        -- print the lines that call the remote so you can read the args
                        for line in src:gmatch("[^\r\n]+") do
                            local ll = line:lower()
                            if (ll:find("fireserver") or ll:find("invokeserver")) then
                                print("    "..line:gsub("^%s+", ""))
                            end
                        end
                        table.insert(PlotCopy.SpyLog, { remote = s:GetFullName(), method = "script-scan", argc = 0 })
                        hits += 1
                        break
                    end
                end
            end
        end
    end
    if hits == 0 then
        print("[PlotCopy] No candidates found via script scan. Listing all RemoteEvents instead:")
        for _, r in ipairs(game:GetDescendants()) do
            if r:IsA("RemoteEvent") or r:IsA("RemoteFunction") then
                local n = r.Name:lower()
                for _, kw in ipairs(KEYWORDS) do
                    if n:find(kw) then print("    "..r:GetFullName().." ("..r.ClassName..")"); break end
                end
            end
        end
    end
    WindUI:Notify({
        Title = "PlotCopy",
        Content = hits > 0 and (hits.." candidate script(s) found — check console (F9).")
            or "No obvious match — see console for remote list.",
        Duration = 7, Icon = "search",
    })
end

-- HOOK-FREE: deep-inspect ONE module by name keyword. Prints the RemoteEvent
-- reference + context lines around each FireServer so the exact args are visible.
local function inspectModule(nameKeyword)
    local decomp = decompile or getsource
    if not decomp then
        WindUI:Notify({ Title = "PlotCopy", Content = "No decompiler on this executor.", Duration = 6, Icon = "x" }); return
    end
    local scriptList = {}
    if getscripts then
        for _, s in ipairs(getscripts()) do scriptList[#scriptList+1] = s end
    elseif getgc then
        for _, o in ipairs(getgc(true)) do
            if typeof(o) == "Instance" and (o:IsA("LocalScript") or o:IsA("ModuleScript")) then
                scriptList[#scriptList+1] = o
            end
        end
    end
    local matches = {}
    for _, s in ipairs(scriptList) do
        if s:GetFullName():lower():find(nameKeyword:lower()) then
            matches[#matches+1] = s
        end
    end
    if #matches == 0 then
        print("[PlotCopy] No module matching '"..nameKeyword.."' found."); return
    end
    print(string.format("[PlotCopy] %d script(s) match '%s':", #matches, nameKeyword))
    for _, s in ipairs(matches) do print("   * "..s:GetFullName()) end

    for _, target in ipairs(matches) do
    local ok, src = pcall(function() return decomp(target) end)
    if not ok or type(src) ~= "string" then
        print("[PlotCopy] Could not decompile "..target:GetFullName())
    else

    -- split into lines
    local lines = {}
    for line in (src.."\n"):gmatch("(.-)\n") do lines[#lines+1] = line end

    print("=== [PlotCopy] DEEP INSPECT: "..target:GetFullName().." ("..#lines.." lines) ===")
    -- 1) print every line that references a RemoteEvent/Function or WaitForChild
    print("--- remote references ---")
    for i, line in ipairs(lines) do
        local ll = line:lower()
        if ll:find("remoteevent") or ll:find("remotefunction")
           or ll:find("waitforchild") or ll:find("getremote") or ll:find(":fireserver")
           or ll:find(":invokeserver") then
            print(string.format("%4d: %s", i, line:gsub("^%s+", "")))
        end
    end
    -- 2) print 12 lines of context around each FireServer/InvokeServer
    print("--- fire context ---")
    for i, line in ipairs(lines) do
        local ll = line:lower()
        if ll:find(":fireserver") or ll:find(":invokeserver") then
            local a = math.max(1, i - 12)
            local b = math.min(#lines, i + 4)
            print(string.format(">>> context around line %d:", i))
            for j = a, b do
                print(string.format("%4d: %s", j, lines[j]))
            end
        end
    end
    print("=== END INSPECT: "..target:GetFullName().." ===")
    end
    end
    WindUI:Notify({ Title = "PlotCopy", Content = "Dumped "..#matches.." script(s) to console (F9). Send the output.", Duration = 7, Icon = "file-text" })
end

-- newcclosure + checkcaller, and auto-unhooks after the first capture to keep
-- the detection window as small as possible.
local hookRef, restoreHook
local function installStealthHook()
    if not (hookmetamethod and newcclosure and checkcaller) then
        WindUI:Notify({ Title = "PlotCopy", Content = "Executor missing hookmetamethod/checkcaller — use Hook-Free scan.", Duration = 7, Icon = "x" })
        return
    end
    if hookRef then return end
    local captured = false
    local old
    old = hookmetamethod(game, "__namecall", newcclosure(function(self, ...)
        -- never touch calls that originate from our own executor thread
        if not checkcaller() and not captured then
            local method = getnamecallmethod and getnamecallmethod()
            if method == "FireServer" or method == "InvokeServer" then
                local n = tostring(self.Name):lower()
                for _, kw in ipairs(KEYWORDS) do
                    if n:find(kw) then
                        local args = { ... }
                        print(string.format("[SPY] %s:%s argc=%d", self:GetFullName(), method, #args))
                        for i, a in ipairs(args) do
                            print(string.format("   arg[%d] (%s) = %s", i, typeof(a), tostring(a)))
                        end
                        table.insert(PlotCopy.SpyLog, { remote = self:GetFullName(), method = method, argc = #args })
                        captured = true
                        -- immediately restore original to minimise detection window
                        if restoreHook then task.defer(restoreHook) end
                        break
                    end
                end
            end
        end
        return old(self, ...)
    end))
    hookRef = old
    restoreHook = function()
        if hookRef and hookmetamethod then
            pcall(function() hookmetamethod(game, "__namecall", hookRef) end)
            hookRef = nil
        end
    end
    print("[PlotCopy] Stealth hook armed (auto-unhooks after first capture). Place ONE item now.")
end


-------------------------------------------------------------
-- 2) PLOT SCAN — locate the target's plot and serialize items.
-- Town stores plots in workspace; the exact folder name varies. This tries
-- common containers and matches by owner. Adjust PLOT_ROOTS if needed.
-------------------------------------------------------------
local PLOT_ROOTS = { "Plots", "Plot", "Houses", "Builds", "PlayerPlots" }

local function findPlotModel(player)
    for _, rootName in ipairs(PLOT_ROOTS) do
        local root = workspace:FindFirstChild(rootName)
        if root then
            -- match a plot whose Owner value == player
            for _, plot in ipairs(root:GetChildren()) do
                local ownerVal = plot:FindFirstChild("Owner") or plot:FindFirstChild("Player")
                if ownerVal and (ownerVal.Value == player or tostring(ownerVal.Value) == player.Name) then
                    return plot
                end
                if plot.Name == player.Name then return plot end
            end
        end
    end
    return nil
end

local function serializePlot(plot)
    local items = {}
    -- Prefer an explicit items/furniture folder if present
    local container = plot:FindFirstChild("Items")
        or plot:FindFirstChild("Furniture")
        or plot:FindFirstChild("Objects")
        or plot
    local basePart = plot:FindFirstChild("Base") or plot.PrimaryPart
        or plot:FindFirstChildWhichIsA("BasePart")
    local baseCF = basePart and basePart.CFrame or CFrame.new()

    for _, obj in ipairs(container:GetChildren()) do
        local model = obj:IsA("Model") and obj or nil
        local part  = obj:IsA("BasePart") and obj or (model and model.PrimaryPart)
        if part then
            table.insert(items, {
                Id       = obj.Name,                       -- item id/name Town uses
                CFrame   = baseCF:ToObjectSpace(part.CFrame), -- relative to plot base
                Color    = part.Color,
                Size     = part.Size,
            })
        end
    end
    return items
end

-------------------------------------------------------------
-- 3) REBUILD — fire the placement remote for each item.
-------------------------------------------------------------
local function rebuildOnMyPlot(items)
    if not PLACEMENT_CONFIG.RemotePath then
        WindUI:Notify({ Title = "PlotCopy", Content = "Placement remote not set yet. Run the spy first!", Duration = 6, Icon = "alert-triangle" })
        return
    end
    local remote = resolvePath(PLACEMENT_CONFIG.RemotePath)
    if not remote then
        WindUI:Notify({ Title = "PlotCopy", Content = "Remote path not found in game. Re-check the spy output.", Duration = 6, Icon = "x" })
        return
    end
    local myPlot = findPlotModel(LocalPlayer)
    local baseCF = CFrame.new()
    if myPlot then
        local bp = myPlot:FindFirstChild("Base") or myPlot.PrimaryPart or myPlot:FindFirstChildWhichIsA("BasePart")
        if bp then baseCF = bp.CFrame end
    end

    local placed, failed = 0, 0
    task.spawn(function()
        for _, item in ipairs(items) do
            -- convert stored relative CFrame back to WORLD space on MY plot
            local worldItem = {
                Id = item.Id,
                CFrame = baseCF:ToWorldSpace(item.CFrame),
                Color = item.Color,
                Size = item.Size,
            }
            local ok = pcall(function()
                remote[PLACEMENT_CONFIG.Method](remote, PLACEMENT_CONFIG.buildArgs(worldItem))
            end)
            if ok then placed += 1 else failed += 1 end
            task.wait(PlotCopy.PlaceDelay)
        end
        WindUI:Notify({
            Title = "PlotCopy",
            Content = string.format("Rebuild done: %d placed, %d failed.", placed, failed),
            Duration = 8, Icon = "check",
        })
    end)
end

-------------------------------------------------------------
-- PLOTCOPY TAB UI
-------------------------------------------------------------
Tabs.PlotCopy:Section({ Title = "1. Discover Placement Remote" })
Tabs.PlotCopy:Paragraph({
    Title = "How to make copy work (safe method)",
    Desc = "Town kicks for FireServer hooks, so use HOOK-FREE SCAN first — it reads the game's own scripts without touching FireServer, so there's nothing to detect. Press it, then send back the printed [PlotCopy] candidate lines.",
})
Tabs.PlotCopy:Button({
    Title = "Hook-Free Scan (recommended)",
    Desc = "No hooks — reads game scripts to find the placement remote",
    Callback = function()
        discoverRemotesNoHook()
    end,
})
Tabs.PlotCopy:Button({
    Title = "Deep Inspect: replication_client",
    Desc = "Dumps the plot replication module + FireServer args (send me the output)",
    Callback = function()
        inspectModule("replication_client")
    end,
})
Tabs.PlotCopy:Paragraph({
    Title = "Fallback (risky)",
    Desc = "Only if the scan finds nothing AND your executor has strong metatable spoofing. This uses a hook that CAN be detected. It auto-unhooks after one capture to reduce risk.",
})
Tabs.PlotCopy:Toggle({
    Title = "Stealth Hook (may get kicked)",
    Desc = "Arms a one-shot auto-unhooking hook; place one item after enabling",
    Default = false,
    Callback = function(state)
        if state then installStealthHook() else if restoreHook then restoreHook() end end
    end,
})
Tabs.PlotCopy:Button({
    Title = "Dump Discovery Log",
    Desc = "Print captured candidates again",
    Callback = function()
        if #PlotCopy.SpyLog == 0 then
            print("[PlotCopy] Log empty — run Hook-Free Scan first.")
        else
            for i, e in ipairs(PlotCopy.SpyLog) do
                print(string.format("[PlotCopy] #%d  %s  %s  argc=%d", i, e.remote, e.method, e.argc))
            end
        end
    end,
})

Tabs.PlotCopy:Section({ Title = "2. Select Target & Scan" })
local function playerNames()
    local names = {}
    for _, p in ipairs(Players:GetPlayers()) do
        if p ~= LocalPlayer then table.insert(names, p.Name) end
    end
    if #names == 0 then table.insert(names, "(no other players)") end
    return names
end
local targetDropdown = Tabs.PlotCopy:Dropdown({
    Title = "Target Player",
    Desc = "Whose plot to copy",
    Values = playerNames(),
    Value = playerNames()[1],
    Callback = function(name)
        PlotCopy.Target = Players:FindFirstChild(name)
    end,
})
Tabs.PlotCopy:Button({
    Title = "Refresh Player List",
    Callback = function()
        if targetDropdown and targetDropdown.Refresh then
            targetDropdown:Refresh(playerNames())
        end
    end,
})
Tabs.PlotCopy:Button({
    Title = "Scan Target Plot",
    Desc = "Find & serialize the target's items",
    Callback = function()
        local target = PlotCopy.Target
        if not target then
            WindUI:Notify({ Title = "PlotCopy", Content = "Pick a target player first.", Duration = 5, Icon = "x" }); return
        end
        local plot = findPlotModel(target)
        if not plot then
            WindUI:Notify({ Title = "PlotCopy", Content = "Couldn't find their plot. Adjust PLOT_ROOTS in the script.", Duration = 7, Icon = "alert-triangle" }); return
        end
        PlotCopy.LastScan = serializePlot(plot)
        WindUI:Notify({
            Title = "PlotCopy",
            Content = string.format("Scanned %d items from %s's plot.", #PlotCopy.LastScan, target.Name),
            Duration = 6, Icon = "search",
        })
        print(string.format("[PlotCopy] Serialized %d items:", #PlotCopy.LastScan))
        for i, it in ipairs(PlotCopy.LastScan) do
            if i <= 20 then print("  -", it.Id) end
        end
    end,
})

Tabs.PlotCopy:Section({ Title = "3. Rebuild On Your Plot" })
Tabs.PlotCopy:Slider({
    Title = "Placement Delay (ms)",
    Desc = "Throttle between placements to avoid anti-spam kicks",
    Value = { Min = 20, Max = 1000, Default = 100 },
    Callback = function(v) PlotCopy.PlaceDelay = v / 1000 end,
})
Tabs.PlotCopy:Button({
    Title = "Copy Plot To Me",
    Desc = "Rebuild the scanned items on your own plot",
    Callback = function()
        if #PlotCopy.LastScan == 0 then
            WindUI:Notify({ Title = "PlotCopy", Content = "Scan a target plot first.", Duration = 5, Icon = "x" }); return
        end
        rebuildOnMyPlot(PlotCopy.LastScan)
    end,
})
Tabs.PlotCopy:Button({
    Title = "Export Scan (JSON)",
    Desc = "Copy serialized plot to clipboard (if supported)",
    Callback = function()
        if #PlotCopy.LastScan == 0 then
            WindUI:Notify({ Title = "PlotCopy", Content = "Nothing scanned yet.", Duration = 5, Icon = "x" }); return
        end
        local ok, json = pcall(function()
            -- CFrame/Color3 aren't JSON-native; store a printable summary
            local out = {}
            for _, it in ipairs(PlotCopy.LastScan) do
                table.insert(out, { Id = it.Id, CFrame = tostring(it.CFrame) })
            end
            return HttpService:JSONEncode(out)
        end)
        if ok and setclipboard then setclipboard(json) end
        WindUI:Notify({ Title = "PlotCopy", Content = ok and "Exported to clipboard." or "Export failed.", Duration = 5, Icon = "clipboard" })
    end,
})

--============================================================
--// SETTINGS TAB
--============================================================
Tabs.Settings:Section({ Title = "UI Settings" })
Tabs.Settings:Toggle({
    Title = "Transparent UI",
    Default = true,
    Callback = function(state) Window:ToggleTransparency(state) end,
})
Tabs.Settings:Button({
    Title = "Destroy UI",
    Desc = "Close and remove the interface",
    Callback = function() Window:Destroy() end,
})

WindUI:Notify({
    Title = "Loaded",
    Content = "Town V1 loaded successfully! ESP + Aimbot ready.",
    Duration = 4,
    Icon = "rocket",
})