-- No Dash Cooldown Script
-- Removes the cooldown from the dash system

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

local LocalPlayer = Players.LocalPlayer

-- Function to find objects in garbage collection
local function findInGC(className, name)
    for _, obj in pairs(getgc(true)) do
        if typeof(obj) == "Instance" and obj.ClassName == className then
            if not name or obj.Name == name then
                return obj
            end
        end
    end
    return nil
end

-- Try to find dash objects
local DashRemote = ReplicatedStorage:FindFirstChild("DashRemote") or findInGC("RemoteEvent", "DashRemote")
local DashAnimations = ReplicatedStorage:FindFirstChild("DashAnimations")

if not DashRemote then
    warn("DashRemote not found!")
    return
end

if not DashAnimations then
    warn("DashAnimations not found!")
    return
end

print("Dash objects found successfully!")

-- No cooldown dash function
local function performDash()
    local character = LocalPlayer.Character
    if not character then return end
    
    local humanoidRootPart = character:FindFirstChild("HumanoidRootPart")
    local humanoid = character:FindFirstChild("Humanoid")
    
    if not humanoidRootPart or not humanoid then return end
    
    -- Check if player is blocking (original condition)
    if LocalPlayer:GetAttribute("Blocking") == true then
        return
    end
    
    -- Get movement direction
    local moveVector = humanoid.MoveDirection
    local unit = Vector3.new(moveVector.X, 0, moveVector.Z).Unit
    
    if unit.Magnitude > 0 then
        -- Create BodyPosition for dash movement
        local bodyPosition = Instance.new("BodyPosition", humanoidRootPart)
        game.Debris:AddItem(bodyPosition, 0.5)
        
        bodyPosition.MaxForce = Vector3.new(100000, 0, 100000)
        bodyPosition.P = 65000
        bodyPosition.D = 3000
        
        -- Set dash target position
        bodyPosition.Position = humanoidRootPart.Position + unit * 125
        
        -- Determine which animation to play based on input
        local dashAnimation = DashAnimations.Front -- Default
        
        if UserInputService:IsKeyDown(Enum.KeyCode.D) then
            dashAnimation = DashAnimations.Right
        elseif UserInputService:IsKeyDown(Enum.KeyCode.A) then
            dashAnimation = DashAnimations.Left
        elseif UserInputService:IsKeyDown(Enum.KeyCode.S) then
            dashAnimation = DashAnimations.Back
        end
        
        -- Play dash animation
        if dashAnimation and humanoid.Animator then
            local animTrack = humanoid.Animator:LoadAnimation(dashAnimation)
            animTrack:Play()
            
            -- Adjust animation speed
            if dashAnimation == DashAnimations.Front then
                animTrack:AdjustSpeed(4)
            elseif dashAnimation == DashAnimations.Right or dashAnimation == DashAnimations.Left then
                animTrack:AdjustSpeed(4)
            elseif dashAnimation == DashAnimations.Back then
                animTrack:AdjustSpeed(2)
            end
            
            -- Clean up BodyPosition after animation starts
            game.Debris:AddItem(bodyPosition, 0.2)
        end
        
        -- Fire the dash remote to server
        DashRemote:FireServer(character, bodyPosition.Position, unit)
        
        -- Optional: FOV effect (visual only)
        local camera = workspace.CurrentCamera
        if camera then
            camera.FieldOfView = 65
            task.wait(0.15)
            camera.FieldOfView = 50
        end
        
        print("Dash executed - No cooldown!")
    end
end

-- Connect input events for no cooldown dashing
UserInputService.InputBegan:Connect(function(input, gameProcessed)
    if gameProcessed then return end
    
    -- Check for Q key or ButtonX (original dash keys)
    if input.KeyCode == Enum.KeyCode.Q or input.KeyCode == Enum.KeyCode.ButtonX then
        performDash()
    end
end)

-- Alternative: Spam dash function (hold key to continuously dash)
local spamDashEnabled = false

local function toggleSpamDash()
    spamDashEnabled = not spamDashEnabled
    if spamDashEnabled then
        print("Spam dash enabled! Hold Q to continuously dash")
        task.spawn(function()
            while spamDashEnabled do
                if UserInputService:IsKeyDown(Enum.KeyCode.Q) then
                    performDash()
                end
                task.wait(0.1) -- Small delay to prevent excessive spam
            end
        end)
    else
        print("Spam dash disabled")
    end
end

-- Keybind to toggle spam dash (F key)
UserInputService.InputBegan:Connect(function(input, gameProcessed)
    if gameProcessed then return end
    
    if input.KeyCode == Enum.KeyCode.F then
        toggleSpamDash()
    end
end)

-- Hook the original dash function to remove cooldown
local function hookOriginalDash()
    for _, connection in pairs(getconnections(UserInputService.InputBegan)) do
        if connection.Function then
            local oldFunction = connection.Function
            connection:Disconnect()
            
            UserInputService.InputBegan:Connect(function(input, gameProcessed)
                if gameProcessed then return end
                
                if input.KeyCode == Enum.KeyCode.Q or input.KeyCode == Enum.KeyCode.ButtonX then
                    -- Call modified version without cooldown
                    performDash()
                else
                    -- Call original function for other inputs
                    pcall(oldFunction, input, gameProcessed)
                end
            end)
            
            print("Original dash function hooked successfully!")
            break
        end
    end
end

-- Try to hook original function
pcall(hookOriginalDash)

-- Expose functions globally
getgenv().PerformDash = performDash
getgenv().ToggleSpamDash = toggleSpamDash

print("No Dash Cooldown Script Loaded!")
print("- Q/ButtonX: Dash with no cooldown")
print("- F: Toggle spam dash mode")
print("- Use getgenv().PerformDash() to dash manually")
print("- Use getgenv().ToggleSpamDash() to toggle spam mode")