-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. Deal with caution.
--
-- Stay safe:
--   • Never log in on unofficial Roblox sites or lookalike domains.
--   • Real Roblox links use roblox.com (check the .com ending).
--   • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End Rscripts Risk Notice ]]

local Players = game:GetService("Players")
local VirtualInputManager = game:GetService("VirtualInputManager")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local LocalPlayer = Players.LocalPlayer

local Fluent = loadstring(game:HttpGet(
    "https://github.com/dawid-scripts/Fluent/releases/latest/download/main.lua"
))()

local Window = Fluent:CreateWindow({
    Title = "Kyelisz",
    SubTitle = "Fluent UI",
    TabWidth = 160,
    Size = UDim2.fromOffset(580, 460),
    Acrylic = true,
    Theme = "Dark",
    MinimizeKey = Enum.KeyCode.LeftControl
})

-- =========================================================
-- TABS
-- =========================================================

local AutoTab = Window:AddTab({
    Title = "Auto",
    Icon = "zap"
})

local FullAutoTab = Window:AddTab({
    Title = "Full auto farm",
    Icon = "repeat"
})

local RemoveTab = Window:AddTab({
    Title = "Remove",
    Icon = "trash-2"
})

local MovementTab = Window:AddTab({
    Title = "Movement",
    Icon = "move"
})

-- =========================================================
-- VARIABLES
-- =========================================================

local savedCFrame = nil

local eggRunning = false
local BestRunning = false
local RandomRunning = false
local FullAutoRunning = false

local SelectedStage = "Meadow"

-- Full Auto stage cooldowns.
-- [StageName] = time when stage can be tried again.
local StageBlockedUntil = {}

local CurrentFullAutoStage = nil

-- =========================================================
-- AUTO WEIGHT
-- =========================================================

local AutoWeight = AutoTab:AddToggle("AutoWeight", {
    Title = "Auto Weight",
    Default = false
})

AutoWeight:OnChanged(function(Value)
    local Character =
        LocalPlayer.Character
        or LocalPlayer.CharacterAdded:Wait()

    local RootPart =
        Character:WaitForChild("HumanoidRootPart")

    if Value then

        savedCFrame = RootPart.CFrame

        RootPart.CFrame = CFrame.new(
            -25.525551,
            1.063050,
            23.662083
        )

    else

        local Humanoid =
            Character:FindFirstChildOfClass("Humanoid")

        if Humanoid then
            Humanoid.Jump = true
        end

        task.wait(1)

        if RootPart and savedCFrame then
            RootPart.CFrame = savedCFrame
        end
    end
end)

-- =========================================================
-- STAGES
-- =========================================================

local StageNames = {
    "Meadow",
    "Mystic Isles",
    "Prehistoric",
    "Savannah",
    "The Underworld",
    "Winter",
    "Jungle",
    "Desert",
    "Crystal Mines",
    "Coral Reef",
    "Celestial Heights"
}

local PriorityStages = {
    "The Underworld",
    "Savannah",
    "Celestial Heights",
    "Prehistoric"
}

-- =========================================================
-- GET EGG FOLDER
-- =========================================================

local function GetEggFolder(StageName)

    local Map = workspace:FindFirstChild("Map")

    if not Map then
        return nil
    end

    local Stages = Map:FindFirstChild("Stages")

    if not Stages then
        return nil
    end

    local Stage = Stages:FindFirstChild(StageName)

    if not Stage then
        return nil
    end

    return Stage:FindFirstChild("SpawnedEggs")
end

-- =========================================================
-- HAS EGGS
-- =========================================================

local function HasEggs(StageName)

    local EggFolder = GetEggFolder(StageName)

    if not EggFolder then
        return false
    end

    for _, Object in ipairs(EggFolder:GetChildren()) do

        if Object:IsA("Model") then
            return true
        end

    end

    return false
end

-- =========================================================
-- AVAILABLE STAGES
-- =========================================================

local function GetAvailableStages()

    local AvailableStages = {}

    for _, StageName in ipairs(StageNames) do

        if HasEggs(StageName) then
            table.insert(
                AvailableStages,
                StageName
            )
        end

    end

    return AvailableStages
end

-- =========================================================
-- STAGE DROPDOWN
-- =========================================================

local StageDropdown = AutoTab:AddDropdown(
    "StageDropdown",
    {
        Title = "Which Stage",
        Values = StageNames,
        Multi = false,
        Default = "Meadow"
    }
)

StageDropdown:OnChanged(function(Value)
    SelectedStage = Value
end)

-- =========================================================
-- RANDOM TOGGLE
-- =========================================================

local RandomToggle = AutoTab:AddToggle(
    "RandomToggle",
    {
        Title = "Random",
        Description =
            "Randomly chooses from stages that currently have eggs",
        Default = false
    }
)

RandomToggle:OnChanged(function(Value)

    if not Value then
        RandomRunning = false
        return
    end

    if RandomRunning then
        return
    end

    RandomRunning = true

    task.spawn(function()

        local LastRandomStage = nil

        while RandomToggle.Value do

            local AvailableStages =
                GetAvailableStages()

            if #AvailableStages > 0 then

                local Choices = {}

                for _, StageName in
                    ipairs(AvailableStages) do

                    if #AvailableStages == 1
                        or StageName ~= LastRandomStage then

                        table.insert(
                            Choices,
                            StageName
                        )

                    end
                end

                if #Choices > 0 then

                    local RandomStage =
                        Choices[
                            math.random(
                                1,
                                #Choices
                            )
                        ]

                    LastRandomStage =
                        RandomStage

                    SelectedStage =
                        RandomStage

                    StageDropdown:SetValue(
                        RandomStage
                    )
                end
            end

            task.wait(0.5)
        end

        RandomRunning = false
    end)
end)

-- =========================================================
-- BEST TOGGLE
-- =========================================================

local BestToggle = AutoTab:AddToggle(
    "BestToggle",
    {
        Title = "Best",
        Description =
            "Continuously finds the highest-priority stage with eggs",
        Default = false
    }
)

BestToggle:OnChanged(function(Value)

    if not Value then
        BestRunning = false
        return
    end

    if BestRunning then
        return
    end

    BestRunning = true

    task.spawn(function()

        while BestToggle.Value do

            local FoundStage = nil

            -- Priority stages first.
            for _, StageName in
                ipairs(PriorityStages) do

                if HasEggs(StageName) then

                    FoundStage =
                        StageName

                    break
                end
            end

            -- If none of the priority stages
            -- have eggs, search everything.
            if not FoundStage then

                for _, StageName in
                    ipairs(StageNames) do

                    if HasEggs(StageName) then

                        FoundStage =
                            StageName

                        break
                    end
                end
            end

            if FoundStage
                and SelectedStage ~= FoundStage then

                SelectedStage =
                    FoundStage

                StageDropdown:SetValue(
                    FoundStage
                )
            end

            task.wait(0.5)
        end

        BestRunning = false
    end)
end)

-- =========================================================
-- AUTO EGG
-- =========================================================

local AutoEgg = AutoTab:AddToggle(
    "AutoEgg",
    {
        Title = "Auto Egg",
        Default = false
    }
)

AutoEgg:OnChanged(function(Value)

    if not Value then

        eggRunning = false

        VirtualInputManager:SendKeyEvent(
            false,
            Enum.KeyCode.E,
            false,
            game
        )

        return
    end

    if eggRunning then
        return
    end

    eggRunning = true

    task.spawn(function()

        local Character =
            LocalPlayer.Character
            or LocalPlayer.CharacterAdded:Wait()

        local RootPart =
            Character:WaitForChild(
                "HumanoidRootPart"
            )

        while AutoEgg.Value do

            local EggsFolder =
                GetEggFolder(
                    SelectedStage
                )

            if EggsFolder then

                for _, Egg in
                    ipairs(
                        EggsFolder:GetChildren()
                    ) do

                    if not AutoEgg.Value then
                        break
                    end

                    if Egg:IsA("Model") then

                        local TargetPart =
                            Egg.PrimaryPart
                            or Egg:FindFirstChildWhichIsA(
                                "BasePart",
                                true
                            )

                        if TargetPart then

                            RootPart.CFrame =
                                TargetPart.CFrame
                                + Vector3.new(
                                    0,
                                    2,
                                    0
                                )

                            task.wait(0.2)

                            -- EXACT 1 SECOND E HOLD
                            VirtualInputManager:SendKeyEvent(
                                true,
                                Enum.KeyCode.E,
                                false,
                                game
                            )

                            task.wait(1)

                            VirtualInputManager:SendKeyEvent(
                                false,
                                Enum.KeyCode.E,
                                false,
                                game
                            )

                            task.wait(0.2)

                            RootPart.CFrame =
                                CFrame.new(
                                    0.096151,
                                    1.000000,
                                    -32.040047
                                )

                            task.wait(0.5)
                        end
                    end
                end
            end

            task.wait(0.2)
        end

        VirtualInputManager:SendKeyEvent(
            false,
            Enum.KeyCode.E,
            false,
            game
        )

        eggRunning = false
    end)
end)

-- =========================================================
-- FULL AUTO FARM
-- =========================================================

local FullAutoStatus =
    FullAutoTab:AddParagraph({
        Title = "Status",
        Content = "Stopped"
    })

-- =========================================================
-- NOTIFICATION DETECTOR
-- =========================================================

local NotificationRemote

do

    local Remotes =
        ReplicatedStorage:FindFirstChild(
            "Remotes"
        )

    if Remotes then

        NotificationRemote =
            Remotes:FindFirstChild(
                "Notification"
            )
    end
end

if NotificationRemote
    and NotificationRemote:IsA("RemoteEvent") then

    NotificationRemote.OnClientEvent:Connect(
        function(...)

            if not FullAutoRunning then
                return
            end

            local Arguments = {...}

            for _, Argument in
                ipairs(Arguments) do

                if typeof(Argument) == "string" then

                    local Lower =
                        string.lower(
                            Argument
                        )

                    local HasYouNeed =
                        string.find(
                            Lower,
                            "you need",
                            1,
                            true
                        )

                    local HasJumpPower =
                        string.find(
                            Lower,
                            "jump power",
                            1,
                            true
                        )

                    local HasStealEgg =
                        string.find(
                            Lower,
                            "to steal this egg",
                            1,
                            true
                        )

                    if HasYouNeed
                        and HasJumpPower
                        and HasStealEgg then

                        if CurrentFullAutoStage then

                            -- Leave this entire stage out
                            -- for exactly 3 minutes.
                            StageBlockedUntil[
                                CurrentFullAutoStage
                            ] =
                                os.clock() + 180
                        end

                        break
                    end
                end
            end
        end
    )
end

-- =========================================================
-- CHECK STAGE COOLDOWN
-- =========================================================

local function IsStageBlocked(StageName)

    local BlockedUntil =
        StageBlockedUntil[StageName]

    if not BlockedUntil then
        return false
    end

    if os.clock() >= BlockedUntil then

        StageBlockedUntil[StageName] =
            nil

        return false
    end

    return true
end

-- =========================================================
-- GET RANDOM FULL-AUTO STAGE
-- =========================================================

local function GetRandomFullAutoStage()

    local AvailableStages = {}

    for _, StageName in
        ipairs(StageNames) do

        if HasEggs(StageName)
            and not IsStageBlocked(
                StageName
            ) then

            table.insert(
                AvailableStages,
                StageName
            )
        end
    end

    if #AvailableStages == 0 then
        return nil
    end

    return AvailableStages[
        math.random(
            1,
            #AvailableStages
        )
    ]
end

-- =========================================================
-- GET RANDOM EGG
-- =========================================================

local function GetRandomEgg(StageName)

    local EggsFolder =
        GetEggFolder(StageName)

    if not EggsFolder then
        return nil
    end

    local Eggs = {}

    for _, Egg in
        ipairs(
            EggsFolder:GetChildren()
        ) do

        if Egg:IsA("Model") then

            table.insert(
                Eggs,
                Egg
            )
        end
    end

    if #Eggs == 0 then
        return nil
    end

    return Eggs[
        math.random(
            1,
            #Eggs
        )
    ]
end

-- =========================================================
-- FULL AUTO START
-- =========================================================

FullAutoTab:AddButton({
    Title = "Start Full Auto Farm",
    Description =
        "30s Weight → 30s Random Eggs → repeat",

    Callback = function()

        if FullAutoRunning then
            return
        end

        FullAutoRunning = true

        task.spawn(function()

            while FullAutoRunning do

                -- =================================================
                -- WEIGHT PHASE - 30 SECONDS
                -- =================================================

                FullAutoStatus:SetDesc(
                    "Weight: 30 seconds"
                )

                if not AutoWeight.Value then
                    AutoWeight:SetValue(true)
                end

                local WeightStart =
                    os.clock()

                while FullAutoRunning
                    and
                    os.clock() - WeightStart < 30 do

                    task.wait(0.2)
                end

                if not FullAutoRunning then
                    break
                end

                -- Turn weight OFF.
                if AutoWeight.Value then
                    AutoWeight:SetValue(false)
                end

                -- Existing Auto Weight function
                -- waits 1 second and restores
                -- the original position.
                task.wait(1)

                if not FullAutoRunning then
                    break
                end

                -- =================================================
                -- EGG PHASE - 30 SECONDS
                -- ALL BIOMES / RANDOM
                -- =================================================

                FullAutoStatus:SetDesc(
                    "Eggs: random biome"
                )

                local EggStart =
                    os.clock()

                while FullAutoRunning
                    and
                    os.clock() - EggStart < 30 do

                    local StageName =
                        GetRandomFullAutoStage()

                    if StageName then

                        local Egg =
                            GetRandomEgg(
                                StageName
                            )

                        if Egg then

                            CurrentFullAutoStage =
                                StageName

                            local Character =
                                LocalPlayer.Character
                                or LocalPlayer.CharacterAdded:Wait()

                            local RootPart =
                                Character:FindFirstChild(
                                    "HumanoidRootPart"
                                )

                            local TargetPart =
                                Egg.PrimaryPart
                                or Egg:FindFirstChildWhichIsA(
                                    "BasePart",
                                    true
                                )

                            if RootPart
                                and TargetPart then

                                -- Teleport to random
                                -- biome's random egg.
                                RootPart.CFrame =
                                    TargetPart.CFrame
                                    + Vector3.new(
                                        0,
                                        2,
                                        0
                                    )

                                task.wait(0.2)

                                -- E DOWN
                                VirtualInputManager:SendKeyEvent(
                                    true,
                                    Enum.KeyCode.E,
                                    false,
                                    game
                                )

                                -- IMPORTANT:
                                -- Keep E held for 1 full second.
                                task.wait(1)

                                -- E UP
                                VirtualInputManager:SendKeyEvent(
                                    false,
                                    Enum.KeyCode.E,
                                    false,
                                    game
                                )

                                task.wait(0.2)

                                -- If the notification fired,
                                -- CurrentFullAutoStage has
                                -- already been blocked for
                                -- 3 minutes.
                                if not IsStageBlocked(
                                    StageName
                                ) then

                                    RootPart.CFrame =
                                        CFrame.new(
                                            0.096151,
                                            1.000000,
                                            -32.040047
                                        )

                                    task.wait(0.5)
                                end
                            end

                            CurrentFullAutoStage = nil
                        end

                    else

                        -- Every stage with eggs is currently
                        -- on its 3-minute JumpPower cooldown.
                        FullAutoStatus:SetDesc(
                            "Waiting for a biome cooldown..."
                        )

                        task.wait(0.5)
                    end

                    task.wait(0.1)
                end
            end

            -- =================================================
            -- CLEAN STOP
            -- =================================================

            CurrentFullAutoStage = nil

            if AutoEgg.Value then
                AutoEgg:SetValue(false)
            end

            if AutoWeight.Value then
                AutoWeight:SetValue(false)
            end

            VirtualInputManager:SendKeyEvent(
                false,
                Enum.KeyCode.E,
                false,
                game
            )

            FullAutoStatus:SetDesc(
                "Stopped"
            )
        end)
    end
})

-- =========================================================
-- FULL AUTO STOP
-- =========================================================

FullAutoTab:AddButton({
    Title = "Stop Full Auto Farm",
    Description =
        "Stops the current cycle",

    Callback = function()

        FullAutoRunning = false

        CurrentFullAutoStage = nil

        if AutoEgg.Value then
            AutoEgg:SetValue(false)
        end

        if AutoWeight.Value then
            AutoWeight:SetValue(false)
        end

        VirtualInputManager:SendKeyEvent(
            false,
            Enum.KeyCode.E,
            false,
            game
        )

        FullAutoStatus:SetDesc(
            "Stopped"
        )
    end
})

-- =========================================================
-- REMOVE
-- =========================================================

RemoveTab:AddButton({
    Title = "Remove Bosses",
    Description = "Remove ClientGuards",

    Callback = function()

        local Map =
            workspace:FindFirstChild(
                "Map"
            )

        if not Map then
            return
        end

        local ClientGuards =
            Map:FindFirstChild(
                "ClientGuards"
            )

        if ClientGuards then
            ClientGuards:Destroy()
        end
    end
})

-- =========================================================
-- MOVEMENT
-- =========================================================

local SelectedSpeed = 16
local SelectedJumpPower = 50

MovementTab:AddSlider(
    "SpeedSlider",
    {
        Title = "Speed",
        Description = "WalkSpeed",
        Default = 16,
        Min = 1,
        Max = 999,
        Rounding = 0
    }
):OnChanged(function(Value)

    SelectedSpeed = Value

    local Character =
        LocalPlayer.Character

    local Humanoid =
        Character
        and Character:FindFirstChildOfClass(
            "Humanoid"
        )

    if Humanoid then
        Humanoid.WalkSpeed = Value
    end
end)

MovementTab:AddSlider(
    "JumpPowerSlider",
    {
        Title = "JumpPower",
        Description = "JumpPower",
        Default = 50,
        Min = 1,
        Max = 999,
        Rounding = 0
    }
):OnChanged(function(Value)

    SelectedJumpPower = Value

    local Character =
        LocalPlayer.Character

    local Humanoid =
        Character
        and Character:FindFirstChildOfClass(
            "Humanoid"
        )

    if Humanoid then

        Humanoid.UseJumpPower = true

        Humanoid.JumpPower =
            Value
    end
end)

-- =========================================================
-- ANTI TAMPER
-- =========================================================

local AntiTamper =
    MovementTab:AddToggle(
        "AntiTamper",
        {
            Title = "Anti Tamper",
            Description =
                "Restores Speed and JumpPower every 1 second",
            Default = false
        }
    )

AntiTamper:OnChanged(function(Value)

    if not Value then
        return
    end

    task.spawn(function()

        while AntiTamper.Value do

            local Character =
                LocalPlayer.Character

            local Humanoid =
                Character
                and Character:FindFirstChildOfClass(
                    "Humanoid"
                )

            if Humanoid then

                Humanoid.WalkSpeed =
                    SelectedSpeed

                Humanoid.UseJumpPower =
                    true

                Humanoid.JumpPower =
                    SelectedJumpPower
            end

            task.wait(1)
        end
    end)
end)

-- =========================================================
-- START TAB
-- =========================================================

Window:SelectTab(1)