El personaje y el controlador

1

Introducci贸n: De la idea al desarrollo

2

Estructura de carpetas en Unity

3

Assets, Game Objects y Sprite Atlas

4

Animaciones desde un sprite map

5

Animation Controller y Transiciones

6

Plataformas y gravedad

7

F铆sica en Unity

8

El script de control

9

Programando funciones en C# y Unity: Jump

10

Detectar el suelo con Raycast

11

Herramientas de debugging visual

12

Cambiar las animaciones seg煤n los estados

13

Reto: Terminando nuestras animaciones

14

Soluci贸n del reto

15

Hacer que el personaje camine

El manager del videojuego

16

C贸mo funciona el Game Manager

17

El Singleton

18

El modo de juego

19

Input manager y juegos multiplataforma

20

Correcci贸n del Bug del salto

21

La zona de muerte

22

Reiniciar la partida

23

Corrigiendo los bugs al reiniciar nuestro juego

Dise帽o procedural de niveles 2D

24

El dise帽o de niveles a mano

25

Configurando nuestros assets para el dise帽o procedural

26

Generaci贸n procedural de niveles

27

Creando la zona que eliminar谩 bloques del nivel excedentes

28

A帽adir un nuevo bloque de forma aleatoria

29

La c谩mara que sigue al jugador

30

Destrucci贸n de bloques antiguos

31

Terminando de programar la destrucci贸n de bloques antiguos

32

Solucionando el salto de la c谩mara al reiniciar el juego

HUD, men煤s y gameplay

33

El canvas en Unity

34

Uso de botones para crear un men煤

35

La l贸gica de los men煤s

36

Ejercicio: Preparando el men煤 del juego

37

Programando el men煤 del juego

38

Los coleccionables del juego

39

Actualizar UI de coleccionables

40

Iniciando con pociones y man谩

41

Pociones de vida y man谩

42

Programando las barras de vida y man谩

43

Calculando los puntajes con la distancia y el tiempo de juego

44

La l贸gica del man谩

Enemigos y dificultad

45

Plataformas m贸viles

46

Iniciar movimiento de la plataforma con trigger

47

Enemigos m贸viles

48

Enemigos m贸viles: preparando nuestro enemigo para girar

49

Enemigos m贸viles: programando que fire al chocar

50

Arreglando el collider de nuestra roca

51

Programando la condici贸n de muerte del personaje

52

A帽adiendo m煤sica de fondo a nuestro videojuego

53

A帽adiendo efectos de sonido y cierre del curso

A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Curso de C# para Videojuegos

Curso de C# para Videojuegos

Juan Gabriel Gomila

Juan Gabriel Gomila

Hacer que el personaje camine

15/53
Recursos

Aportes 49

Preguntas 5

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

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

solo con hacer eso basta
rb.velocity = new Vector2(Input.GetAxis(鈥淗orizontal鈥) * speed, rb.velocity.y);

para que el personaje rote con un concepto de cursos anteriores

if (Input.GetAxis(鈥淗orizontal鈥)<0){
GetComponent<SpriteRenderer>().flipX = true;
}
if (Input.GetAxis(鈥淗orizontal鈥) > 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(鈥淗orizontal鈥);
}

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 鈥淚nput.GetAxis鈥 para rescatar la tecla de movimiento, ya que funciona con flechas del teclado y 鈥渨asd鈥.
  • 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 鈥渇lipX鈥 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 鈥淒鈥 o 鈥渇lecha derecha鈥 se mueva hacia la derecha y cuando se oprimen las techas 鈥淎鈥 o 鈥渇lecha 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(鈥渋sOnTheGround鈥, false);
GetComponent<Animator>().SetBool(鈥渟toped鈥, false);
GetComponent<Animator>().SetBool(鈥渋sAlive鈥, true);
}
if (Input.GetKeyUp(KeyCode.Space))
{
GetComponent<Animator>().SetBool(鈥渋sOnTheGround鈥, true);
GetComponent<Animator>().SetBool(鈥渟toped鈥, false);
GetComponent<Animator>().SetBool(鈥渋sAlive鈥, true);
}
if (Input.GetKeyDown(KeyCode.E))
{
GetComponent<Animator>().SetBool(鈥渋sOnTheGround鈥, true);
GetComponent<Animator>().SetBool(鈥渟toped鈥, true);
GetComponent<Animator>().SetBool(鈥渋sAlive鈥, 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(鈥淗orizontal鈥); Unity ya tiene configurado y trae la acci贸n cuando se pulsa las teclas A y D y flechas de izquierda y derecha