How do I improve my dash in unity and not throw elements of the code around all the functions?

1. Why use an int and not simply directly store the desired vector in a

   private Vector2 dashDir;
   

   and then

   if (Input.GetKey(KeyCode.D) || Input.GetKey(KeyCode.RightArrow))
   {
       dashDir = transform.right; 
   }
   else if (Input.GetKey(KeyCode.A) || Input.GetKey(KeyCode.LeftArrow))
   {
       dashDir = -transform.right;
   }
   ...
   

   etc and later only use

   if(isDashing)
   {
       rb.velocity = dashDir * dashSpeed; 
   }
   

2. Also by configuring your axis you could probably use

   var dashDir = Vector2.ClampMagnitude(new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical")), 1f);
   

   instead of all the repeated Input checks.

   Per default the Horizontal axis refers to either the left/right keys or a/d and the Vertical refers to either up/down keys or w/s.

   

So you could actually simply do

Vector2 dashDir;

private void Update()
{
    if (Input.GetKeyDown(KeyCode.LeftShift))
    {
        shiftReplacement = true;
    }
    // the resetting of this flag is handled by the Dash itself see below
}

private void FixedUpdate()
{
    Dash();
}

private void Dash()
{
    // ignore the input if you already are dashing
    if (!isDashing)
    {
        if(shiftReplacement)
        {
            isDashing = true; //initiate dash
            currentDashTimer = startDashTime;
            rb.velocity = Vector2.zero;

            // according to your Input settings this can already cover both arrow keys and WASD, by default that is the case
            var input = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));
            // you want to limit the vector to a maximum magnitude of 1 so diagonal movement is not faster than movement on a single axis
            dashDir = Vector2.ClampMagnitude(input, 1f);
        }
    }
    else
    {
        rb.velocity = dashDir * dashSpeed; 

        // in general avoid logging too often
        //Debug.Log("bich Im dashin'");

        currentDashTimer -= Time.deltaTime;

        if (currentDashTimer <= 0)
        {
            isDashing = false;
        }
    }  

    // you probably want to handle this only exactly once
    // => instead of resetting this time based in Update rather do it right after eventually handling it here
    shiftReplacement = false;
}

I would btw then also change your Shift input and rather use a Coroutine using WaitForFixedUpdate like this

bool isDashing;

private void Update()
{
    // Ignore input when already dashing
    if (!isDashing && Input.GetKeyDown(KeyCode.LeftShift))
    {
        // Get the dash direction ONCE
        var input = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));
        var direction = Vector2.ClampMagnitude(input, 1f);
        
        // start a coroutine for dashing into this direction
        // => direction can't be changed until dashing has finished
        StartCoroutine(DashRoutine(direction));
    }
}

private void DashRoutine(Vector2 direction)
{
    // just in case if we already are dashing do nothing
    if(isDashing) yield break;

    // set dashing flag so no other concurrent routine can be started
    isDashing = true;

    // This is handy way for writing a while loop with a timer
    // basically this is executed every fixeUpdate for startDashTime seconds
    for(var timePassed = 0f; timePassed < startDashTime; timePassed += Time.deltaTime)
    {
        // wait for the next FixedUpdate call
        yield return new WaitForFixedUpdate();

        rb.velocity = direction * dashSpeed;
    }

    // finally release the flag so the next dashing can be triggered
    isDashing = false;
}

this gets rid of all your timer and direction fields entirely and bundles the behavior and variables together. Also this way you don't all the time get the FixedUpdate and Dash all even though most of time it isn't used anyway. The Coroutine only gets invoked when actually needed.

I fixed a couple of complier errors unity gave me and this is what I have now. But the code still doesn't make the player dash. What's wrong with the code? Here's the code as it is now @derHugo:

public class AltDashScript : MonoBehaviour
{
    Rigidbody2D rb;

    Vector2 dashDir;

    public float dashSpeed;
    bool isDashing;
    public float startDashTime;

    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        isDashing = false;
    }

    private void Update()
    {
        // Ignore input when already dashing
        if (!isDashing && Input.GetKeyDown(KeyCode.LeftShift))
        {
            // Get the dash direction ONCE
            var input = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));
            var direction = Vector2.ClampMagnitude(input, 1f);

            // start a coroutine for dashing into this direction
            // => direction can't be changed until dashing has finished
            StartCoroutine(DashRoutine(direction));
        }
    }
    private IEnumerator DashRoutine(Vector2 direction)
    {
        // just in case if we already are dashing do nothing
        if (isDashing) yield break;

        // set dashing flag so no other concurrent routine can be started
        isDashing = true;

        // This is handy way for writing a while loop with a timer
        // basically this is executed every fixeUpdate for startDashTime seconds
        for (var timePassed = 0f; timePassed < startDashTime; timePassed += Time.deltaTime)
        {
            // wait for the next FixedUpdate call
            yield return new WaitForFixedUpdate();

            rb.velocity = direction * dashSpeed;
        }
        Debug.Log("I should dash");

        // finally release the flag so the next dashing can be triggered
        isDashing = false;
    }
}

Thanks again for your help.