Matemáticas para juegos: vectores

¿Cómo aplicar matemáticas en videojuegos?

La matemática puede parecer intimidante, pero aplicarla en videojuegos es una herramienta poderosa que nos permite crear experiencias dinámicas y realistas. En esta clase hablamos sobre cómo mover un enemigo hacia la posición de nuestro personaje utilizando conceptos matemáticos sencillos. Este tipo de movimiento es fundamental para darle vida a los personajes de un juego y hacerlo más inmersivo. Vamos a explorar cómo lograrlo paso a paso.

¿Qué es un vector director?

Cuando queremos mover un objeto, como un enemigo, hacia la posición de otro, como nuestro personaje, utilizamos un vector llamado vector director. Este vector se origina en la posición inicial del enemigo y se extiende hasta la posición del personaje.

Para calcularlo, necesitamos:

• Posición del enemigo: un vector con componentes x y y iniciales.
• Posición del personaje: un vector con componentes x y y finales.

El vector director se obtiene restando el vector de posición inicial del enemigo del vector de posición final del personaje:

vector_director = vector_final - vector_inicial

¿Cómo normalizar un vector?

El vector director que calculamos es proporcional a la distancia que hay entre los dos objetos. Esto significa que, si los objetos están alejados, el vector será mayor. Para manejar mejor esto, convertimos el vector director en un vector unitario.

Normalizar un vector significa que su magnitud será una unidad:

Vector3 director = target.position - transform.position;
Vector3 directorUnitario = director.normalized;

Implementación en Unity

Ahora que tenemos los conceptos claros, los implementamos en Unity. Vamos a crear un script en C# para mover nuestro enemigo:

1. Crear la carpeta y script:

   • Vamos a Unity y creamos una nueva carpeta dentro de Scripts llamada Enemy.
   • Dentro de esta carpeta, creamos un nuevo C# Script llamado EnemyMove.

2. Definir el objetivo y el movimiento:

   • En el script, definimos un Transform público que representa el objetivo.
   • Usamos RigidBody2D rb para manipular el movimiento del enemigo.

3. Inicializar el componente:

   • En el método Start(), obtenemos el componente RigidBody2D del objeto.

4. Actualizar el movimiento:

   • En el método FixedUpdate(), actualizamos la velocidad del enemigo. Calculamos la dirección al objetivo y normalizamos el vector para mantener una distancia constante.

using UnityEngine;

public class EnemyMove : MonoBehaviour {
    public Transform target;
    private Rigidbody2D rb;

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

    void FixedUpdate() {
        Vector3 direction = (target.position - transform.position).normalized;
        rb.velocity = direction * speed;
    }
}

5. Configurar en Unity:
   • Asignamos el script al enemigo.
   • Seteamos la gravedad a cero y seleccionamos el personaje como objetivo.

Al ejecutar el juego, el enemigo seguirá al personaje a una velocidad constante, independientemente de la distancia entre ellos.

¿Por qué es útil la normalización?

Normalizar nuestros vectores nos permite definir una velocidad constante para nuestro enemigo. Así, sin importar cuán alejados o cercanos estén los personajes, el enemigo se desplazará siempre a la misma velocidad. Este enfoque es especialmente útil en espacios abiertos, donde no enfrentamos obstáculos físicos.

¿Qué sigue?

Con estas técnicas, nuestros personajes pueden interactuar de formas más significativas en el entorno del videojuego. Estos conceptos son fundamentales para mejorar la inteligencia de juego y hacer que los enemigos se comporten de manera más realista.

Ahora que hemos dominado estas matemáticas básicas, estamos listos para optimizar el movimiento de nuestros personajes aún más. ¡Sigue aprendiendo y llevando tus proyectos al siguiente nivel! Gracias a estas técnicas, tu comprensión del desarrollo de videojuegos seguirá expandiéndose.