-- EVADE Ultimate Script v4.0
-- Features: Bunnyhop + Speed Changer + Simple ESP
-- Optimized for performance - No lag
-- All code and comments in English

local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")
local RunService = game:GetService("RunService")
local Workspace = game:GetService("Workspace")
local Camera = Workspace.CurrentCamera
local CollectionService = game:GetService("CollectionService")

local LocalPlayer = Players.LocalPlayer
local Character = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()
local Humanoid = Character:WaitForChild("Humanoid")
local HumanoidRootPart = Character:WaitForChild("HumanoidRootPart")

-- CONFIGURATION
local CONFIG = {
    -- Bunnyhop Settings
    BunnyhopEnabled = false,
    BunnyhopKey = Enum.KeyCode.Q,
    JumpPower = 45, -- Lower for anti-cheat (default is 50)
    JumpDelay = 0.04,
    
    -- Speed Changer Settings
    SpeedEnabled = false,
    SpeedKey = Enum.KeyCode.Q, -- Same as bunnyhop toggle
    SpeedBonus = 10, -- +10 speed (26 total, default is 16)
    BaseWalkSpeed = 16,
    
    -- ESP Settings
    ESPEnabled = false,
    ESPKey = Enum.KeyCode.T,
    ESPUpdateRate = 0.2, -- Update every 0.2 seconds (5 FPS) - prevents lag
    MaxDistance = 300,
    
    -- Anti-Cheat
    Randomization = true,
}

-- State variables
local LastJump = 0
local ESPItems = {} -- Table to store ESP objects
local LastESPUpdate = 0

-- Utility Functions
local function RandomizeValue(value, percentage)
    if not CONFIG.Randomization then return value end
    local variance = value * (percentage / 100)
    return value + (math.random() * variance * 2 - variance)
end

local function IsPlayerGrounded()
    if not HumanoidRootPart then return false end
    
    local raycastParams = RaycastParams.new()
    raycastParams.FilterDescendantsInstances = {Character}
    raycastParams.FilterType = Enum.RaycastFilterType.Blacklist
    
    local result = Workspace:Raycast(
        HumanoidRootPart.Position, 
        Vector3.new(0, -3, 0), 
        raycastParams
    )
    
    return result ~= nil or Humanoid.FloorMaterial ~= Enum.Material.Air
end

local function GetPlayerSpeed()
    if not HumanoidRootPart then return 0 end
    local velocity = HumanoidRootPart.Velocity
    return math.floor(Vector3.new(velocity.X, 0, velocity.Z).Magnitude)
end

-- BUNNYHOP FUNCTION
local function PerformJump()
    local currentTime = tick()
    if currentTime - LastJump < RandomizeValue(CONFIG.JumpDelay, 10) then return end
    if not IsPlayerGrounded() then return end
    
    LastJump = currentTime
    
    -- Set lower jump power for anti-cheat safety
    Humanoid.JumpPower = CONFIG.JumpPower
    
    -- Perform jump using multiple methods (anti-cheat bypass)
    local jumpMethods = {
        function() Humanoid:ChangeState(Enum.HumanoidStateType.Jumping) end,
        function() Humanoid.Jump = true end,
    }
    
    -- Select random method
    local selectedMethod = jumpMethods[math.random(1, #jumpMethods)]
    selectedMethod()
    
    -- Apply small velocity boost for momentum
    if HumanoidRootPart then
        local lookVector = HumanoidRootPart.CFrame.LookVector
        local boost = Vector3.new(lookVector.X * 6, 0, lookVector.Z * 6)
        HumanoidRootPart.Velocity = HumanoidRootPart.Velocity + boost
    end
end

-- AUTO-STRAFE FUNCTION (A/D + W for better velocity)
local function PerformAutoStrafe()
    if not Humanoid then return end
    
    -- Alternate between A and D for air strafing
    local time = tick()
    local direction = (math.floor(time * 10) % 2 == 0) and 1 or -1
    
    -- Move with W + A/D combination for maximum velocity
    -- This creates the "strafing" effect that increases speed
    local moveDirection = Vector3.new(direction * 0.3, 0, 1)
    Humanoid:Move(moveDirection, false)
    
    -- Tip: Holding W + alternating A/D gives best velocity!
end

-- SPEED CHANGER FUNCTION
local function UpdateSpeed()
    if not Humanoid then return end
    
    if CONFIG.SpeedEnabled then
        -- Add +10 to base speed (16 + 10 = 26)
        Humanoid.WalkSpeed = CONFIG.BaseWalkSpeed + CONFIG.SpeedBonus
    else
        -- Reset to default
        Humanoid.WalkSpeed = CONFIG.BaseWalkSpeed
    end
end

-- SIMPLIFIED ESP SYSTEM (Optimized - No Lag)
local function CreateNextbotESP(nextbotModel)
    if ESPItems[nextbotModel] then return end
    
    -- Create Highlight (Roblox built-in, very optimized)
    local highlight = Instance.new("Highlight")
    highlight.Name = "NextbotHighlight"
    highlight.FillColor = Color3.fromRGB(255, 0, 0) -- Red
    highlight.OutlineColor = Color3.fromRGB(255, 255, 255) -- White outline
    highlight.FillTransparency = 0.5
    highlight.OutlineTransparency = 0
    highlight.Parent = nextbotModel
    
    -- Create simple distance label
    local billboard = Instance.new("BillboardGui")
    billboard.Name = "DistanceLabel"
    billboard.Size = UDim2.new(0, 100, 0, 30)
    billboard.StudsOffset = Vector3.new(0, 2, 0)
    billboard.AlwaysOnTop = true
    billboard.MaxDistance = CONFIG.MaxDistance
    
    local textLabel = Instance.new("TextLabel")
    textLabel.Name = "DistanceText"
    textLabel.Size = UDim2.new(1, 0, 1, 0)
    textLabel.BackgroundTransparency = 1
    textLabel.Text = "0m"
    textLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
    textLabel.TextSize = 14
    textLabel.Font = Enum.Font.GothamBold
    textLabel.TextStrokeTransparency = 0.5
    textLabel.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
    textLabel.Parent = billboard
    
    billboard.Parent = nextbotModel
    
    -- Store reference
    ESPItems[nextbotModel] = {
        Highlight = highlight,
        Billboard = billboard,
        TextLabel = textLabel,
        Model = nextbotModel
    }
end

local function RemoveNextbotESP(nextbotModel)
    local esp = ESPItems[nextbotModel]
    if esp then
        if esp.Highlight then esp.Highlight:Destroy() end
        if esp.Billboard then esp.Billboard:Destroy() end
        ESPItems[nextbotModel] = nil
    end
end

local function FindNextbots()
    if not CONFIG.ESPEnabled then return end
    
    -- Look for nextbots in workspace
    -- Nextbots are NPC models with Humanoid that aren't players
    for _, object in ipairs(Workspace:GetDescendants()) do
        if object:IsA("Model") and object:FindFirstChildOfClass("Humanoid") then
            -- Check if it's not a player character
            if object ~= Character and not Players:GetPlayerFromCharacter(object) then
                local humanoid = object:FindFirstChildOfClass("Humanoid")
                
                -- Verify it's alive and likely a nextbot
                if humanoid and humanoid.Health > 0 then
                    -- Check if already has ESP
                    if not ESPItems[object] then
                        CreateNextbotESP(object)
                    end
                end
            end
        end
    end
    
    -- Clean up dead nextbots
    for model, esp in pairs(ESPItems) do
        if not model or not model.Parent then
            RemoveNextbotESP(model)
        else
            local humanoid = model:FindFirstChildOfClass("Humanoid")
            if not humanoid or humanoid.Health <= 0 then
                RemoveNextbotESP(model)
            end
        end
    end
end

local function UpdateESP()
    if not CONFIG.ESPEnabled then return end
    
    local playerPos = HumanoidRootPart and HumanoidRootPart.Position or Vector3.new()
    
    for model, esp in pairs(ESPItems) do
        if not model or not model.Parent then
            RemoveNextbotESP(model)
            continue
        end
        
        -- Calculate distance
        local nextbotPos = model:GetPivot().Position
        local distance = (nextbotPos - playerPos).Magnitude
        local meters = math.floor(distance / 3.571) -- Convert studs to meters
        
        -- Update distance text
        if esp.TextLabel then
            esp.TextLabel.Text = string.format("%dm", meters)
            
            -- Change color based on distance
            if distance < 50 then
                esp.TextLabel.TextColor3 = Color3.fromRGB(255, 0, 0) -- Close = Red
                esp.Highlight.FillColor = Color3.fromRGB(255, 0, 0)
            elseif distance < 150 then
                esp.TextLabel.TextColor3 = Color3.fromRGB(255, 255, 0) -- Medium = Yellow
                esp.Highlight.FillColor = Color3.fromRGB(255, 255, 0)
            else
                esp.TextLabel.TextColor3 = Color3.fromRGB(0, 255, 100) -- Far = Green
                esp.Highlight.FillColor = Color3.fromRGB(0, 255, 100)
            end
        end
    end
end

-- GUI CREATION
local ScreenGui = Instance.new("ScreenGui")
ScreenGui.Name = "EVADE_Ultimate_v4"
ScreenGui.ResetOnSpawn = false

-- Main Frame
local MainFrame = Instance.new("Frame")
MainFrame.Size = UDim2.new(0, 300, 0, 200)
MainFrame.Position = UDim2.new(0, 20, 0.5, -100)
MainFrame.BackgroundColor3 = Color3.fromRGB(25, 25, 35)
MainFrame.BorderSizePixel = 0
MainFrame.Parent = ScreenGui

local UICorner = Instance.new("UICorner")
UICorner.CornerRadius = UDim.new(0, 10)
UICorner.Parent = MainFrame

local UIStroke = Instance.new("UIStroke")
UIStroke.Color = Color3.fromRGB(0, 255, 150)
UIStroke.Thickness = 2
UIStroke.Parent = MainFrame

-- Title
local TitleLabel = Instance.new("TextLabel")
TitleLabel.Size = UDim2.new(1, -20, 0, 30)
TitleLabel.Position = UDim2.new(0, 10, 0, 10)
TitleLabel.BackgroundTransparency = 1
TitleLabel.Text = "EVADE Ultimate v4.0"
TitleLabel.TextColor3 = Color3.fromRGB(0, 255, 150)
TitleLabel.TextSize = 20
TitleLabel.Font = Enum.Font.GothamBold
TitleLabel.TextXAlignment = Enum.TextXAlignment.Left
TitleLabel.Parent = MainFrame

-- Bunnyhop Status
local BunnyhopLabel = Instance.new("TextLabel")
BunnyhopLabel.Size = UDim2.new(1, -20, 0, 25)
BunnyhopLabel.Position = UDim2.new(0, 10, 0, 50)
BunnyhopLabel.BackgroundColor3 = Color3.fromRGB(40, 40, 50)
BunnyhopLabel.Text = "Bunnyhop + Speed: OFF [Q]"
BunnyhopLabel.TextColor3 = Color3.fromRGB(255, 100, 100)
BunnyhopLabel.TextSize = 14
BunnyhopLabel.Font = Enum.Font.GothamBold
BunnyhopLabel.Parent = MainFrame

local Corner1 = Instance.new("UICorner")
Corner1.CornerRadius = UDim.new(0, 6)
Corner1.Parent = BunnyhopLabel

-- ESP Status
local ESPLabel = Instance.new("TextLabel")
ESPLabel.Size = UDim2.new(1, -20, 0, 25)
ESPLabel.Position = UDim2.new(0, 10, 0, 85)
ESPLabel.BackgroundColor3 = Color3.fromRGB(40, 40, 50)
ESPLabel.Text = "ESP: OFF [T]"
ESPLabel.TextColor3 = Color3.fromRGB(255, 100, 100)
ESPLabel.TextSize = 14
ESPLabel.Font = Enum.Font.GothamBold
ESPLabel.Parent = MainFrame

local Corner2 = Instance.new("UICorner")
Corner2.CornerRadius = UDim.new(0, 6)
Corner2.Parent = ESPLabel

-- Speed Display
local SpeedLabel = Instance.new("TextLabel")
SpeedLabel.Size = UDim2.new(0.5, -15, 0, 25)
SpeedLabel.Position = UDim2.new(0, 10, 0, 120)
SpeedLabel.BackgroundColor3 = Color3.fromRGB(40, 40, 50)
SpeedLabel.Text = "Speed: 0"
SpeedLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
SpeedLabel.TextSize = 14
SpeedLabel.Font = Enum.Font.GothamBold
SpeedLabel.Parent = MainFrame

local Corner3 = Instance.new("UICorner")
Corner3.CornerRadius = UDim.new(0, 6)
Corner3.Parent = SpeedLabel

-- Nextbot Count
local CountLabel = Instance.new("TextLabel")
CountLabel.Size = UDim2.new(0.5, -15, 0, 25)
CountLabel.Position = UDim2.new(0.5, 5, 0, 120)
CountLabel.BackgroundColor3 = Color3.fromRGB(40, 40, 50)
CountLabel.Text = "Nextbots: 0"
CountLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
CountLabel.TextSize = 14
CountLabel.Font = Enum.Font.GothamBold
CountLabel.Parent = MainFrame

local Corner4 = Instance.new("UICorner")
Corner4.CornerRadius = UDim.new(0, 6)
Corner4.Parent = CountLabel

-- Tips Label
local TipsLabel = Instance.new("TextLabel")
TipsLabel.Size = UDim2.new(1, -20, 0, 40)
TipsLabel.Position = UDim2.new(0, 10, 0, 155)
TipsLabel.BackgroundTransparency = 1
TipsLabel.Text = "TIP: Hold W + alternate A/D for max velocity!"
TipsLabel.TextColor3 = Color3.fromRGB(255, 200, 100)
TipsLabel.TextSize = 11
TipsLabel.Font = Enum.Font.Gotham
TipsLabel.TextWrapped = true
TipsLabel.Parent = MainFrame

ScreenGui.Parent = LocalPlayer.PlayerGui

-- TOGGLE FUNCTIONS
local function ToggleBunnyhopAndSpeed()
    CONFIG.BunnyhopEnabled = not CONFIG.BunnyhopEnabled
    CONFIG.SpeedEnabled = CONFIG.BunnyhopEnabled -- Enable both together
    
    if CONFIG.BunnyhopEnabled then
        BunnyhopLabel.Text = "Bunnyhop + Speed: ON [Q]"
        BunnyhopLabel.TextColor3 = Color3.fromRGB(100, 255, 100)
        
        -- Apply settings
        if Humanoid then
            Humanoid.JumpPower = CONFIG.JumpPower
        end
        UpdateSpeed()
    else
        BunnyhopLabel.Text = "Bunnyhop + Speed: OFF [Q]"
        BunnyhopLabel.TextColor3 = Color3.fromRGB(255, 100, 100)
        
        -- Reset settings
        if Humanoid then
            Humanoid.JumpPower = 50 -- Default
            Humanoid.WalkSpeed = CONFIG.BaseWalkSpeed
        end
    end
end

local function ToggleESP()
    CONFIG.ESPEnabled = not CONFIG.ESPEnabled
    
    if CONFIG.ESPEnabled then
        ESPLabel.Text = "ESP: ON [T]"
        ESPLabel.TextColor3 = Color3.fromRGB(100, 255, 100)
        FindNextbots() -- Initial find
    else
        ESPLabel.Text = "ESP: OFF [T]"
        ESPLabel.TextColor3 = Color3.fromRGB(255, 100, 100)
        
        -- Clear all ESP
        for model, _ in pairs(ESPItems) do
            RemoveNextbotESP(model)
        end
    end
end

-- INPUT HANDLING
UserInputService.InputBegan:Connect(function(input, gameProcessed)
    if gameProcessed then return end
    
    if input.KeyCode == CONFIG.BunnyhopKey then
        ToggleBunnyhopAndSpeed()
    elseif input.KeyCode == CONFIG.ESPKey then
        ToggleESP()
    end
end)

-- MAIN LOOP (Heartbeat for bunnyhop, slower for ESP)
RunService.Heartbeat:Connect(function()
    -- Update speed display
    SpeedLabel.Text = "Speed: " .. GetPlayerSpeed()
    
    -- Bunnyhop and speed logic
    if CONFIG.BunnyhopEnabled then
        PerformJump()
        PerformAutoStrafe()
    end
    
    -- ESP Update (throttled to prevent lag)
    local currentTime = tick()
    if currentTime - LastESPUpdate >= CONFIG.ESPUpdateRate then
        LastESPUpdate = currentTime
        
        if CONFIG.ESPEnabled then
            FindNextbots()
            UpdateESP()
        end
        
        -- Update count
        local count = 0
        for _ in pairs(ESPItems) do count = count + 1 end
        CountLabel.Text = "Nextbots: " .. count
    end
end)

-- CHARACTER RESPAWN HANDLER
LocalPlayer.CharacterAdded:Connect(function(newCharacter)
    Character = newCharacter
    Humanoid = newCharacter:WaitForChild("Humanoid")
    HumanoidRootPart = newCharacter:WaitForChild("HumanoidRootPart")
    
    -- Clear old ESP
    for model, _ in pairs(ESPItems) do
        RemoveNextbotESP(model)
    end
    
    -- Reapply settings if enabled
    if CONFIG.BunnyhopEnabled then
        task.wait(0.3)
        Humanoid.JumpPower = CONFIG.JumpPower
        UpdateSpeed()
    end
end)

-- INITIALIZATION
print("========================================")
print("EVADE Ultimate v4.0 Loaded Successfully!")
print("Features:")
print("  - Bunnyhop (Low Jump - Anti-Cheat Safe)")
print("  - Speed Changer (+10 Speed)")
print("  - Simple ESP (Highlight + Distance)")
print("Controls:")
print("  Q = Toggle Bunnyhop + Speed")
print("  T = Toggle ESP")
print("TIP: Hold W + alternate A/D for best velocity!")
print("========================================")