Dash Script with Afterimages

 Players = :()
 UserInputService = :()
 RunService = :()
 CollectionService = :()


 DASH_KEY = .KeyCode.Q
 INITIAL_DASH_POWER =     
 DASH_DURATION =        
 DASH_COOLDOWN = 
 MIN_VELOCITY = 
 TURN_SPEED =           
 DECELERATION =         
 START_DELAY =         
 STOP_POINT =         
 SLOWDOWN_START =     
 STOP_DURATION =      
 AFTERIMAGE_TRANSPARENCY =       
 AFTERIMAGE_LIFETIME =      
 AFTERIMAGE_INTERVAL =     
 DASH_COLOR = .(, , )  
 USE_ORIGINAL_COLORS =          
 SANDEVISTAN_MODE =         
 SANDEVISTAN_COLORS = {
    .(, , ),    
    .(, , ),    
    .(, , ),      
    .(, , ),    
    .(, , )       
}
 MAX_AFTERIMAGES =          
 CHROMATIC_OFFSET =          


 LocalPlayer = Players.LocalPlayer
 Character = LocalPlayer.Character  LocalPlayer.CharacterAdded:()
 Humanoid = Character:()
 Root = Character:()
 Camera = .CurrentCamera

 canDash = 
 isDashing = 
 dashVelocity = .(, , )
 initialDashDir = .(, , )


 effectsFolder = .()
effectsFolder.Name = 
effectsFolder.Parent = 


  ()
     moveDir = Humanoid.MoveDirection
    
    
     moveDir.Magnitude ==  
         camLook = Camera.CFrame.LookVector
        moveDir = .(camLook.X, , camLook.Z)
    
    
     moveDir.Unit



  (index, total)
    
    index = total - index + 
    
     colorCount = #SANDEVISTAN_COLORS
     position = ((index-) / (total-)) * (colorCount-)
     colorIndex = .(position) + 
     nextColorIndex = .(colorIndex + , colorCount)
     lerpAmount = position - .(position)
    
     color1 = SANDEVISTAN_COLORS[colorIndex]
     color2 = SANDEVISTAN_COLORS[nextColorIndex]
    
    
     .(
        color1.R + (color2.R - color1.R) * lerpAmount,
        color1.G + (color2.G - color1.G) * lerpAmount,
        color1.B + (color2.B - color1.B) * lerpAmount
    )



  (character, afterimageCount)
     clone = .()
    clone.Name = 
    
     rootPart = character:()
      rootPart   
    
     rootCFrame = rootPart.CFrame
    
     _, part  (character:()) 
         part:()  part.Transparency <  
             clonePart = part:()
            
            
             _, child  (clonePart:()) 
                  child:()  
                    child:()  
                    child:() 
                    child:()
                
            
            
            
            clonePart.CanCollide = 
            clonePart.CanQuery = 
            clonePart.CanTouch = 
            clonePart.Anchored = 
            
             SANDEVISTAN_MODE 
                clonePart.Material = .Material.Neon
                
                clonePart.Color = (afterimageCount, MAX_AFTERIMAGES)
                clonePart.Transparency = AFTERIMAGE_TRANSPARENCY
            
                 USE_ORIGINAL_COLORS 
                    clonePart.Transparency = AFTERIMAGE_TRANSPARENCY
                
                    clonePart.Transparency = AFTERIMAGE_TRANSPARENCY
                    clonePart.Color = .(, , )
                    clonePart.Material = .Material.Neon
                
            
            
            CollectionService:(clonePart, )
            
            clonePart.CFrame = rootCFrame:(rootPart.CFrame:(part.CFrame))
            clonePart.Parent = clone
        
    
    
    clone.Parent = effectsFolder
    
    
    :():(clone, AFTERIMAGE_LIFETIME)
    
    
     startTime = ()
     connection
    connection = RunService.Heartbeat:(()
         elapsed = () - startTime
         elapsed >= AFTERIMAGE_LIFETIME 
            connection:()
            
        
        
         fadeProgress = elapsed / AFTERIMAGE_LIFETIME
         _, part  (clone:()) 
             part:() 
                part.Transparency = AFTERIMAGE_TRANSPARENCY + (( - AFTERIMAGE_TRANSPARENCY) * fadeProgress)
            
        
    )



  ()
     ring = .()
    ring.Size = .(, , )
    ring.Transparency = 
    ring.CanCollide = 
    ring.CanQuery = 
    ring.CanTouch = 
    ring.Anchored = 
    ring.Material = .Material.Neon
    ring.Color = DASH_COLOR
    CollectionService:(ring, )
    
    
     mesh = .()
    mesh.MeshType = .MeshType.FileMesh
    mesh.MeshId =   
    mesh.Scale = .(, , )
    mesh.Parent = ring
    
    ring.Parent = effectsFolder
    
    
     tweenInfo = TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out)
     tween = :():(mesh, tweenInfo, {
        Scale = .(, , )
    })
    tween:()
    
    
     fadeTween = :():(ring, tweenInfo, {
        Transparency = 
    })
    fadeTween:()
    
    :():(ring, )
     ring



  ()
      canDash  isDashing   
    
    
    canDash = 
    isDashing = 
    dashVelocity = .(, , )
    
    
    ()  
    
    
    initialDashDir = ()
    
    
     dashEffect = .()
    dashEffect.Color = ColorSequence.(.(, , ))
    dashEffect.Transparency = NumberSequence.()
    dashEffect.Lifetime = 
    CollectionService:(dashEffect, )
    
     attachment0 = .()
     attachment1 = .()
    attachment0.Position = .(, -, )
    attachment1.Position = .(, , )
    
    CollectionService:(attachment0, )
    CollectionService:(attachment1, )
    
    attachment0.Parent = Root
    attachment1.Parent = Root
    dashEffect.Attachment0 = attachment0
    dashEffect.Attachment1 = attachment1
    dashEffect.Parent = Root
    
     lastAfterimage = 
     afterimageCount = 
    
    
     dashStart = ()
     connection
    connection = RunService.Heartbeat:((delta)
          isDashing 
            connection:()
            dashEffect:()
            attachment0:()
            attachment1:()
            
        
        
         elapsed = () - dashStart
        
        
         elapsed >= START_DELAY / DASH_DURATION   
           () - lastAfterimage >= AFTERIMAGE_INTERVAL 
            afterimageCount = (afterimageCount % MAX_AFTERIMAGES) + 
            (Character, afterimageCount)
            lastAfterimage = ()
        
        
        
         elapsed >= DASH_DURATION 
            
            
            
            isDashing = 
            connection:()
            dashEffect:()
            attachment0:()
            attachment1:()
            
            
             Humanoid 
                Humanoid.WalkSpeed =   
                .(STOP_DURATION, ()
                     Humanoid 
                        Humanoid.WalkSpeed =   
                        
                        .(DASH_COOLDOWN, ()
                            canDash = 
                        )
                    
                )
            
            
        
        
        
         progress = elapsed / DASH_DURATION
        
        
         currentDir = ()
        
        
         progress < START_DELAY / DASH_DURATION 
            
            dashVelocity = .(, , )
         progress < STOP_POINT 
            
             accelerationProgress = (progress - START_DELAY / DASH_DURATION) / (STOP_POINT - START_DELAY / DASH_DURATION)
             speedFactor = accelerationProgress * ( - accelerationProgress)  
             targetVelocity = currentDir * (INITIAL_DASH_POWER * speedFactor)
            dashVelocity = dashVelocity:(targetVelocity, TURN_SPEED * delta * )
         progress < SLOWDOWN_START 
            
             targetVelocity = currentDir * INITIAL_DASH_POWER
            dashVelocity = dashVelocity:(targetVelocity, TURN_SPEED * delta * )
        
            
             slowdownProgress = (progress - SLOWDOWN_START) / ( - SLOWDOWN_START)
             slowdownFactor = ( - slowdownProgress) ^ 
             targetVelocity = currentDir * (INITIAL_DASH_POWER * slowdownFactor)
            dashVelocity = dashVelocity:(targetVelocity, TURN_SPEED * delta * )
        
        
        
         Root 
            
            Root.CFrame = Root.CFrame + dashVelocity * delta
            
            
             dashVelocity.Magnitude > MIN_VELOCITY 
                 lookAt = Root.Position + dashVelocity.Unit
                Root.CFrame = .(Root.Position, .(lookAt.X, Root.Position.Y, lookAt.Z))
            
        
    )



 isKeyDown = 
UserInputService.InputBegan:((input, gameProcessed)
      gameProcessed  input.KeyCode == DASH_KEY 
        isKeyDown = 
        ()  
    
)

UserInputService.InputEnded:((input, gameProcessed)
     input.KeyCode == DASH_KEY 
        isKeyDown = 
    
)


LocalPlayer.CharacterAdded:((newCharacter)
    Character = newCharacter
    Humanoid = Character:()
    Root = Character:()
    canDash = 
    isDashing = 
    
    
     _, effect  (CollectionService:()) 
        effect:()
    
)


  ()
     screenGui = .()
     frame = .()
     text = .()
    
    screenGui.Parent = LocalPlayer.PlayerGui
    
    frame.Size = .(, , , )
    frame.Position = .(, -, , -)
    frame.BackgroundTransparency = 
    frame.BackgroundColor3 = .(, , )
    frame.Parent = screenGui
    
    text.Size = .(, , , )
    text.BackgroundTransparency = 
    text.TextColor3 = .(, , )
    text.Text = 
    text.Parent = frame
    
    RunService.Heartbeat:(()
        text.Text = canDash    
    )


()

()
()