Matemáticas para juegos: vectores, Lerp y Mathf

No hace falta ser matemático#

Programar juegos usa matemáticas, sí, pero no necesitas dominarlas en abstracto: necesitas conocer un puñado de operaciones y qué hacen. Unity te da funciones listas para casi todo. Este es tu kit de supervivencia.

Operaciones con vectores#

Un Vector3 es una dirección o una posición (x, y, z). Lo básico:

Vector3 a = new Vector3(3, 0, 4);

float longitud = a.magnitude;        // 5  (el "largo" del vector)
Vector3 dir = a.normalized;          // mismo sentido, longitud 1

// Distancia entre dos puntos
float dist = Vector3.Distance(jugador.position, enemigo.position);

// Dirección de A hacia B (normalizada)
Vector3 haciaEnemigo = (enemigo.position - jugador.position).normalized;

// Mover hacia un objetivo a velocidad fija
transform.position = Vector3.MoveTowards(transform.position, destino, velocidad * Time.deltaTime);

El patrón 'destino - origen'

Para obtener la dirección de un punto a otro: destino - origen. Si además la .normalized, tienes solo el sentido (longitud 1), listo para multiplicar por una velocidad. Este patrón ((objetivo.position - transform.position).normalized) aparece por todas partes: perseguir, disparar, apuntar.

Producto escalar (Dot): ¿está delante o detrás?#

Vector3.Dot mide cómo de alineados están dos vectores. No te asustes por el nombre: en la práctica responde a "¿el objetivo está delante de mí?".

Vector3 haciaObjetivo = (objetivo.position - transform.position).normalized;
float d = Vector3.Dot(transform.forward, haciaObjetivo);

// d ≈  1 → justo delante
// d ≈  0 → a un lado (90°)
// d ≈ -1 → justo detrás
if (d > 0.5f) Debug.Log("Lo tengo más o menos de frente");

Es la base de conos de visión y comprobaciones de orientación (ver percepción de IA, que usa el Angle equivalente).

Producto vectorial (Cross): la perpendicular#

Vector3.Cross(a, b) da un vector perpendicular a los dos. Útil para saber si algo está a tu izquierda o derecha, o para calcular normales de superficies. Menos habitual que Dot, pero bueno conocerlo.

Interpolación: Lerp, la estrella#

Lerp (interpolación lineal) mezcla entre dos valores según un factor t de 0 a 1. Es la herramienta nº1 para movimientos y transiciones suaves.

// A t=0 devuelve A; a t=1 devuelve B; a t=0.5 el punto medio
float medio = Mathf.Lerp(0f, 100f, 0.5f);        // 50
Vector3 pm  = Vector3.Lerp(inicio, fin, 0.5f);
Color mezcla = Color.Lerp(rojo, azul, t);

El patrón "seguimiento suave"#

// Se acerca a 'objetivo' un poco cada frame: rápido al principio, suave al final
transform.position = Vector3.Lerp(transform.position, objetivo, velocidad * Time.deltaTime);

Lerp para posición NO es velocidad constante

Lerp(actual, objetivo, t) cada frame produce un suavizado exponencial (frena al acercarse), no un movimiento a velocidad constante. Si quieres velocidad constante, usa MoveTowards. Elige según el efecto: Lerp para suavizar (cámaras, UI), MoveTowards para "ir hacia" a ritmo fijo.

Slerp: como Lerp pero para rotaciones o direcciones (interpola por el arco, no en línea recta). Ideal para girar suavemente.
SmoothDamp: suavizado con "amortiguación" muy natural, el favorito para cámaras.

Mathf: la caja de herramientas#

Mathf reúne funciones matemáticas útiles:

Función	Hace
`Mathf.Clamp(v, min, max)`	Limita v entre min y max
`Mathf.Clamp01(v)`	Limita entre 0 y 1
`Mathf.Abs(v)`	Valor absoluto (quita el signo)
`Mathf.Sign(v)`	Devuelve -1 o 1 según el signo
`Mathf.Min/Max`	El menor / mayor
`Mathf.Round/Floor/Ceil`	Redondear
`Mathf.PingPong(t, len)`	Va y viene entre 0 y len (rebote)
`Mathf.Sin(t)` `Mathf.Cos(t)`	Ondas (flotar, latir)
`Mathf.Repeat(t, len)`	Bucle de 0 a len

// Un objeto que flota arriba y abajo (movimiento sinusoidal)
float y = inicioY + Mathf.Sin(Time.time * 2f) * 0.5f;
transform.position = new Vector3(transform.position.x, y, 0f);

// Vida limitada entre 0 y el máximo
vida = Mathf.Clamp(vida - daño, 0, vidaMax);

Rotaciones sin dolor#

No necesitas quaternions a mano (Transform lo explica). Lo práctico:

// Mirar hacia una dirección
Quaternion objetivo = Quaternion.LookRotation(direccion);

// Girar suavemente hacia ella (grados por segundo)
transform.rotation = Quaternion.RotateTowards(transform.rotation, objetivo, 180f * Time.deltaTime);

// En 2D, apuntar en el plano hacia el ratón
Vector3 dir = ratonMundo - transform.position;
float ang = Mathf.Atan2(dir.y, dir.x) * Mathf.Rad2Deg;
transform.rotation = Quaternion.Euler(0, 0, ang);

Grados y radianes

Las funciones trigonométricas de C# (Atan2, Sin) trabajan en radianes; Unity muestra grados. Convierte con Mathf.Rad2Deg y Mathf.Deg2Rad. Es la causa de muchas rotaciones "que salen locas".

Errores frecuentes#

Usar Lerp(actual, objetivo, t) esperando velocidad constante (usa MoveTowards).
Olvidar .normalized en una dirección antes de multiplicar por la velocidad.
Mezclar radianes y grados en rotaciones.
Comparar magnitude cuando sqrMagnitude (sin raíz cuadrada) bastaría y es más barato en bucles.

Ponte a prueba#

📝 Pon a prueba lo aprendido

Resumen#

Tu kit matemático: vectores (destino - origen para direcciones, .normalized, Distance, Dot para "¿delante o detrás?"), interpolación (Lerp/Slerp para suavizar, MoveTowards para velocidad constante, SmoothDamp para cámaras) y Mathf (Clamp, Abs, Sign, Sin/Cos para ondas). Para rotar, LookRotation + RotateTowards, cuidando grados vs radianes. No necesitas más matemáticas para el 95% de un juego.