3.1 La Plataforma.
Comenzaremos creando un cubo 3D al cuál le vamos a modificar su tamaño para que tenga una forma parecida y funcional al de una plataforma de un videojuego (es decir, una donde nuestro personaje se pueda subir y quedarse parado por un tiempo mientras la plataforma lo lleva al lugar de destino). A nuestra plataforma la llamaremos “Platform“.
Una vez tengamos nuestra plataforma, vamos a crear y asignarle el tag “Platform“; la capa o layer se quedará como “Default“.
Como siguiente paso, vamos a añadirle el componente “Box Collider” y le activaremos la propiedad “Is Trigger” (esto es porque queremos que este collider sirva como una zona invisible a la cual si nuestro personaje entra suceda una cierta acción).
Para asegurar que exista una zona que permita la detección de nuestro personaje, vamos a modificar este collider para que sobresalga un poco de la plataforma del lado donde el personaje deba subirse a ella (como se muestra a continuación):
Ahora, vamos a crear un objeto vacío dentro de nuestra plataforma (clic derecho y “Create Empty“), después a este objeto vacío no le pondremos un tag pero si le asignaremos la capa o layer “ground3D“. Por último le asignaremos un “Box Collider” asegurándonos que tenga el tamaño exacto de nuestra plataforma (lo cual normalmente sucede de forma automática). Esto lo hacemos para crear el área donde nuestro personaje se pueda parar y mover.
3.2 El Código de la Plataforma
Para que nuestra plataforma se pueda mover a través de los puntos que uno designe (waypoints), es necesario crear y asignarle a nuestra plataforma el siguiente código (“MovingPlatform.cs“):
using UnityEngine;
/// <summary>
/// Script para mover una plataforma 3D entre puntos predefinidos (waypoints) de forma cíclica y repetitiva.
/// </summary>
public class MovingPlatform : MonoBehaviour
{
/// <summary>
/// Array de waypoints (puntos objetivo) donde se moverá la plataforma.
/// Estos puntos deben crearse como GameObjects vacíos en la escena.
/// </summary>
[SerializeField] private Transform[] waypoints;
/// <summary>
/// Velocidad a la que se mueve la plataforma entre los waypoints.
/// </summary>
[SerializeField] private float speed = 2f;
/// <summary>
/// Tiempo que se espera en cada waypoint antes de continuar al siguiente.
/// </summary>
[SerializeField] private float waitTime = 1f;
/// <summary>
/// Índice del waypoint actual al que se dirige la plataforma.
/// </summary>
private int currentWaypointIndex = 0;
/// <summary>
/// Temporizador para controlar el tiempo de espera en cada waypoint.
/// </summary>
private float waitTimer = 0f;
/// <summary>
/// Bandera para indicar si la plataforma está en estado de espera (detenida en un waypoint).
/// </summary>
private bool waiting = false;
/// <summary>
/// Inicializa la posición de la plataforma y valida los waypoints.
/// </summary>
void Start()
{
// Validar que existan waypoints asignados
if (waypoints.Length == 0)
{
Debug.LogError("¡No hay waypoints asignados a la plataforma!");
enabled = false; // Desactiva el script para evitar errores
return;
}
// Posicionar la plataforma en el primer waypoint al inicio
transform.position = waypoints[0].position;
}
/// <summary>
/// Maneja el movimiento de la plataforma entre waypoints.
/// </summary>
void Update()
{
// Si la plataforma está en estado de espera, incrementar el temporizador
if (waiting)
{
waitTimer += Time.deltaTime; // Incrementa el temporizador basado en el tiempo real
if (waitTimer >= waitTime)
{
waiting = false; // Salir del estado de espera
// Avanzar al siguiente waypoint (con ciclo cíclico)
currentWaypointIndex = (currentWaypointIndex + 1) % waypoints.Length;
}
return;
}
// Verificar si hay waypoints definidos
if (waypoints.Length == 0) return;
// Seleccionar el waypoint objetivo actual
Transform target = waypoints[currentWaypointIndex];
// Mover la plataforma hacia el waypoint objetivo
transform.position = Vector3.MoveTowards(
transform.position,
target.position,
speed * Time.deltaTime
);
// Comprobar si la plataforma llegó al waypoint objetivo
if (Vector3.Distance(transform.position, target.position) < 0.05f)
{
waitTimer = 0f; // Reiniciar el temporizador
waiting = true; // Activar estado de espera
}
}
/// <summary>
/// Dibuja líneas entre waypoints en el Editor de Unity para visualizar la ruta.
/// </summary>
private void OnDrawGizmos()
{
// Validar que existan al menos 2 waypoints para dibujar conexiones
if (waypoints == null || waypoints.Length < 2) return;
// Dibujar líneas entre waypoints consecutivos
for (int i = 0; i < waypoints.Length - 1; i++)
{
Gizmos.color = Color.cyan; // Color de las líneas
if (waypoints[i] != null && waypoints[i + 1] != null)
Gizmos.DrawLine(waypoints[i].position, waypoints[i + 1].position);
}
// Dibujar línea del último waypoint al primero para completar el ciclo
Gizmos.DrawLine(waypoints[waypoints.Length - 1].position, waypoints[0].position);
}
}
Este script hay que añadirlo a nuestra plataforma, y antes de hacerlo funcionar es necesario crear los puntos por donde queremos que nuestra plataforma se mueva (waypoints).
Los “waypoints” son objetos vacíos que nos sirven como referencia para asignar las coordenadas por donde nuestra plataforma va a pasar. Así que, crearemos objetos vacíos (con “Create Empty“) sin tag ni layers asignados, los llamaremos “Waypoint” y los colocaremos en los lugares dentro de nuestra escena por donde queremos que nuestra plataforma pase.
Una vez hecho esto, asignaremos cada waypoint que hicimos en la sección “Waypoints” de nuestro código “MovingPlatform”.
Al hacerlo podremos ver en nuestra escena como cada waypoint se une al siguiente por medio de una línea de color cian representando la ruta que tendrá nuestra plataforma al moverse.
En este punto ya podrás oprimir “Play” en la escena para ver como se mueve la plataforma.
