Hacer que el personaje camine

No se necesita un
if (Input.GetKeyDown(KeyCode.A) || Input.GetKeyDown(KeyCode.LeftArrow)) { }

solo con hacer eso basta
rb.velocity = new Vector2(Input.GetAxis(“Horizontal”) * speed, rb.velocity.y);

para que el personaje rote con un concepto de cursos anteriores

if (Input.GetAxis(“Horizontal”)<0){
GetComponent<SpriteRenderer>().flipX = true;
}
if (Input.GetAxis(“Horizontal”) > 0)
{
GetComponent<SpriteRenderer>().flipX = false;
}

Para hacer que el personaje voltee cuando camine necesitamos recuperar el componente SpriteRenderer del personaje y llamar a un metodo que lo voltee en X dependiendo de la velocidad del personaje.

void CharacterDirection()
    {
        if(rigidBody.velocity.x < 0)
        {
            spriteRenderer.flipX = true;
        }
        else
        {
            spriteRenderer.flipX = false;
        }
    }

A tener en cuenta.
Ya que el frame rate del Update es diferente del FixedUpdate, esto causa ciertos impedimentos al momento de ejecutar acciones.

El FixedUpdate se suele usar para Physics(Físicas), pero aquellos cálculos físicos, ya que el frame rate es estable, aunque muy diferente al real manejado.

Ya explicado esto, es recomendado usar Update para Input y FixedUpdate para ejecutar los cálculos físicos, de esta maneras evitaras malos cálculos y tendrás mas precision en lo que haces.

Un ejemplo es con el salto, puede variar mucho al momento de ejecutarlo en el Update los cálculos

 private bool isJump;

  private void Update()
    {
        isJump = Input.GetKeyDown(KeyCode.Space);
    }

    private void FixedUpdate()
    {
        if (isJump)
        {
            Jump();
        }
    }

Dejo el código que se agregó para cumplir el reto propuesto.

SpriteRenderer spriteRenderer;

void Awake() {
        rigidBody = GetComponent<Rigidbody2D>();
        animator = GetComponent<Animator>();
        spriteRenderer = GetComponent<SpriteRenderer>();
    }

void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space) || Input.GetMouseButtonDown(0))
        {
            Jump();
        }

        animator.SetBool(STATE_ON_THE_GROUND, IsTouchingTheGround());

        Debug.DrawRay(this.transform.position, Vector2.down * 1.5f, Color.red);

        CharacterDirection();

        if (Input.GetKey(KeyCode.D))
        {
            rigidBody.velocity = new Vector2(runningSpeed, //x
                rigidBody.velocity.y //y
                );
        }
        else if (Input.GetKey(KeyCode.A))
        {
            rigidBody.velocity = new Vector2(runningSpeed *-1, //x
                rigidBody.velocity.y //y
                );
        }
        else
        {
            rigidBody.velocity = new Vector2(runningSpeed * 0, //x
                rigidBody.velocity.y //y
                );
        }
    }

void CharacterDirection()
    {
        if (rigidBody.velocity.x < 0)
        {
            spriteRenderer.flipX = true;
        }
        else
        {
            spriteRenderer.flipX = false;
        }
    }

El profe explica muy bien y además nos intensiva a investigar y hacer cosas por nuestra cuenta, claro dándonos las bases. Me parece algo genial.

tenia el problema de que el personaje se deslizaba así que le agregue un else para que parara su movimiento una vez uno deje de oprimir las teclas.

<private void FixedUpdate() // un update que funciona a ritmo fijo, que no se retraza y no acelera 
    {
        if (Input.GetKey(KeyCode.RightArrow)) //Movimiento del personaje
        {
            rigidBody.velocity = new Vector2(runningSpeed, // eje x
                                             rigidBody.velocity.y // eje y
                                             );
            transform.localScale = new Vector2(1f, 1f); //agarra la escala del transform del personaje y la modifica con un nuevo vector para la animación
        }

        else if (Input.GetKey(KeyCode.LeftArrow)) //Movimineto izquierda
        {
            rigidBody.velocity = new Vector2(runningSpeed * -1, rigidBody.velocity.y);

            transform.localScale = new Vector2(-1f, 1f);
                                            
        } 

    
        else //dejar de caminar para no deslizar
        {
            rigidBody.velocity = new Vector2(runningSpeed * 0, rigidBody.velocity.y);
        }

    }>

Yo le di movilidad a mi personaje de esta forma en la cual de una vez modifico la escala del transform para hacerle flip a la animación.

<private void FixedUpdate() // un update que funciona a ritmo fijo, que no se retraza y no acelera 
    {
        if (Input.GetKey(KeyCode.RightArrow)) //Movimiento del personaje
        {
            rigidBody.velocity = new Vector2(runningSpeed, // eje x
                                             rigidBody.velocity.y // eje y
                                             );
            transform.localScale = new Vector2(1f, 1f);
        }

        if (Input.GetKey(KeyCode.LeftArrow))
        {
            rigidBody.velocity = new Vector2(runningSpeed * -1, rigidBody.velocity.y);

            transform.localScale = new Vector2(-1f, 1f);
                                            
        }

    }>

Recuerden que no se necesita que vaya de izquierda a derecha porque es un Infinity Runner, camina hacia la derecha por si solo

Estoy haciendo un videojuego al estilo de pacman por lo tanto también el personaje puede subir y bajar por todo el esceanario

¿por qué si pongo este código para que mi personaje se mueva hacia arriba, al soltar la tecla sigue subiendo indefinidamente?

else if (Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.UpArrow))
{
// moverse hacia arriba
rigidBody.velocity = new Vector2(rigidBody.velocity.x, runningSpeed);
}```

Así es como yo lo resolví

//Movimiento derecha
        if (Input.GetKey(KeyCode.RightArrow))
        {
            rigidBody.velocity = new Vector2(runningSpeed, rigidBody.velocity.y);
        }
        //Movimiento izquierda
        else if (Input.GetKey(KeyCode.LeftArrow))
        {
            rigidBody.velocity = new Vector2(runningSpeed * -1, rigidBody.velocity.y);
        }
        else 
        {
            rigidBody.velocity = new Vector2(rigidBody.velocity.x * 0, rigidBody.velocity.y);
        }

Mi solución

private void FixedUpdate()
    {
        float direction = Input.GetAxis("Horizontal");
        if(direction != 0)
        {
            rigidBody.velocity = new Vector2(direction * runningspeed, rigidBody.velocity.y);
            spriteRenderer.flipX = direction < 0 ;
        }
    }

void Awake()
{
    spriteRenderer = GetComponent<SpriteRenderer>();
}

void Update(){
horizontal = Input.GetAxisRaw(“Horizontal”);
}

void FixedUpdate()
{
    rb.velocity = new Vector2(speed * horizontal, rb.velocity.y);
    if (horizontal != 0) spriteRenderer.flipX = horizontal < 0;
}

para que el personaje se quede quieto y deje de caminar utilice la función A.enabled = false y que lo vuelva hacer a los otros los puse true

private void FixedUpdate()
{
if (Input.GetKey(KeyCode.D) || Input.GetKey(KeyCode.RightArrow))
{
rb.velocity = new Vector2(Correr, rb.velocity.y);
transform.localScale = new Vector2(1f, 1f);
A.enabled = true;
}
else if (Input.GetKey(KeyCode.LeftArrow) || Input.GetKey(KeyCode.A))
{
rb.velocity = new Vector2(-Correr, rb.velocity.y);
transform.localScale = new Vector2(-1f, 1f);
A.enabled = true;
}
else { rb.velocity = new Vector2(Correr * 0, rb.velocity.y);
A.enabled = false;
}

echo
private void FixedUpdate()
{
if(Input.GetKey(KeyCode.D) || Input.GetKey(KeyCode.RightArrow))
{
rb.velocity = new Vector2(Speed, rb.velocity.y);
transform.localScale = new Vector2(1f, 1f);
}
else if(Input.GetKey(KeyCode.LeftArrow) || Input.GetKey(KeyCode.A))
{
rb.velocity = new Vector2(Speed * -1, rb.velocity.y);
transform.localScale = new Vector2(-1f, 1f);
}
}

Hablando de fixedUpdate, ese también se suele usar para salto si esque utilizan OnCollisionEnter / OnCollisionEnter2D

Me ha gustado muchisimo este curso hasta este momento, lo recomiendo totalmente 😄

Aquí os dejo mi fragmento de código.

if(PlayerRigidbody.velocity.x <runningSpeed)
        {
            PlayerRigidbody.velocity = new Vector2(runningSpeed,
                PlayerRigidbody.velocity.y);
        }

        float movimientoH = Input.GetAxisRaw("Horizontal");
        PlayerRigidbody.velocity = new Vector3(movimientoH * runningSpeed, PlayerRigidbody.velocity.y);

        if (movimientoH > 0)
        {
            spRd.flipX = false;
        }
        else if (movimientoH < 0)
        {
            spRd.flipX = true;
        }

En mi caso decidi:

void FixedUpdate() {
	rigidBody.velocity = new Vector2(runningSpeed * Input.GetAxis("Horizontal"), rigidBody.velocity.y);
	if (rigidBody.velocity.x < 0) playerSprite.flipX = true;
	else if (rigidBody.velocity.x > 0) playerSpriye.flipX = false;
}

Esto lo que hace es mantener el sprite volteado para una direccion cuando se deja de presionar en la ultima direccion pulsada

Esta es mi solución, puedes mover el personaje de forma real para adelante y para atras

// Update is called once per frame
   void Update()
   {
       if (Input.GetKeyDown(KeyCode.Space) || Input.GetMouseButtonDown(0)) // Jump
       {
           Jump();
       }
       if (Input.GetKeyDown(KeyCode.D) || Input.GetKeyDown(KeyCode.RightArrow)) //Go to the right
       {
           GoToTheRight();
       }
       if (Input.GetKeyDown(KeyCode.A) || Input.GetKeyDown(KeyCode.LeftArrow)) //Go to the left
       {
           GoToTheLeft();
       }

       animator.SetBool(STATE_ON_THE_GROUND, IsTouchingTheGround());

       Debug.DrawRay(this.transform.position, Vector2.down * 1.5f, Color.red);
   }

   void GoToTheRight()
   {
       GetComponent<SpriteRenderer>().flipX = false;
   }

   void GoToTheLeft()
   {
       GetComponent<SpriteRenderer>().flipX = true;
   }

   void FixedUpdate()
   {
       rigibBody.velocity = new Vector2(Input.GetAxis("Horizontal") * runningSpeed, //x
                                               rigibBody.velocity.y); //y
   }

Les comparto mi pequeño aporte

void FixedUpdate()
{
    move();
}

void move()
{
    if (Input.GetKey(KeyCode.RightArrow) && rigidBody.velocity.x < runningSpeed)
    {
        rigidBody.velocity = new Vector2(runningSpeed,
                                rigidBody.velocity.y);
        GetComponent<SpriteRenderer>().flipX = false;
    }
    if (Input.GetKey(KeyCode.LeftArrow) && rigidBody.velocity.x < runningSpeed)
    {
        rigidBody.velocity = new Vector2(-runningSpeed,
                                rigidBody.velocity.y);
        GetComponent<SpriteRenderer>().flipX = true;
    }

}

Lo de el Intro no me funciona 😕

Acá mi solución al reto:

• Use “Input.GetAxis” para rescatar la tecla de movimiento, ya que funciona con flechas del teclado y “wasd”.
• Para la dirección ocupo la misma variable de velocidad, pero en el caso de querer ir en el sentido contrario, multiplico su valor por -1 para obtener el valor en negativo.
• Finalmente para voltear al personaje, utilizo el atributo “flipX” del SpriteRenderer, cambiando su valor booleano.

void Awake()
{
	rigidBody = GetComponent<Rigidbody2D>();
        animator = GetComponent<Animator>();
        spriteRenderer = GetComponent<SpriteRenderer>();
}

void FixedUpdate()
{
        MovementControl();
}

void MovementControl()
{
        float horizontalAxis = Input.GetAxis("Horizontal");

        if (horizontalAxis < 0)
        {
            rigidBody.velocity = new Vector2(runningSpeed * -1, rigidBody.velocity.y);
            spriteRenderer.flipX = true;
        }
        else if (horizontalAxis > 0)
        {
            rigidBody.velocity = new Vector2(runningSpeed, rigidBody.velocity.y);
            spriteRenderer.flipX = false;
        }
}

Reto completado haciendo que el personaje pueda voltearse

    void FixedUpdate()
    {
        Vector3 localScale = transform.localScale;
        if (Input.GetKey(KeyCode.A)) {
            rigidBody.velocity = new Vector2(-runningSpeed, rigidBody.velocity.y);
            Debug.Log(localScale.x);
            if(localScale.x > 0)
            {
                localScale.x *= -1;
                transform.localScale = localScale;
            }
        } 

        if(Input.GetKey(KeyCode.D))
        {
            rigidBody.velocity = new Vector2(runningSpeed, rigidBody.velocity.y);
            if (localScale.x < 0)
            {
                localScale.x *= -1;
                transform.localScale = localScale;
            }
        }
    }

Así fue como solucione el reto:

Aquí programe que cuando se opriman las techas “D” o “flecha derecha” se mueva hacia la derecha y cuando se oprimen las techas “A” o “flecha izquierda” se mueva a la izquierda.

Para hacer que el personaje se mueva a la izquierda convertí la variable runningSpeed en un número negativo, por eso la multiplico por -1

	//mover derecha
 	if (Input.GetKey(KeyCode.D) || Input.GetKey(KeyCode.RightArrow))
        {
            GetComponent<SpriteRenderer>().flipX = false;
            MovePlayer(runningSpeed);
        }
	//mover izquierda
        else if (Input.GetKey(KeyCode.A) || Input.GetKey(KeyCode.LeftArrow))
        {
            GetComponent<SpriteRenderer>().flipX = true;
            MovePlayer(runningSpeed * -1);
        }

este es el método de movimiento, es el mismo de la clase, lo unico que cambie es:

• que el lugar donde estaba la variable runningSpeed sea un parámetro del método MovePlayer para que facilitar la conversión a negativo de runningSpeed.

• y puse el método Mathf.Abs() que en resumen convierte números negativos en positivos. Sin este método el personaje no se movería a la izquierda, por el if del método MovePlayer.

void MovePlayer (float rS)
        {
            if (rigidBody.velocity.x < Mathf.Abs(rS))
            {
                 rigidBody.velocity = new Vector2( rS, // x
                                                  rigidBody.velocity.y //Y
                                                  );
            }
        }

void Walk()
    {
        if (rigidBody.velocity.x < runningSpeed)
        {
            var xAxisValue = Input.GetAxis("Horizontal");
            GetComponent<SpriteRenderer>().flipX = xAxisValue < 0;
            rigidBody.velocity = new Vector2(xAxisValue * runningSpeed, rigidBody.velocity.y);
        }
    }

if(Input.GetKey(KeyCode.A)) {
            spriteRenderer.flipX = true;
            rigidBody.velocity = new Vector2(-runningSpeed, rigidBody.velocity.y);

        } else if(Input.GetKey(KeyCode.D)) {
            spriteRenderer.flipX = false;
            rigidBody.velocity = new Vector2(runningSpeed, rigidBody.velocity.y);
        }

Aquí mi solución para que el personaje se mueva en el eje X y se voltee según su dirección:

Primero defino la variable del Sprite Renderer:

private SpriteRenderer playerSprite;
void Awake()
    {
        playerSprite = GetComponent<SpriteRenderer>();
    }
void FixedUpdate()
    {
        PlayerMove();
    }

Después creo la función de PlayerMove(), aquí uso la propiedad de flipX para voltear al personaje según la dirección:

void PlayerMove(){
        float horizontalMovement = Input.GetAxis("Horizontal");
        rigiBody.velocity = new Vector2(runningSpeed * horizontalMovement, rigiBody.velocity.y);
        if(horizontalMovement < 0)
        {
            playerSprite.flipX = true;
        }
        else
        {
            playerSprite.flipX = false;
        }
    }

Aquí el resultado final:

Yo asi hice el reto espero me entiendan mi codigo
Les recominedo este video que me gusto como lo explico
https://youtu.be/fh4H1bPKGfo

hola alguien sabe como hacer que el personaje se mueva de izquierda a derecha con las teclas?

if(Input.GetKeyDown(KeyCode.LeftArrow)){
if(Derecha && !Izquierda){
Izquierda = true;
Derecha = false;
flip();

        }

    }
    if(Input.GetKeyDown(KeyCode.RightArrow)){
        if (!Derecha && Izquierda)
        {
            Derecha = true;
            Izquierda = false;
            flip();
          
        }
    }

void flip(){
//GetComponent<SpriteRenderer>().flipX = false;
transform.Rotate(0, 180,0);

}

Mi solución para que puede moverse hacia ambos lados y que el personaje voltee hacia donde se mueve:

bool hasRotetedLeft = false;

void Update(){
        if (Input.GetKeyDown(KeyCode.UpArrow) || Input.GetKey(KeyCode.W)){
            Jump();
        }

        if(Input.GetKey(KeyCode.D) || Input.GetKey(KeyCode.RightArrow)){
            MoveRight();
        }

        if (Input.GetKey(KeyCode.A) || Input.GetKey(KeyCode.LeftArrow))
        {
            MoveLeft();
        }
}

void MoveRight(){
        if (rigidBody.velocity.x < runingSpeed)
        {
            if(hasRotetedLeft == true){
                spriteRenderer.flipX = false;  
            }
            rigidBody.velocity = new Vector2(runingSpeed, rigidBody.velocity.y);
        }
    }

void MoveLeft(){
        rigidBody.velocity = new Vector2(runingSpeed * -1, rigidBody.velocity.y);
        if(rigidBody.velocity.x < 0){
            spriteRenderer.flipX = true;
            hasRotetedLeft = true;
        }
        else{
            spriteRenderer.flipX = false;
        }
 }

Esta fue mi solución, deje comentado el flipX ya que esta opción NO GIRA el COLLIDER y consideré que podría ser útil en este juego:

void FixedUpdate()
{
    //MOVE RIGHT
    if (Input.GetKey(KeyCode.D) || Input.GetKey(KeyCode.RightArrow))
    {
        playerRigidBody.velocity = new Vector2(runningSpeed, playerRigidBody.velocity.y);
        //GetComponent<SpriteRenderer>().flipX = false;  //flip SPRITE NO GIRA el COLLIDER
        transform.localScale = new Vector2(1, transform.localScale.y);
    }
    //MOVE LEFT
    if (Input.GetKey(KeyCode.A) || Input.GetKeyDown(KeyCode.LeftArrow))
    {
        playerRigidBody.velocity = new Vector2(runningSpeed * -1, playerRigidBody.velocity.y);
        //GetComponent<SpriteRenderer>().flipX = true;  //flip SPRITE NO GIRA el COLLIDER
        transform.localScale = new Vector2(-1, transform.localScale.y);
    }

    private void FixedUpdate()
    {
        if(Input.GetAxis("Horizontal") != 0)
        {
            rigidBody.velocity = new Vector2(runningSpeed * Input.GetAxis("Horizontal"), rigidBody.velocity.y);
            spriteRenderer.flipX = (Input.GetAxis("Horizontal") < 0) ? true : false;
        }
    }```

mi solucion

 Vector2 playerScale = transform.localScale;
        if (Input.GetKey(KeyCode.A))//Moverse a la izquierda
        {
            playerScale.x = -1;
            rigidBody.velocity = new Vector2(runningSpeed *-1, //x
                                             rigidBody.velocity.y); //y
        }
        else if (Input.GetKey(KeyCode.D))//Moverse a la derecha
        {
            playerScale.x = 1;
            rigidBody.velocity = new Vector2(runningSpeed * 1, //x
                                             rigidBody.velocity.y); //y
           
        }
        transform.localScale = playerScale;

Para evitar que una bajada de frames que pueden afectar al movimiento físico de nuestro personaje tenemos que usar el método FixedUpdate().
FixedUpdate, va intervalos fijos y nunca se acelera. Cualquier cosa por dentro de el actúa de manera fluida

flip completo: ![](

![](![](

yo hice el control de animación con un sistema de if me funciono mejor que su código
if (Input.GetKeyDown(KeyCode.Space) || Input.GetMouseButtonDown(0))
{
GetComponent<Animator>().SetBool(“isOnTheGround”, false);
GetComponent<Animator>().SetBool(“stoped”, false);
GetComponent<Animator>().SetBool(“isAlive”, true);
}
if (Input.GetKeyUp(KeyCode.Space))
{
GetComponent<Animator>().SetBool(“isOnTheGround”, true);
GetComponent<Animator>().SetBool(“stoped”, false);
GetComponent<Animator>().SetBool(“isAlive”, true);
}
if (Input.GetKeyDown(KeyCode.E))
{
GetComponent<Animator>().SetBool(“isOnTheGround”, true);
GetComponent<Animator>().SetBool(“stoped”, true);
GetComponent<Animator>().SetBool(“isAlive”, true);
}

Excelente curso

Usen esto para que el jugador se pueda voltear

        if(rigidBody.velocity.x < 0)
        {
            transform.localScale = new Vector2(-1, transform.localScale.y);
        } else if (rigidBody.velocity.x > 0)
        {
            transform.localScale = new Vector2(1, transform.localScale.y);
        }

necesito ayuda, Al momento de saltar mi personaje baja la velocidad en que se mueve en el eje x, como puedo solucionar esto?

Mi código:

void Awake()
{
        _rigidBody = GetComponent<Rigidbody2D>();
        _animator = GetComponent<Animator>();
        _spriteRenderer = GetComponent<SpriteRenderer>();
}

void FixedUpdate()
{
        if (Input.GetAxis("Horizontal") != 0)
        {
            Move();
        }
        else
        {
            _animator.SetBool(WALK_STATE, false);
        }
}

void Move()
{
        _spriteRenderer.flipX = Input.GetAxis("Horizontal") < 0;
        _animator.SetBool(WALK_STATE, true);
        _rigidBody.velocity = new Vector2(
            Input.GetAxis("Horizontal") * _runningSpeed,
            _rigidBody.velocity.y
        );
}

Great

Este es mi codigo para que el personaje se mueva

        Rigidbody.velocity = new Vector2(Input.GetAxis("Horizontal") * SpeedMovement, Rigidbody.velocity.y);

        if(Input.GetAxis("Horizontal") == 0){
            animator.SetBool("isWalking", false);
        }
        else if(Input.GetAxis("Horizontal") > 0){
            animator.SetBool("isWalking", true);
            SpriteRenderer.flipX = false;
        }
        else if(Input.GetAxis("Horizontal") < 0){
            animator.SetBool("isWalking", true);
            SpriteRenderer.flipX = true;
        }```

Reto cumplido, logré realizarlo con el componente del SpriteRenderer.flipX

Les comparto como lo hice, lo que no se es cual es exactamente la diferencia entre llamar las acciones de movimiento dentro del método Update o el FIxedUpdate, alguien me podría aclarar esa parte porfa?

    void PlayerMovement()
    {
        _spriteRenderer.flipX = Input.GetAxis("Horizontal") < 0.0f;
        
        if (Input.GetKey(KeyCode.A))
            _playerRigidBody.velocity = new Vector2(-runningSpeed, _playerRigidBody.velocity.y);

        if (Input.GetKey(KeyCode.D))
            _playerRigidBody.velocity = new Vector2(runningSpeed, _playerRigidBody.velocity.y);
    }

Wao!! estuve intentado ver como voltear o mejor dicho invertir las animaciones y no pude hacerlo o mejor dicho no investigue lo suficiente, aunque gracias a ustede ahora se como hacerlo les dejo mi codigo como solución alternativa:

void RunningController()
    {
        if (Input.GetKeyDown(KeyCode.W) || Input.GetKeyDown(KeyCode.UpArrow))
        {
            Jump();
        }
        
        float moveX = Input.GetAxis(HORIZONTAL);

        //transform.position = new Vector2(moveX, 0f)* speed *Time.deltaTime;
        rigidBody.velocity =  new Vector2(moveX *speed, rigidBody.velocity.y);
        TurningPlayer(moveX);
    }

Basicamente utilize esta función al igual que casi todos, y aquí viene lo diferente:

void TurningPlayer(float leftOrRight)
    {
        if(leftOrRight < -1f *leftOrRight)
        {
            this.transform.localRotation = Quaternion.Euler(0f, 180f, 0f);
        }
        else
        {
            this.transform.localRotation = Quaternion.Euler(0f, 0f, 0f);
        }

    }```
Lo que hice fue rotar al personaje en sí  en vez de las animaciones
PSD: al rotar se usan quaternion porque es un termino matemático,  con el que si no me equivoco usando numeros complejos se calculan rotaciones, pero gracias a unity solo tenemos que usar esa función con los valores de cada eje.

Mi solucion al reto

void FixedUpdate()
    {
        if (Input.GetAxis("Horizontal") > 0.1f)
        {
            rigidBody2D.velocity = new Vector2(speedRun, rigidBody2D.velocity.y);
            transform.localScale = new Vector2(1f, transform.localScale.y);
        }
        else if (Input.GetAxis("Horizontal") < -0.1f)
        {
            rigidBody2D.velocity = new Vector2(speedRun * -1f, rigidBody2D.velocity.y);
            transform.localScale = new Vector2(-1f, transform.localScale.y);
        }
    }

El Input.GetAxis(“Horizontal”); Unity ya tiene configurado y trae la acción cuando se pulsa las teclas A y D y flechas de izquierda y derecha