local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local Debris = game:GetService("Debris")
local UIS = game:GetService("UserInputService")

local player = Players.LocalPlayer
local bootsOn = false
local sneaking = false
local iceCooldown = 0
local lastHealth = nil
local damageCooldown = 1.5
local lastDamageTime = 0

-- TOOL
local tool = Instance.new("Tool")
tool.TextureId = "rbxassetid://97625418048677"
tool.Name = "FrostWalkerBoots"
tool.RequiresHandle = true
tool.CanBeDropped = true

local handle = Instance.new("Part")
handle.Name = "Handle"
handle.Size = Vector3.new(1, 1, 1)
handle.Transparency = 0.5
handle.Material = Enum.Material.Neon
handle.Color = Color3.fromRGB(0, 255, 255)
handle.Parent = tool

tool.Parent = player:WaitForChild("Backpack")

-- STUD TEXTURE
local function addStudTexture(part)
    local top = Instance.new("Texture")
    top.Texture = "rbxassetid://1095708"
    top.Face = Enum.NormalId.Top
    top.StudsPerTileU = 4
    top.StudsPerTileV = 4
    top.Parent = part

    local bottom = top:Clone()
    bottom.Face = Enum.NormalId.Bottom
    bottom.Parent = part
end

-- BOOTS
local leftBoot, rightBoot, leftGlint, rightGlint

local function createBoots(character)
    local leftLeg = character:FindFirstChild("Left Leg")
    local rightLeg = character:FindFirstChild("Right Leg")

    if not leftLeg or not rightLeg then return end

    leftBoot = Instance.new("Part")
    leftBoot.Name = "LeftBoot"
    leftBoot.Size = Vector3.new(1.2, 1.2, 1.2)
    leftBoot.Material = Enum.Material.Plastic
    leftBoot.Color = Color3.fromRGB(50, 150, 255)
    leftBoot.CanCollide = false
    leftBoot.Parent = character
    addStudTexture(leftBoot)

    rightBoot = leftBoot:Clone()
    rightBoot.Name = "RightBoot"
    rightBoot.Parent = character

    -- GLINTS
    leftGlint = Instance.new("Part")
    leftGlint.Name = "EnchantmentGlint"
    leftGlint.Size = leftBoot.Size + Vector3.new(0.01, 0.01, 0.01)
    leftGlint.Material = Enum.Material.ForceField
    leftGlint.Transparency = 0.3
    leftGlint.CanCollide = false
    leftGlint.Color = Color3.fromRGB(160, 0, 255)
    leftGlint.Parent = character

    rightGlint = leftGlint:Clone()
    rightGlint.Parent = character

    -- POSITION
    leftBoot.CFrame = leftLeg.CFrame * CFrame.new(0, -0.5, 0)
    rightBoot.CFrame = rightLeg.CFrame * CFrame.new(0, -0.5, 0)
    leftGlint.CFrame = leftBoot.CFrame
    rightGlint.CFrame = rightBoot.CFrame

    -- WELDS
    local weld1 = Instance.new("WeldConstraint")
    weld1.Part0 = leftBoot
    weld1.Part1 = leftLeg
    weld1.Parent = leftBoot

    local weld2 = Instance.new("WeldConstraint")
    weld2.Part0 = rightBoot
    weld2.Part1 = rightLeg
    weld2.Parent = rightBoot

    local gw1 = Instance.new("WeldConstraint")
    gw1.Part0 = leftGlint
    gw1.Part1 = leftBoot
    gw1.Parent = leftGlint

    local gw2 = Instance.new("WeldConstraint")
    gw2.Part0 = rightGlint
    gw2.Part1 = rightBoot
    gw2.Parent = rightGlint
end

local function removeBoots()
    if leftBoot then leftBoot:Destroy() end
    if rightBoot then rightBoot:Destroy() end
    if leftGlint then leftGlint:Destroy() end
    if rightGlint then rightGlint:Destroy() end
    leftBoot, rightBoot, leftGlint, rightGlint = nil, nil, nil, nil
end

-- HEALTH BOOST
local function addHealthBoost(humanoid)
    humanoid.MaxHealth = humanoid.MaxHealth + 40
    humanoid.Health = humanoid.Health + 40
end

local function removeHealthBoost(humanoid)
    humanoid.MaxHealth = humanoid.MaxHealth - 40
    if humanoid.Health > humanoid.MaxHealth then
        humanoid.Health = humanoid.MaxHealth
    end
end

-- TOOL ACTIVATION
tool.Activated:Connect(function()
    local char = player.Character
    local humanoid = char and char:FindFirstChild("Humanoid")

    bootsOn = not bootsOn

    if bootsOn then
        createBoots(char)
        if humanoid then addHealthBoost(humanoid) end
    else
        removeBoots()
        if humanoid then removeHealthBoost(humanoid) end
    end
end)

-- SNEAK
local sneakAngle = math.rad(30)

local function setSneak(character, on)
    local torso = character:FindFirstChild("Torso")
    local head = character:FindFirstChild("Head")
    local lArm = character:FindFirstChild("Left Arm")
    local rArm = character:FindFirstChild("Right Arm")

    if not torso or not head or not lArm or not rArm then return end

    local neck = head:FindFirstChild("Neck")
    local lShoulder = torso:FindFirstChild("Left Shoulder")
    local rShoulder = torso:FindFirstChild("Right Shoulder")

    if not neck or not lShoulder or not rShoulder then return end

    if on then
        torso.CFrame = torso.CFrame * CFrame.Angles(sneakAngle, 0, 0)
        neck.C0 = neck.C0 * CFrame.Angles(sneakAngle, 0, 0)
        lShoulder.C0 = lShoulder.C0 * CFrame.Angles(sneakAngle, 0, 0)
        rShoulder.C0 = rShoulder.C0 * CFrame.Angles(sneakAngle, 0, 0)
    else
        torso.CFrame = torso.CFrame * CFrame.Angles(-sneakAngle, 0, 0)
        neck.C0 = neck.C0 * CFrame.Angles(-sneakAngle, 0, 0)
        lShoulder.C0 = lShoulder.C0 * CFrame.Angles(-sneakAngle, 0, 0)
        rShoulder.C0 = rShoulder.C0 * CFrame.Angles(-sneakAngle, 0, 0)
    end
end

UIS.InputBegan:Connect(function(input, gameProcessed)
    if gameProcessed then return end
    if input.KeyCode == Enum.KeyCode.T and bootsOn then
        sneaking = not sneaking
        local char = player.Character
        if char then setSneak(char, sneaking) end
    end
end)

-- DEATH / DROPPING TOOL
player.CharacterAdded:Connect(function(character)
    bootsOn = false
    sneaking = false
    removeBoots()

    local humanoid = character:WaitForChild("Humanoid")

    humanoid.Died:Connect(function()
        tool.Parent = workspace
        tool.Handle.CFrame = character.HumanoidRootPart.CFrame
        tool.Handle.Anchored = false
        tool.Handle.CanCollide = true

        local spin = Instance.new("BodyAngularVelocity")
        spin.AngularVelocity = Vector3.new(0, 6, 0)
        spin.MaxTorque = Vector3.new(0, math.huge, 0)
        spin.Parent = tool.Handle
    end)
end)

-- ICE SPAWN (GRID)
RunService.Heartbeat:Connect(function(delta)
    if not bootsOn then return end
    iceCooldown = iceCooldown - delta
    if iceCooldown > 0 then return end

    local character = player.Character
    if not character then return end

    local root = character:FindFirstChild("HumanoidRootPart")
    if not root then return end

    local footPos = root.Position - Vector3.new(0, 3, 0)

    local rayParams = RaycastParams.new()
    rayParams.FilterDescendantsInstances = {character}
    rayParams.FilterType = Enum.RaycastFilterType.Blacklist

    local ray = workspace:Raycast(footPos, Vector3.new(0, -5, 0), rayParams)

    if ray and ray.Instance and ray.Instance.CanCollide == false then
        local gridX = math.floor(root.Position.X / 3) * 3
        local gridZ = math.floor(root.Position.Z / 3) * 3
        local gridY = ray.Position.Y + 1.5

        local ice = Instance.new("Part")
        ice.Size = Vector3.new(3, 3, 3)
        ice.Anchored = true
        ice.CanCollide = true
        ice.Material = Enum.Material.Plastic
        ice.Color = Color3.fromRGB(160, 230, 255)
        ice.Reflectance = 0.4

        ice.Position = Vector3.new(gridX + 1.5, gridY, gridZ + 1.5)
        ice.Parent = workspace

        local top = Instance.new("Texture", ice)
        top.Texture = "rbxassetid://1095708"
        top.Face = Enum.NormalId.Top
        top.StudsPerTileU = 4
        top.StudsPerTileV = 4

        local bottom = Instance.new("Texture", ice)
        bottom.Texture = "rbxassetid://1095708"
        bottom.Face = Enum.NormalId.Bottom
        bottom.StudsPerTileU = 4
        bottom.StudsPerTileV = 4

        Debris:AddItem(ice, 4)

        iceCooldown = 0.2
    end
end)

-- DAMAGE HIGHLIGHT (NOT THROUGH WALLS)
local function makeHighlight(character)
    local highlight = character:FindFirstChild("DamageHighlight")
    if highlight then return highlight end

    highlight = Instance.new("Highlight")
    highlight.Name = "DamageHighlight"
    highlight.FillColor = Color3.fromRGB(255, 0, 0)
    highlight.FillTransparency = 0.5
    highlight.OutlineTransparency = 1
    highlight.Parent = character

    return highlight
end

local function canSeeTarget(target)
    local camera = workspace.CurrentCamera
    local origin = camera.CFrame.Position
    local targetPos = target.Position
    local direction = (targetPos - origin).Unit * (targetPos - origin).Magnitude

    local rayParams = RaycastParams.new()
    rayParams.FilterDescendantsInstances = {workspace.CurrentCamera, player.Character}
    rayParams.FilterType = Enum.RaycastFilterType.Blacklist

    local ray = workspace:Raycast(origin, direction, rayParams)
    if not ray then return true end
    if ray.Instance:IsDescendantOf(target.Parent) then
        return true
    end
    return false
end

local function damageHighlightCheck()
    local character = player.Character
    if not character then return end

    local humanoid = character:FindFirstChildOfClass("Humanoid")
    if not humanoid then return end

    if lastHealth == nil then
        lastHealth = humanoid.Health
        return
    end

    if humanoid.Health < lastHealth then
        if tick() - lastDamageTime >= damageCooldown then
            if canSeeTarget(character.PrimaryPart or character:FindFirstChild("HumanoidRootPart")) then
                local highlight = makeHighlight(character)
                highlight.Enabled = true
                lastDamageTime = tick()

                delay(0.3, function()
                    if highlight then
                        highlight.Enabled = false
                    end
                end)
            end
        end
    end

    lastHealth = humanoid.Health
end

RunService.Heartbeat:Connect(damageHighlightCheck)