Implementación de Fixed Update para Movimiento de Enemigos en Unity

Clase 48 de 53 • Curso de C# para Videojuegos

Resumen

¿Por qué usar Fixed Update en lugar de Update?

Entender la importancia de utilizar FixedUpdate en lugar del tradicional Update es crucial para optimizar el rendimiento de tu videojuego, especialmente si estás manejando cálculos físicos. Update se ejecuta en cada frame, lo que, en casos de bajadas de frames, puede afectar visualmente al juego. En cambio, FixedUpdate se ejecuta a intervalos fijos, permitiendo que los cálculos de física sean más precisos y estables.

¿Cómo integrar Fixed Update en el script de un enemigo?

En este contexto, estamos ajustando el script de un enemigo para utilizar FixedUpdate, garantizando que todos los cálculos que afectan al motor de física se realicen correctamente.

void FixedUpdate()
{
    // Determinar la velocidad y dirección actual
    float currentRunningSpeed = runningSpeed;
    if (facingRight)
    {
        // Moviéndose hacia la derecha
        currentRunningSpeed = runningSpeed;
    }
    else
    {
        // Moviéndose hacia la izquierda
        currentRunningSpeed = -runningSpeed;
    }

    // Cambiar la orientación del enemigo
    transform.eulerAngles = facingRight ? new Vector3(0, 180, 0) : Vector3.zero;

    // Actualizar la velocidad solo si el juego está en progreso
    if (GameManager.instance.currentGameState == GameState.InGame)
    {
        rigidbody.velocity = new Vector2(currentRunningSpeed, rigidbody.velocity.y);
    }
}

¿Cómo afecta la dirección al movimiento del enemigo?

Una parte clave del script es cambiar la dirección en la que el enemigo se enfrenta y se mueve. Esto se determina a través del parámetro de orientación, permitiendo que el enemigo gire 180 grados cuando es necesario. Esta funcionalidad se puede observar cuando el parámetro facingRight cambia, obligando al enemigo a girar y cambiar su dirección de movimiento.

¿Qué hacer cuando el enemigo choca con obstáculos?

Al interactuar con el entorno, como al chocar con una pared, el enemigo debe cambiar de dirección. Aunque este comportamiento aún no se ha implementado en el script, es un desafío que dejamos para la mejora futura del comportamiento del enemigo.

¿Cómo observar el comportamiento del enemigo en ejecución?

Puedes observar la ejecución y ajustes sobre el enemigo utilizando el inspector de Unity. Al activar el modo de juego y seleccionar el enemigo, puedes ver cómo el script ajusta su velocidad y dirección en tiempo real. Esto te permitirá calibrar parámetros como la velocidad para optimizar el diseño del juego y hacerlo más entretenido.

¿Qué mejoras se esperan en el comportamiento del enemigo?

En clases futuras, se añadirá funcionalidad adicional al enemigo, como la interacción con obstáculos o condiciones específicas del terreno. Esto no solo mejora la jugabilidad, sino también permite un diseño de niveles más dinámico. El objetivo es que el enemigo pueda reaccionar de modo inteligente a cambios en el entorno, mejorando así la experiencia de juego.

Esta integración de elementos adicionales será clave para crear un desafío atractivo para los jugadores, manteniendo el balance y la diversión del juego.

Samar Jaffal

student•

También pueden usar esta línea de código para hacer el giro al sprite: GetComponent<SpriteRenderer>().flipX = true;

Javier Hernan Santagiuliana Gomez

student•

Hay casos donde haya alguna diferencia en hacerlo de esta manera o de la que dijo el profe?

Adrian Alexander Castro Peñaherrera

student•

Es util si solo necesitas que el sprite se voltee (solo el sprite), pero en el caso de que por ejemplo tengas algun colisionador al lado derecho del gameObject, y no decees poner otro y por ende añadir otro script; lo mejor es hacerlo de la otra forma. P.D. Ademas del

this.transform.eulerAngles = new Vector3(0, 180, 0)
...
this.transform.eulerAngles = new Vector3(0, 0, 0)

Yo recomiendo una manera mas sencilla para voltearlo:

void ToFlip()
{
	//Logica para determinar cuando voltea
	//Ejemplo
	if(xDir < 0 && facingRight == true)
	{
		Flip();
	}
	if(xDir > 0 && facingRight == false)
	{
		Flip();
	}
}

//Funcion para voltear
void Flip()
{
	facingRight = !facingRight;
	this.transform.localScale = 
	new Vector2(-transform.localScale.x, 
	transform.localScale.y);
}

Juan Carlos Frausto Arias

student•

FixedUpdate: se utiliza para actualizar el motor de física, con intervalos establecidos Esta linea de codigo sirve para girar 180º: this.transform.eulerAngles = new Vector3(0, 180, 0);

Tomas Leonardo Amaya Ríos

student•

Dirección del enemigo![](

![](

Thomas Antonio Contreras Lan

student•

Otra forma para girar el sprite al ver hacia la derecha o izquierda en lugar de los "euler angles" seria "transform.localScale" por ejemplo:

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

Al igual que otros puntos del setting del videojuego hay varias formas de querer realizar tal o cual acción, mi pregunta seria de nuevo... EulerAngles o LocalScale? :D

Richard Eduardo Lara Rueda

student•

Yo pensé exactamente lo mismo, prefiero usar el LocalScale

Alexis Duque

student•

He añadidoal script la posibilidad de esocger el tipo de movimiento del enemigo, horizontal y vertical, les dejo el código.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public enum MovementDirection
{
    horizontal,
    vertical
}

public class Enemy : MonoBehaviour
{
    public MovementDirection movementDirection = MovementDirection.horizontal;
    public bool facingRight = false;
    public bool facingUp = false;
    public float runningSpeed = 1.5f;

    Rigidbody2D rigidbody2D;
    Vector3 startPosition;

    private void Awake()
    {
        rigidbody2D = GetComponent<Rigidbody2D>();
        startPosition = this.transform.position;
    }

    // Start is called before the first frame update
    void Start()
    {
        this.transform.position = startPosition;
    }

    private void FixedUpdate()
    {
        float currentRunnningSpeed = runningSpeed;

        if (movementDirection == MovementDirection.horizontal)
        {
            rigidbody2D.constraints = RigidbodyConstraints2D.FreezePositionY;

            if (facingRight)
            {
                currentRunnningSpeed = runningSpeed;
                this.transform.eulerAngles = new Vector3(0, 180, 0);
            }
            else
            {
                currentRunnningSpeed = -runningSpeed;
                this.transform.eulerAngles = Vector3.zero;
            }
        }

        if (movementDirection == MovementDirection.vertical)
        {
            rigidbody2D.constraints = RigidbodyConstraints2D.FreezePositionX;

            if (facingUp)
            {
                currentRunnningSpeed = runningSpeed;
                this.transform.eulerAngles = new Vector3(0, 0, -90);
            }
            else
            {
                currentRunnningSpeed = -runningSpeed;
                this.transform.eulerAngles = new Vector3(0, 0, 90);
            }
        }

        if (GameManager.sharedInstance.currentGameState == GameState.inGame)
        {
            if (movementDirection == MovementDirection.horizontal)
            {
                rigidbody2D.velocity = new Vector2(currentRunnningSpeed, rigidbody2D.velocity.y);
            }

            if (movementDirection == MovementDirection.vertical)
            {
                rigidbody2D.velocity = new Vector2(rigidbody2D.velocity.x, currentRunnningSpeed);
            }
        }
    }
}

Ervic Perez Mendoza

student•

Usaremos FixedUpdate(se ejecuta a intervalos fijos de tiempo) siempre que necesitemos el motor de físicas (fuerzas, aceleraciones, velocidades) - de esta manera evitaremos tener desfaces visuales.

Luis Antonio Preza Padilla

student•

¿Entonces podríamos decir entonces que utilizar el Delta Time y el método FixedUpdate() funcionarían igual en lo que a físicas se refiere?

Adrian Alexander Castro Peñaherrera

student•

Primero, hablemos de deltaTime. Esta es una medida de tiempo en segundos que representa el tiempo que ha pasado desde el último frame. Es esencial para hacer que tus juegos sean consistentes en diferentes dispositivos y velocidades de fotogramas. Al multiplicar valores como la velocidad del movimiento por Time.deltaTime, te aseguras de que el movimiento se realice de manera suave y constante, sin importar cuántos fotogramas se muestren por segundo.

Por otro lado, FixedUpdate es un método especial en Unity que se utiliza para realizar cálculos de física y movimiento en intervalos de tiempo fijos. A diferencia de Update, que se llama una vez por cada frame, FixedUpdate se llama a una tasa constante, generalmente cada 0.02 segundos por defecto. Esto es útil para evitar problemas de física en situaciones de alta velocidad de fotogramas, donde Time.deltaTime podría ser muy pequeño y causar comportamientos inconsistentes en el movimiento.

Entonces, en resumen, deltaTime se usa para hacer que el movimiento sea suave y dependiente del tiempo, mientras que FixedUpdate se utiliza para manejar cálculos de física y movimiento en intervalos de tiempo fijos, lo que ayuda a mantener la estabilidad en el juego. No son lo mismo, pero a menudo se usan juntos para lograr un control preciso en los juegos de Unity.