script

--script is coded in 1 day


local players = game:GetService("Players")
local runservice = game:GetService("RunService")
local userservice = game:GetService("UserInputService")
local replicatedstorage = game:GetService("ReplicatedStorage")
local camera = workspace.CurrentCamera
local localplayer = players.LocalPlayer

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

local Window = WindUI:CreateWindow({
    Title = "sn0w | Bloody Playground",
    Icon = "eye",
    Author = "2zerfff",
    Folder = "2zerfff",
    
    Size = UDim2.fromOffset(580, 460),
    MinSize = Vector2.new(560, 350),
    MaxSize = Vector2.new(850, 560),
    Transparent = true,
    Theme = "Dark",
    Resizable = true,
    SideBarWidth = 200,
    BackgroundImageTransparency = 0.42,
    HideSearchBar = true,
    ScrollBarEnabled = false,

    User = {
        Enabled = true,
        Anonymous = false,
        Callback = function()
            print("release - 2zerfff")
        end,
    },
})



local Modules = replicatedstorage:WaitForChild("Modules")
local BulletHandler = require(Modules:WaitForChild("BulletHandler"))

local silents = {
    Enabled = false,
    FOV = 300,
    HitPart = "Head",
    ShowCircle = false
}

local silent
local silentcircle = Drawing.new("Circle")
silentcircle.Visible = silents.ShowCircle
silentcircle.Thickness = 2
silentcircle.NumSides = 100
silentcircle.Radius = silents.FOV
silentcircle.Filled = false
silentcircle.Transparency = 1


local function getClosestTarget()
    local closest = nil
    local shortest = silents.FOV

    local mousePos = userservice:GetMouseLocation()

    for _, plr in pairs(players:GetPlayers()) do
        if plr ~= localplayer and plr.Character and plr.Character:FindFirstChild(silents.HitPart) then

            local part = plr.Character[silents.HitPart]
            local screenPos, onScreen = camera:WorldToViewportPoint(part.Position)

            if onScreen then
                local dist = (Vector2.new(screenPos.X, screenPos.Y) - mousePos).Magnitude

                if dist < shortest then
                    shortest = dist
                    closest = part
                end
            end
        end
    end

    return closest
end

local oldBullet = BulletHandler.bullet

BulletHandler.bullet = function(self, data)

    if silents.Enabled and data then
        local target = getClosestTarget()

        if target then
            data.position = target.Position
            data.hit = target

            if data.origin then
                local dir = (target.Position - data.origin).Unit
                data.velocity = dir * 5000
                data.direction = dir
            end

            data.normal = Vector3.new(0,1,0)
        end
    end

    return oldBullet(self, data)
end

local ActiveCast = require(replicatedstorage.Modules.FastCastRedux.ActiveCast)
local old_new = ActiveCast.new

local wallbang = false

ActiveCast.new = function(caster, origin, direction, velocity, behavior)
    behavior = behavior or {}

    behavior.CanPierceFunction = function(cast, result, vel, bullet)
        if not wallbang then
            return false
        end

        if not result or not result.Instance then
            return false
        end

        local hit = result.Instance
        local model = hit:FindFirstAncestorOfClass("Model")

        if model and model:FindFirstChild("Humanoid") then
            return false
        end

        if model == localplayer.Character then
            return false
        end

        return true
    end

    if not behavior.RaycastParams then
        behavior.RaycastParams = RaycastParams.new()
    end

    behavior.RaycastParams.FilterType = Enum.RaycastFilterType.Exclude
    behavior.RaycastParams.FilterDescendantsInstances = {localplayer.Character}
    behavior.RaycastParams.IgnoreWater = true

    behavior.HighFidelityBehavior = 1
    behavior.HighFidelitySegmentSize = 5

    return old_new(caster, origin, direction, velocity, behavior)
end

local function toggleActiveCast()
    wallbang = not wallbang
end




local maintab = Window:Tab({
    Title = "Main",
    Icon = "crosshair",
    Locked = false,
})

local aimbotsection = maintab:Section({
    Title = "Aimbot",
    Icon = "users",
    Opened = true,
})

local silentaim = aimbotsection:Toggle({
    Title = "Silent Aim",
    Desc = "Redirects Bullets To Target",
    Icon = "check",
    Type = "Checkbox",
    Value = false,
Callback = function(v) 
    silents.Enabled = v
    silents.ShowCircle = v
    silentcircle.Visible = v

    if v then
        if not silent then
            silent = runservice.RenderStepped:Connect(function()
                local mousePos = userservice:GetMouseLocation()
                silentcircle.Position = mousePos
                silentcircle.Radius = silents.FOV
            end)
        end
    else
        if silent then 
            silent:Disconnect()
            silent = nil
        end
    end
end

})

local radius = aimbotsection:Slider({
    Title = "Silent Aim Radius",
    Desc = "Changes The Silent Aim Radius",
    
    Step = 1,
    Value = {
        Min = 50,
        Max = 750,
        Default = 120,
    },
    Callback = function(value)
        silents.FOV = value
    end
})

local hitpart = aimbotsection:Dropdown({
    Title = "Hit Part",
    Desc = "Silent Aim Hit Part",
    Values = { "Head", "HumanoidRootPart", "UpperTorso" },
    Value = { "Head" },
    Multi = false,
    AllowNone = false,
    Callback = function(option)
        silents.HitPart = typeof(option) == "table" and option[1] or option
    end
})

local silentcolor = aimbotsection:Colorpicker({
    Title = "Silent Aim Color",
    Desc = "Changes The Silent Aim Color",
    Default = Color3.fromRGB(0, 255, 0),
    Transparency = 0,
    Locked = false,
    Callback = function(color) 
        silentcircle.Color = color
    end
})



local settings = {
    enabled = false,
    fov = 120,
    smoothness = 0.15,
    hitPart = "HumanoidRootPart",
    aimKey = Enum.KeyCode.E,
    holdToAim = true,
    visibleCheck = false,
    teamCheck = false,
    prediction = true,
    predictionAmount = 0.165,
    predictionJump = true,
    bulletVelocity = 5000
}

local aiming = false

local circle = Drawing.new("Circle")
circle.Visible = false
circle.Filled = false
circle.Thickness = 2
circle.Color = Color3.fromRGB(235,200,200)
circle.Radius = settings.fov
circle.Transparency = 0.5

userservice.InputChanged:Connect(function()
    if settings.enabled then
        circle.Position = userservice:GetMouseLocation()
    end
end)

userservice.InputBegan:Connect(function(input, gp)
    if gp then return end

    if input.KeyCode == settings.aimKey then
        aiming = true
    end
end)

userservice.InputEnded:Connect(function(input)
    if input.KeyCode == settings.aimKey then
        aiming = false
    end
end)


local function isAimKeyPressed()
    return aiming
end

local function isVisible(targetPart)
    if not settings.visibleCheck then return true end

    local origin = camera.CFrame.Position
    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Exclude
    params.FilterDescendantsInstances = {localplayer.Character, workspace.Cache}
    params.IgnoreWater = true

    local result = workspace:Raycast(origin, (targetPart.Position - origin).Unit * 1000, params)
    return result and result.Instance:IsDescendantOf(targetPart.Parent)
end

local function getPredictedPosition(targetPart)
    local currentPos = targetPart.Position
    local velocity = targetPart.Velocity

    local jumpOffset = Vector3.new(0,0,0)
    if settings.predictionJump then
        local humanoid = targetPart.Parent:FindFirstChild("Humanoid")
        if humanoid and humanoid:GetState() == Enum.HumanoidStateType.Jumping then
            local jumpTime = -velocity.Y / workspace.Gravity
            if jumpTime > 0 then
                local jumpHeight = velocity.Y * jumpTime + 0.5 * workspace.Gravity * jumpTime^2
                jumpOffset = Vector3.new(0, jumpHeight * 0.5, 0)
            end
        end
    end

    local predOffset = Vector3.new(0,0,0)
    if settings.prediction and velocity.Magnitude > 5 then
        local travelTime = (currentPos - camera.CFrame.Position).Magnitude / settings.bulletVelocity
        predOffset = velocity * travelTime * settings.predictionAmount
    end

    return currentPos + predOffset + jumpOffset
end

local function getClosestTarget()
    local closest = nil
    local closestDist = settings.fov
    local mousePos = userservice:GetMouseLocation()

    for _, player in pairs(players:GetPlayers()) do
        if player ~= localplayer then

            if settings.teamCheck and player.Team == localplayer.Team then
                continue
            end

            local char = player.Character
            if not char then continue end

            local part = char:FindFirstChild(settings.hitPart) or char:FindFirstChild("HumanoidRootPart")
            if not part then continue end

            local predicted = getPredictedPosition(part)
            local screenPos, onScreen = camera:WorldToViewportPoint(predicted)
            if not onScreen then continue end

            local dist = (Vector2.new(screenPos.X, screenPos.Y) - mousePos).Magnitude

            if dist < closestDist then
                if not settings.visibleCheck or isVisible(part) then
                    closestDist = dist
                    closest = part
                end
            end
        end
    end

    return closest
end

runservice.RenderStepped:Connect(function()
    if not settings.enabled then
        circle.Visible = false
        return
    end

    circle.Visible = true
    circle.Radius = settings.fov

    if not isAimKeyPressed() then return end

    local target = getClosestTarget()
    if not target then return end

    local predicted = getPredictedPosition(target)
    local camPos = camera.CFrame.Position
    local newCF = CFrame.lookAt(camPos, predicted)

    camera.CFrame = camera.CFrame:Lerp(newCF, settings.smoothness)
end)





aimbotsection:Toggle({
    Title = "Enable Aimbot",
    Value = false,
    Callback = function(state)
        settings.enabled = state
        circle.Visible = state
    end
})

aimbotsection:Slider({
    Title = "FOV",
    Desc = "Aimbot FOV",
    Value = {Min = 50, Max = 360, Default = settings.fov},
    Callback = function(value)
        settings.fov = value
        circle.Radius = value
    end
})

aimbotsection:Slider({
    Title = "Smoothness",
    Desc = "Camera Lerp Speed",
    Value = {Min = 0, Max = 1, Default = settings.smoothness},
    Callback = function(value)
        settings.smoothness = value
    end
})

aimbotsection:Dropdown({
    Title = "Hit Part",
    Desc = "Select target part",
    Values = {"Head", "HumanoidRootPart", "UpperTorso"},
    Value = {settings.hitPart},
    Multi = false,
    Callback = function(option)
        settings.hitPart = option[1]
    end
})

aimbotsection:Keybind({
    Title = "Aim Key",
    Desc = "Hold to aim",
    Default = settings.aimKey,
    HoldToActivate = true,
    Callback = function(key)
        settings.aimKey = key
    end
})

aimbotsection:Toggle({
    Title = "Prediction",
    Value = settings.prediction,
    Callback = function(state)
        settings.prediction = state
    end
})

aimbotsection:Slider({
    Title = "Prediction",
    Desc = "More = High Ping",
    Value = {Min = 0, Max = 1, Default = settings.predictionAmount},
    Callback = function(value)
        settings.predictionAmount = value
    end
})

aimbotsection:Toggle({
    Title = "Hold To Aim",
    Value = true,
    Callback = function(state)
        settings.holdToAim = state
        aiming = false
    end
})

local miscsection = maintab:Section({
    Title = "Misc",
    Icon = "crosshair",
    Opened = true,
})

local wallbangtoggle = miscsection:Toggle({
    Title = "Wallbang",
    Desc = "Bullets Are Penetrating All!",
    Icon = "check",
    Type = "Checkbox",
    Value = false,
    Callback = function(state) 
        wallbang = state
    end
})

local remote = replicatedstorage:WaitForChild("Remotes"):WaitForChild("Swing")

task.spawn(function()
    while true do
        task.wait()

        if StompEnabled then
            for _, plr in pairs(players:GetPlayers()) do
                if Targets[plr.UserId] then

                    local char = plr.Character
                    if not char then continue end

                    local head = char:FindFirstChild("Head")
                    local hum = char:FindFirstChildOfClass("Humanoid")

                    if head and hum and head:IsDescendantOf(workspace) then
                        remote:FireServer("Stomp Air", "Stomp Air Start")
                        remote:FireServer("Stomp Air", "Stomp Air Hit", head)
                        remote:FireServer("Stomp Air", "Stomp Air End")
                    end
                end
            end
        end
    end
end)

local targettab = Window:Tab({
    Title = "Target",
    Icon = "target",
    Locked = false,
})

local targetsection = targettab:Section({
    Title = "Targeting",
    Icon = "users",
    Opened = true,
})

local targettoggle = targetsection:Toggle({
    Title = "Target Player",
    Desc = "Targeting a player with stomp",
    Icon = "check",
    Type = "Checkbox",
    Value = false,
    Callback = function(state)

        if state then
            WindUI:Popup({
                Title = "Targeting",
                Icon = "info",
                Content = "Do you really want to enable targeting?\nWARNING: This may increase your ping!",
                Buttons = {
                    {
                        Title = "No, I don't want",
                        Callback = function()
                            StompEnabled = false
                            targettoggle:SetValue(false)
                        end,
                        Variant = "Tertiary",
                    },
                    {
                        Title = "Yes, I want",
                        Icon = "arrow-right",
                        Callback = function()
                            StompEnabled = true
                            targettoggle:SetValue(true)
                        end,
                        Variant = "Primary",
                    }
                }
            })

        else
            StompEnabled = false
        end
    end
})


local targetlist = targetsection:Dropdown({
    Title = "Targets",
    Desc = "Select players",
    Values = {},
    Value = {},
    Multi = true,
    AllowNone = true,
    Callback = function(selected)
              Targets = {}

        for _, name in pairs(selected) do
            local plr = players:FindFirstChild(name)
            if plr then
                Targets[plr.UserId] = true
            end
        end
    end
})

local function updatePlayerList()
    local names = {}

    for _, plr in pairs(players:GetPlayers()) do
        if plr ~= localplayer then
            table.insert(names, plr.Name)
        end
    end

    targetlist:Refresh(names)
end

updatePlayerList()

players.PlayerAdded:Connect(updatePlayerList)
players.PlayerRemoving:Connect(updatePlayerList)



userservice.InputBegan:Connect(function(input, gameProcessed)
    if gameProcessed then return end

    if input.KeyCode == Enum.KeyCode.P then
        Window:Toggle()
    end
end)

local ESP = {
    Enabled = false,
    Color = Color3.fromRGB(255, 0, 0)
}

local BoxESP = {
    Enabled = false,
    Color = Color3.fromRGB(255,255,255)
}

local boxes = {}

local Highlights = {}

local function createHighlight(plr)
    if plr == localplayer then return end

    local function apply(char)
        if not ESP.Enabled then return end

        if Highlights[plr] then
            Highlights[plr]:Destroy()
            Highlights[plr] = nil
        end

        local hl = Instance.new("Highlight")
        hl.FillColor = ESP.Color
        hl.OutlineColor = ESP.Color
        hl.FillTransparency = 0.5
        hl.OutlineTransparency = 0
        hl.Adornee = char
        hl.Parent = char

        Highlights[plr] = hl
    end

    if plr.Character then
        apply(plr.Character)
    end

    plr.CharacterAdded:Connect(function(char)
        task.wait(0.2)
        apply(char)
    end)
end



local function removeHighlight(plr)
    if Highlights[plr] then
        Highlights[plr]:Destroy()
        Highlights[plr] = nil
    end
end

local function updateHighlights()
    for _, plr in pairs(players:GetPlayers()) do
        if ESP.Enabled then
            createHighlight(plr)
        else
            removeHighlight(plr)
        end
    end
end

players.PlayerAdded:Connect(function(plr)
    createHighlight(plr)
end)


for _, plr in pairs(players:GetPlayers()) do
    createHighlight(plr)
end

for _, plr in pairs(players:GetPlayers()) do
    plr.CharacterAdded:Connect(function()
        task.wait(0.2)
        if ESP.Enabled then
            createHighlight(plr)
        end
    end)
end

local function createBox(player)
    if player == localplayer then return end
    if boxes[player] then return end

    local BOX = Drawing.new("Square")
    BOX.Color = BoxESP.Color
    BOX.Thickness = 1
    BOX.Filled = false
    BOX.Visible = false

    boxes[player] = BOX
end

local function removeBox(player)
    if boxes[player] then
        boxes[player]:Remove()
        boxes[player] = nil
    end
end

runservice.RenderStepped:Connect(function()
    for player, BOX in pairs(boxes) do

        if not BoxESP.Enabled then
            BOX.Visible = false
            continue
        end

        local char = player.Character
        if not char then 
            BOX.Visible = false
            continue
        end

        local head = char:FindFirstChild("Head")
        local hrp = char:FindFirstChild("HumanoidRootPart")

        if not head or not hrp then 
            BOX.Visible = false
            continue
        end

        local headp, vis1 = camera:WorldToViewportPoint(head.Position + Vector3.new(0,0.4,0))
        local rootp, vis2 = camera:WorldToViewportPoint(hrp.Position - Vector3.new(0,3,0))

        if vis1 and vis2 then
            local height = math.abs(headp.Y - rootp.Y)
            local width = height / 1.5

            BOX.Size = Vector2.new(width, height)
            BOX.Position = Vector2.new(rootp.X - width/2, headp.Y)
            BOX.Color = BoxESP.Color
            BOX.Visible = true
        else
            BOX.Visible = false
        end
    end
end)

for _, player in pairs(players:GetPlayers()) do
    createBox(player)
end

players.PlayerAdded:Connect(createBox)
players.PlayerRemoving:Connect(removeBox)

local HealthESP = {
    Enabled = false,
    ColorLow = Color3.fromRGB(255, 0, 0),
    ColorHigh = Color3.fromRGB(0, 255, 0)
}

local healthbars = {}


local function createHealthbar(player)
    if player == localplayer then return end
    if healthbars[player] then return end

    local bar = Drawing.new("Line")
    bar.Thickness = 2
    bar.Visible = false

    healthbars[player] = bar
end

local function removeHealthbar(player)
    if healthbars[player] then
        healthbars[player]:Remove()
        healthbars[player] = nil
    end
end

local function getHealthColor(percent)
    local r = 255 * (1 - percent)
    local g = 255 * percent
    return Color3.fromRGB(r, g, 0)
end

local function getHealthColor(percent)
    return HealthESP.ColorLow:Lerp(HealthESP.ColorHigh, percent)
end



runservice.RenderStepped:Connect(function()
    for player, bar in pairs(healthbars) do

        if not HealthESP.Enabled then
            bar.Visible = false
            continue
        end

        local char = player.Character
        if not char then 
            bar.Visible = false
            continue
        end

        local hrp = char:FindFirstChild("HumanoidRootPart")
        local head = char:FindFirstChild("Head")
        local hum = char:FindFirstChildOfClass("Humanoid")

        if not hrp or not head or not hum then
            bar.Visible = false
            continue
        end

        local headp, vis1 = camera:WorldToViewportPoint(head.Position + Vector3.new(0,0.4,0))
        local rootp, vis2 = camera:WorldToViewportPoint(hrp.Position - Vector3.new(0,3,0))

        if vis1 and vis2 then
            local height = math.abs(headp.Y - rootp.Y)
            local x = rootp.X - (height / 1.5) / 2 - 6

            local healthPercent = hum.Health / hum.MaxHealth
            local barHeight = height * healthPercent

            bar.From = Vector2.new(x, rootp.Y)
            bar.To = Vector2.new(x, rootp.Y - barHeight)

            bar.Color = getHealthColor(healthPercent)
            bar.Visible = true
        else
            bar.Visible = false
        end
    end
end)

for _, player in pairs(players:GetPlayers()) do
    createHealthbar(player)
end

players.PlayerAdded:Connect(createHealthbar)
players.PlayerRemoving:Connect(removeHealthbar)





local esptab = Window:Tab({
    Title = "ESP",
    Icon = "eye",
    Locked = false,
})

local espsection = esptab:Section({
    Title = "Highlight",
    Icon = "eye",
    Opened = true,
})

espsection:Toggle({
    Title = "Player Highlight",
    Callback = function(state)
        ESP.Enabled = state

        for _, plr in pairs(players:GetPlayers()) do
            if state then
                createHighlight(plr)
            else
                if Highlights[plr] then
                    Highlights[plr]:Destroy()
                    Highlights[plr] = nil
                end
            end
        end
    end
})

espsection:Colorpicker({
    Title = "Highlight Color",
    Default = ESP.Color,
    Callback = function(color)
        ESP.Color = color

        for _, hl in pairs(Highlights) do
            hl.FillColor = color
            hl.OutlineColor = color
        end
    end
})

local espsection2 = esptab:Section({
    Title = "Boxes",
    Icon = "eye",
    Opened = true,
})

espsection2:Toggle({
    Title = "Player Boxes",
    Callback = function(state)
        BoxESP.Enabled = state
    end
})

espsection2:Colorpicker({
    Title = "Box Color",
    Default = BoxESP.Color,
    Callback = function(color)
        BoxESP.Color = color
    end
})

local espsection3 = esptab:Section({
    Title = "Healthbars",
    Icon = "eye",
    Opened = true,
})

espsection3:Toggle({
    Title = "Player Healthbars",
    Callback = function(state)
        HealthESP.Enabled = state
    end
})

espsection3:Colorpicker({
    Title = "Health Color Low",
    Default = HealthESP.ColorLow,
    Callback = function(color)
        HealthESP.ColorLow = color
    end
})

espsection3:Colorpicker({
    Title = "Health Color High",
    Default = HealthESP.ColorHigh,
    Callback = function(color)
        HealthESP.ColorHigh = color
    end
})

local NameESP = {
    Enabled = false,
    Color = Color3.fromRGB(255,255,255),
    Size = 13
}

local names = {}

local function createName(player)
    if player == localplayer then return end
    if names[player] then return end

    local text = Drawing.new("Text")
    text.Size = 13
    text.Center = true
    text.Outline = true
    text.Font = 2
    text.Visible = false
    text.Color = NameESP.Color

    names[player] = text
end

local function removeName(player)
    if names[player] then
        names[player]:Remove()
        names[player] = nil
    end
end


runservice.RenderStepped:Connect(function()
    for player, text in pairs(names) do

        if not NameESP.Enabled then
            text.Visible = false
            continue
        end

        local char = player.Character
        if not char then
            text.Visible = false
            continue
        end

        local head = char:FindFirstChild("Head")
        if not head then
            text.Visible = false
            continue
        end

        local pos, visible = camera:WorldToViewportPoint(head.Position + Vector3.new(0, 1.5, 0))

        if visible then
            text.Position = Vector2.new(pos.X, pos.Y)
            text.Text = player.Name
            text.Color = NameESP.Color
            text.Size = NameESP.Size
            text.Visible = true
        else
            text.Visible = false
        end
    end
end)

for _, player in pairs(players:GetPlayers()) do
    createName(player)
end

players.PlayerAdded:Connect(createName)
players.PlayerRemoving:Connect(removeName)

local espsection4 = esptab:Section({
    Title = "Names",
    Icon = "eye",
    Opened = true,
})

espsection4:Toggle({
    Title = "Player Names",
    Callback = function(state)
        NameESP.Enabled = state
    end
})

espsection4:Colorpicker({
    Title = "Name Color",
    Default = NameESP.Color,
    Callback = function(color)
        NameESP.Color = color
    end
})

espsection4:Slider({
    Title = "Name Size",
    Step = 1,
    Value = {
        Min = 10,
        Max = 30,
        Default = 13,
    },
    Callback = function(value)
        NameESP.Size = value
    end
})


local SkeletonESP = {
    Enabled = false,
    Color = Color3.fromRGB(255,255,255)
}

local skeletons = {}

local function createSkeleton(player)
    if player == localplayer then return end
    if skeletons[player] then return end

    local lines = {}

    for i = 1, 6 do
        local line = Drawing.new("Line")
        line.Thickness = 1
        line.Color = SkeletonESP.Color
        line.Visible = false
        lines[i] = line
    end

    skeletons[player] = lines
end

local function removeSkeleton(player)
    if skeletons[player] then
        for _, line in pairs(skeletons[player]) do
            line:Remove()
        end
        skeletons[player] = nil
    end
end

local function getPart(char, name)
    return char:FindFirstChild(name)
end

runservice.RenderStepped:Connect(function()
    for player, lines in pairs(skeletons) do

        if not SkeletonESP.Enabled then
            for _, l in pairs(lines) do l.Visible = false end
            continue
        end

        local char = player.Character
        if not char then
            for _, l in pairs(lines) do l.Visible = false end
            continue
        end

        local head = getPart(char, "Head")
        local root = getPart(char, "HumanoidRootPart")

        local torso = getPart(char, "UpperTorso") or getPart(char, "Torso")
        local larm = getPart(char, "LeftUpperArm") or getPart(char, "Left Arm")
        local rarm = getPart(char, "RightUpperArm") or getPart(char, "Right Arm")
        local lleg = getPart(char, "LeftUpperLeg") or getPart(char, "Left Leg")
        local rleg = getPart(char, "RightUpperLeg") or getPart(char, "Right Leg")

        if not head or not root or not torso then
            for _, l in pairs(lines) do l.Visible = false end
            continue
        end

        local function toScreen(part)
            local pos, vis = camera:WorldToViewportPoint(part.Position)
            return Vector2.new(pos.X, pos.Y), vis
        end

        local h, v1 = toScreen(head)
        local t, v2 = toScreen(torso)
        local r, v3 = toScreen(root)

        if v1 and v2 and v3 then
            lines[1].From = h
            lines[1].To = t

            lines[2].From = t
            lines[2].To = r

            if larm then
                local p, v = toScreen(larm)
                if v then
                    lines[3].From = t
                    lines[3].To = p
                    lines[3].Visible = true
                else
                    lines[3].Visible = false
                end
            end

            if rarm then
                local p, v = toScreen(rarm)
                if v then
                    lines[4].From = t
                    lines[4].To = p
                    lines[4].Visible = true
                else
                    lines[4].Visible = false
                end
            end

            if lleg then
                local p, v = toScreen(lleg)
                if v then
                    lines[5].From = r
                    lines[5].To = p
                    lines[5].Visible = true
                else
                    lines[5].Visible = false
                end
            end

            if rleg then
                local p, v = toScreen(rleg)
                if v then
                    lines[6].From = r
                    lines[6].To = p
                    lines[6].Visible = true
                else
                    lines[6].Visible = false
                end
            end

            for _, l in pairs(lines) do
                l.Color = SkeletonESP.Color
                l.Visible = true
            end
        else
            for _, l in pairs(lines) do
                l.Visible = false
            end
        end
    end
end)

for _, player in pairs(players:GetPlayers()) do
    createSkeleton(player)
end

players.PlayerAdded:Connect(createSkeleton)
players.PlayerRemoving:Connect(removeSkeleton)

local espsection5 = espsection:Section({
    Title = "Skeleton ESP",
    Icon = "eye",
    Opened = true,
})

espsection5:Toggle({
    Title = "Skeleton ESP",
    Callback = function(state)
        SkeletonESP.Enabled = state
    end
})

espsection5:Colorpicker({
    Title = "Skeleton Color",
    Default = SkeletonESP.Color,
    Callback = function(color)
        SkeletonESP.Color = color
    end
})

local misctab = Window:Tab({
    Title = "Misc",
    Icon = "crosshair",
    Locked = false,
})

local miscsection = misctab:Section({
    Title = "Local Player",
    Icon = "crosshair",
    Opened = true,
})

local AntiSettings = {
    NoEndlag = false,
    NoStun = false,
    NoStompCooldown = false,
    NoHurt = false,
    NoRagdoll = false,
    AutoSprint = false
}


local function setupCharacter(character)
    local humanoid = character:WaitForChild("Humanoid")
    
    local connection
    connection = runservice.Heartbeat:Connect(function()

        if AntiSettings.NoEndlag then
            character:SetAttribute("Endlag", false)
        end

        if AntiSettings.NoStun then
            character:SetAttribute("Stunned", false)
        end

        if AntiSettings.NoStompCooldown then
            character:SetAttribute("StompCooldown", false)
        end

        if AntiSettings.NoHurt then
            character:SetAttribute("Hurt", false)
        end

        if AntiSettings.NoRagdoll then
            character:SetAttribute("Ragdoll", false)
        end

        if AntiSettings.AutoSprint then
            character:SetAttribute("Sprinting", true)
        end

    end)

    humanoid.Died:Connect(function()
        if connection then
            connection:Disconnect()
        end
    end)
end
if localplayer.Character then
    setupCharacter(localplayer.Character)
end
localplayer.CharacterAdded:Connect(setupCharacter)


miscsection:Toggle({
    Title = "No Endlag",
    Callback = function(state)
        AntiSettings.NoEndlag = state
    end
})

miscsection:Toggle({
    Title = "No Stun",
    Callback = function(state)
        AntiSettings.NoStun = state
    end
})

miscsection:Toggle({
    Title = "No Stomp Cooldown",
    Callback = function(state)
        AntiSettings.NoStompCooldown = state
    end
})

miscsection:Toggle({
    Title = "No Hurt",
    Callback = function(state)
        AntiSettings.NoHurt = state
    end
})

miscsection:Toggle({
    Title = "No Ragdoll",
    Callback = function(state)
        AntiSettings.NoRagdoll = state
    end
})

miscsection:Toggle({
    Title = "Auto Sprint",
    Callback = function(state)
        AntiSettings.AutoSprint = state
    end
})

local Paragraph = miscsection:Paragraph({
    Title = "Info",
    Desc = "Drop Kick WILL NOT WORK WITH AUTO SPRINT ENABLED ! ",
    Color = "Red",
    Image = "",
    ImageSize = 30,
    Thumbnail = "",
    ThumbnailSize = 80,
    Locked = false,
    Buttons = {
        {
            Icon = "cat",
            Title = "meow",
            Callback = function()
            WindUI:Popup({
    Title = "meow",
    Icon = "cat",
    Content = "meow",
    Buttons = {
        {
            Title = "no",
            Callback = function() end,
            Variant = "Tertiary",
        },
        {
            Title = "meow !",
            Icon = "arrow-right",
            Callback = function() end,
            Variant = "Primary",
        }
    }
})
end
        }
    }
})

local teleporttab = Window:Tab({
    Title = "Teleport",
    Icon = "person-standing",
    Locked = false,
})

local teleportsection = teleporttab:Section({
    Title = "Teleport",
    Icon = "person-standing",
    Opened = true,
})

local Button = teleportsection:Button({
    Title = "Teleport To Secret",
    Desc = "teleports",
    Locked = false,
    Callback = function()
    local char = localplayer.Character or localplayer.CharacterAdded:Wait()
    local hrp = char:FindFirstChild("HumanoidRootPart")
    if hrp then
        hrp.CFrame = CFrame.new(645, 2366, 328)
    end
    end
})

local button2 = teleportsection:Button({
    Title = "Teleport To Heal",
    Desc = "teleports",
    Locked = false,
    Callback = function()
    local char = localplayer.Character or localplayer.CharacterAdded:Wait()
    local hrp = char:FindFirstChild("HumanoidRootPart")
    if hrp then
        hrp.CFrame = workspace.Map.Tower.Traps.buttons.Heal100Brick.CFrame
    end
    end
})