local repo = "https://raw.githubusercontent.com/violin-suzutsuki/LinoriaLib/main/"

local Library = loadstring(game:HttpGet(repo .. "Library.lua"))()
local ThemeManager = loadstring(game:HttpGet(repo .. "addons/ThemeManager.lua"))()
local SaveManager = loadstring(game:HttpGet(repo .. "addons/SaveManager.lua"))()

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local Stats = game:GetService("Stats")
local LocalPlayer = Players.LocalPlayer

local Remotes = ReplicatedStorage:WaitForChild("Remotes", 10)
local UpdateSpeed = Remotes and Remotes:WaitForChild("UpdateSpeed", 10)

local Window = Library:CreateWindow({
    Title = "Nuvik | Auto Walk",
    Center = true,
    AutoShow = true,
    TabPadding = 8,
    MenuFadeTime = 0.2
})

local Tabs = {
    Main = Window:AddTab("Main"),
    Teleport = Window:AddTab("Teleport"),
    Settings = Window:AddTab("Settings"),
}

local AutoBox = Tabs.Main:AddLeftGroupbox("Auto Walk")
local InfoBox = Tabs.Main:AddRightGroupbox("Status")
local MiscBox = Tabs.Main:AddLeftGroupbox("Utility")

local State = {
    Enabled = false,
    Interval = 0.35,
    Burst = 1,
    Threads = 1,
    Calls = 0,
    Errors = 0,
    ActiveThreads = 0,
}

local IsTeleporting = false
local DefaultGravity = workspace.Gravity

local TpSettings = {
    MaxDelta = 300,
    CheckInterval = 6.5,
    HoldTime = 10,
}

local PingStat = nil
pcall(function()
    local serverStats = Stats.Network:FindFirstChild("ServerStatsItem")
    if serverStats then
        PingStat = serverStats:FindFirstChild("Data Ping")
    end
end)

local function Notify(msg, time)
    Library:Notify(msg, time or 3)
end

local function FireWalking()
    if not UpdateSpeed then
        State.Errors += 1
        return false, "Remote not found"
    end

    local ok, err = pcall(function()
        UpdateSpeed:FireServer("Walking")
    end)

    if ok then
        State.Calls += 1
        return true
    else
        State.Errors += 1
        return false, err
    end
end

local function SpawnThread(id)
    local offset = (id - 1) * (State.Interval / State.Threads)

    task.spawn(function()
        State.ActiveThreads += 1
        task.wait(offset)

        while State.Enabled do
            for i = 1, State.Burst do
                if not State.Enabled then break end

                local ok, err = FireWalking()

                if not ok and State.Errors >= 15 then
                    State.Enabled = false
                    Toggles.AutoWalk:SetValue(false)
                    Notify("Auto Walk stopped: too many errors", 4)
                    break
                end

                task.wait(0.02)
            end

            task.wait(State.Interval)
        end

        State.ActiveThreads -= 1
    end)
end

local function StopAllThreads()
    State.Enabled = false
end

local function StartThreads()
    if State.ActiveThreads > 0 then return end
    State.Enabled = true
    State.Errors = 0

    for i = 1, State.Threads do
        SpawnThread(i)
    end
end

local function GradualTeleport(targetX, targetY, targetZ)
    if IsTeleporting then return end
    IsTeleporting = true

    task.spawn(function()
        local hrp = nil

        repeat
            task.wait(0.1)
            pcall(function() hrp = LocalPlayer.Character.HumanoidRootPart end)
        until hrp

        local startPos = hrp.Position
        local startY = startPos.Y
        local totalDist = Vector2.new(startPos.X - targetX, startPos.Z - targetZ).Magnitude
        local stepSize = TpSettings.MaxDelta / (TpSettings.CheckInterval / 0.03)
        stepSize = math.max(stepSize, 0.8)

        local tpNoclipConn = RunService.Stepped:Connect(function()
            pcall(function()
                local char = LocalPlayer.Character
                if char then
                    for _, part in ipairs(char:GetDescendants()) do
                        if part:IsA("BasePart") then
                            part.CanCollide = false
                        end
                    end
                end
            end)
        end)

        local lockPos = nil
        local lockConn = RunService.RenderStepped:Connect(function()
            if lockPos then
                pcall(function()
                    local h = LocalPlayer.Character.HumanoidRootPart
                    h.CFrame = lockPos
                    h.AssemblyLinearVelocity = Vector3.zero
                    h.AssemblyAngularVelocity = Vector3.zero
                end)
            end
        end)

        while IsTeleporting do
            pcall(function() hrp = LocalPlayer.Character.HumanoidRootPart end)

            if not hrp then
                IsTeleporting = false
                break
            end

            local current = hrp.Position
            local currentFlat = Vector2.new(current.X, current.Z)
            local targetFlat = Vector2.new(targetX, targetZ)
            local distFlat = (targetFlat - currentFlat).Magnitude

            if distFlat <= stepSize * 2 then
                lockPos = CFrame.new(targetX, targetY, targetZ)
                task.wait(0.5)

                local finalY = targetY
                
                pcall(function()
                    local char = LocalPlayer.Character
                    local hrpInst = char.HumanoidRootPart
                    
                    local params = RaycastParams.new()
                    params.FilterDescendantsInstances = {char}
                    params.FilterType = Enum.RaycastFilterType.Exclude
                    
                    local roofCheck = workspace:Raycast(
                        Vector3.new(targetX, targetY + 10, targetZ),
                        Vector3.new(0, -20, 0),
                        params
                    )
                    
                    if roofCheck and math.abs(targetY - roofCheck.Position.Y) < 5 then
                        local insidePos = Vector3.new(targetX, targetY - 5, targetZ)
                        lockPos = CFrame.new(insidePos)
                        task.wait(0.5)
                        
                        local floorResult = workspace:Raycast(
                            insidePos + Vector3.new(0, 2, 0),
                            Vector3.new(0, -200, 0),
                            params
                        )
                        
                        if floorResult and floorResult.Normal.Y > 0.5 then
                            finalY = floorResult.Position.Y + 3
                        end
                    end
                end)

                lockPos = CFrame.new(targetX, finalY, targetZ)
                Notify("Arrived — holding...", 3)

                task.wait(TpSettings.HoldTime)

                lockPos = nil
                lockConn:Disconnect()
                if tpNoclipConn then tpNoclipConn:Disconnect() end
                
                if not Toggles.NoClip.Value then
                    pcall(function()
                        local char = LocalPlayer.Character
                        if char then
                            for _, part in ipairs(char:GetDescendants()) do
                                if part:IsA("BasePart") then
                                    part.CanCollide = true
                                end
                            end
                        end
                    end)
                end

                IsTeleporting = false
                Notify("Teleport complete", 2)
                break
            end

            local progress = 1 - (distFlat / totalDist)
            local interpY = startY + (targetY - startY) * math.clamp(progress, 0, 1)

            local dirFlat = (targetFlat - currentFlat).Unit
            local nextX = current.X + dirFlat.X * stepSize
            local nextZ = current.Z + dirFlat.Y * stepSize

            lockPos = CFrame.new(nextX, interpY, nextZ)
            task.wait(0.03)
        end

        if lockConn then lockConn:Disconnect() end
        lockPos = nil
        if tpNoclipConn then tpNoclipConn:Disconnect() end
        
        if not Toggles.NoClip.Value then
            pcall(function()
                local char = LocalPlayer.Character
                if char then
                    for _, part in ipairs(char:GetDescendants()) do
                        if part:IsA("BasePart") then
                            part.CanCollide = true
                        end
                    end
                end
            end)
        end
        
        IsTeleporting = false
    end)
end

local noclipConn = nil

MiscBox:AddToggle("NoClip", {
    Text = "NoClip",
    Default = false,
    Flag = "NoClip",
    Tooltip = "Disables collision so you can walk through walls.",

    Callback = function(value)
        if value then
            if not noclipConn then
                noclipConn = RunService.Stepped:Connect(function()
                    if IsTeleporting then return end 
                    pcall(function()
                        local char = LocalPlayer.Character
                        if char then
                            for _, part in ipairs(char:GetDescendants()) do
                                if part:IsA("BasePart") then
                                    part.CanCollide = false
                                end
                            end
                        end
                    end)
                end)
            end
        else
            if noclipConn then
                noclipConn:Disconnect()
                noclipConn = nil
            end
            pcall(function()
                local char = LocalPlayer.Character
                if char then
                    for _, part in ipairs(char:GetDescendants()) do
                        if part:IsA("BasePart") then
                            part.CanCollide = true
                        end
                    end
                end
            end)
        end
    end
})

MiscBox:AddToggle("NoGravity", {
    Text = "No Gravity",
    Default = false,
    Flag = "NoGravity",
    Tooltip = "Sets workspace gravity to 0.",

    Callback = function(value)
        if value then
            workspace.Gravity = 0
        else
            workspace.Gravity = DefaultGravity
        end
    end
})

AutoBox:AddToggle("AutoWalk", {
    Text = "Auto Walk",
    Default = false,
    Flag = "AutoWalk",
    Tooltip = "Fires Walking remote automatically across all threads.",

    Callback = function(value)
        if value then
            StartThreads()
            Notify("Auto Walk enabled | Threads: " .. State.Threads, 2)
        else
            StopAllThreads()
            Notify("Auto Walk disabled", 2)
        end
    end
})

AutoBox:AddSlider("WalkInterval", {
    Text = "Interval (s)",
    Default = 0.35,
    Min = 0.10,
    Max = 2.00,
    Rounding = 2,
    Flag = "WalkInterval",

    Callback = function(value)
        State.Interval = value
    end
})

AutoBox:AddSlider("WalkBurst", {
    Text = "Burst per cycle",
    Default = 1,
    Min = 1,
    Max = 5,
    Rounding = 0,
    Flag = "WalkBurst",

    Callback = function(value)
        State.Burst = value
    end
})

AutoBox:AddSlider("WalkThreads", {
    Text = "Threads",
    Default = 1,
    Min = 1,
    Max = 100,
    Rounding = 0,
    Flag = "WalkThreads",
    Tooltip = "Parallel fire threads. Each thread fires independently with staggered offset.",

    Callback = function(value)
        State.Threads = value

        if State.Enabled then
            StopAllThreads()
            task.wait(0.1)
            State.Enabled = true
            StartThreads()
            Notify("Threads restarted: " .. value, 2)
        end
    end
})

AutoBox:AddButton("Fire Once", function()
    local ok, err = FireWalking()
    if ok then
        Notify("Walking fired once", 2)
    else
        Notify("Error: " .. tostring(err), 4)
    end
end)

AutoBox:AddButton("Reset Stats", function()
    State.Calls = 0
    State.Errors = 0
    Notify("Stats reset", 2)
end)

AutoBox:AddButton("Copy Coords", function()
    local hrp = nil
    pcall(function() hrp = LocalPlayer.Character.HumanoidRootPart end)

    if not hrp then
        Notify("HumanoidRootPart not found", 3)
        return
    end

    local pos = hrp.Position
    local coords = string.format("X: %.2f, Y: %.2f, Z: %.2f", pos.X, pos.Y, pos.Z)

    if setclipboard then
        setclipboard(coords)
        Notify("Coords copied: " .. coords, 4)
    else
        print(coords)
        Notify("setclipboard not supported", 3)
    end
end)

local LabelCalls = InfoBox:AddLabel("Calls: 0")
local LabelErrors = InfoBox:AddLabel("Errors: 0")
local LabelThreads = InfoBox:AddLabel("Threads: 0")
local LabelState = InfoBox:AddLabel("State: Off")

task.spawn(function()
    while task.wait(0.5) do
        LabelCalls:SetText("Calls: " .. tostring(State.Calls))
        LabelErrors:SetText("Errors: " .. tostring(State.Errors))
        LabelThreads:SetText("Active Threads: " .. tostring(State.ActiveThreads))
        LabelState:SetText("State: " .. (State.Enabled and "Running" or "Off"))
    end
end)

local TeleportBox = Tabs.Teleport:AddLeftGroupbox("Teleports")
local TeleportInfoBox = Tabs.Teleport:AddRightGroupbox("Options")

local TeleportPoints = {
    { Name = "+1 Win", X = -18.16, Y = 14.94, Z = 285.54 },
    { Name = "+3 Wins", X = -17.06, Y = 16.13, Z = 507.90 },
    { Name = "+20 Wins", X = -19.02, Y = 83.85, Z = 1106.21 },
    { Name = "+50 Wins", X = -18.59, Y = 80.80, Z = 1412.68 },
    { Name = "+100 Wins", X = -538.23, Y = 59.78, Z = 1445.27 },
    { Name = "+150 Wins", X = -1008.52, Y = 59.96, Z = 1446.01 },
    { Name = "+300 Wins", X = -1123.75, Y = 302.29, Z = 1447.56 },
    { Name = "+500 Wins", X = -2970.79, Y = 303.25, Z = 1447.38 },
    { Name = "+1000 Wins", X = -3937.81, Y = 304.77, Z = 1447.40 },
    { Name = "+2500 Wins", X = -4368.51, Y = 477.18, Z = 1511.34 },
    { Name = "+50000 Wins", X = -8353.97, Y = 491.42, Z = 1466.87 },
}

for _, point in ipairs(TeleportPoints) do
    TeleportBox:AddButton(point.Name, function()
        GradualTeleport(point.X, point.Y, point.Z)
    end)
end

TeleportBox:AddButton("Add Current Position", function()
    local hrp = nil
    pcall(function() hrp = LocalPlayer.Character.HumanoidRootPart end)

    if not hrp then
        Notify("HumanoidRootPart not found", 3)
        return
    end

    local pos = hrp.Position
    local groundY = pos.Y
    
    pcall(function()
        local params = RaycastParams.new()
        params.FilterDescendantsInstances = {LocalPlayer.Character}
        params.FilterType = Enum.RaycastFilterType.Exclude
        local result = workspace:Raycast(pos, Vector3.new(0, -10, 0), params)
        if result and result.Normal.Y > 0.5 then
            groundY = result.Position.Y + 3
        end
    end)

    local name = "Custom " .. (#TeleportPoints + 1)
    table.insert(TeleportPoints, { Name = name, X = pos.X, Y = groundY, Z = pos.Z })

    TeleportBox:AddButton(name, function()
        GradualTeleport(pos.X, groundY, pos.Z)
    end)

    Notify("Saved: " .. name .. string.format(" (%.1f, %.1f, %.1f)", pos.X, groundY, pos.Z), 3)
end)

TeleportBox:AddButton("Cancel Teleport", function()
    IsTeleporting = false
    Notify("Teleport cancelled", 2)
end)

TeleportInfoBox:AddSlider("TpMaxDelta", {
    Text = "Max Delta/Check",
    Default = 300,
    Min = 50,
    Max = 2000,
    Rounding = 0,
    Flag = "TpMaxDelta",
    Tooltip = "Max units moved per SecretShield check. Lower = safer, slower.",

    Callback = function(value)
        TpSettings.MaxDelta = value
    end
})

TeleportInfoBox:AddSlider("TpCheckInterval", {
    Text = "Check Interval (s)",
    Default = 6.5,
    Min = 0.01,
    Max = 60.0,
    Rounding = 2,
    Flag = "TpCheckInterval",
    Tooltip = "SecretShield check interval. Match to game's anti-cheat timing.",

    Callback = function(value)
        TpSettings.CheckInterval = value
    end
})

TeleportInfoBox:AddSlider("TpHoldTime", {
    Text = "Hold Time (s)",
    Default = 10,
    Min = 0.01,
    Max = 90.0,
    Rounding = 2,
    Flag = "TpHoldTime",
    Tooltip = "Seconds to hold position after arriving.",

    Callback = function(value)
        TpSettings.HoldTime = value
    end
})

Library:SetWatermarkVisibility(true)

local fpsBuffer = {}
local pingBuffer = {}

task.spawn(function()
    while true do
        local dt = RunService.Heartbeat:Wait()
        local fps = math.floor(1 / dt)

        table.insert(fpsBuffer, fps)
        if #fpsBuffer > 10 then table.remove(fpsBuffer, 1) end

        local fsum = 0
        for _, v in ipairs(fpsBuffer) do fsum += v end
        local avgFps = math.floor(fsum / #fpsBuffer)

        local ping = 0
        if PingStat then
            pcall(function()
                ping = math.floor(PingStat.Value)
            end)
        end

        table.insert(pingBuffer, ping)
        if #pingBuffer > 5 then table.remove(pingBuffer, 1) end

        local psum = 0
        for _, v in ipairs(pingBuffer) do psum += v end
        local avgPing = math.floor(psum / #pingBuffer)

        Library:SetWatermark(("Nuvik | FPS: %d | Ping: %dms | Threads: %d"):format(
            avgFps,
            avgPing,
            State.ActiveThreads
        ))
    end
end)

ThemeManager:SetLibrary(Library)
SaveManager:SetLibrary(Library)

SaveManager:IgnoreThemeSettings()
SaveManager:SetIgnoreIndexes({ "MenuKeybind" })

ThemeManager:SetFolder("Nuvik")
SaveManager:SetFolder("Nuvik/AutoWalk")

ThemeManager:ApplyToTab(Tabs.Settings)
SaveManager:BuildConfigSection(Tabs.Settings)

local NuvikTheme = {
    ["Font"] = Enum.Font.Gotham,
    ["Main"] = Color3.fromRGB(10, 10, 15),
    ["Second"] = Color3.fromRGB(18, 18, 26),
    ["Stroke"] = Color3.fromRGB(40, 40, 60),
    ["Divider"] = Color3.fromRGB(30, 30, 45),
    ["Text"] = Color3.fromRGB(220, 220, 255),
    ["TextDark"] = Color3.fromRGB(120, 120, 160),
    ["Header"] = Color3.fromRGB(14, 14, 22),
    ["Accent"] = Color3.fromRGB(100, 80, 255),
    ["OuterBorder"] = Color3.fromRGB(60, 50, 120),
    ["InnerBorder"] = Color3.fromRGB(25, 25, 40),
    ["SchemeColor"] = Color3.fromRGB(100, 80, 255),
    ["Background"] = Color3.fromRGB(10, 10, 15),
    ["Topbar"] = Color3.fromRGB(14, 14, 22),
    ["Shadow"] = Color3.fromRGB(5, 5, 10),
    ["DarkContrast"] = Color3.fromRGB(15, 15, 22),
    ["LightContrast"] = Color3.fromRGB(25, 25, 38),
}

ThemeManager:ApplyTheme(NuvikTheme)

Library:OnUnload(function()
    StopAllThreads()
    IsTeleporting = false
    if noclipConn then
        noclipConn:Disconnect()
    end
    workspace.Gravity = DefaultGravity
end)