Controlar el flujo de un videojuego en Unity exige un Game Manager claro y extensible: define estados con un enum, expone métodos públicos para iniciar, terminar o volver al menú, y centraliza cambios con un único método que actualiza el estado y prepara la escena.
¿Qué es un game manager en Unity y por qué importa?
Un Game Manager es el director que coordina los parámetros globales: pausa, menú principal, partida en marcha y reglas por estado. Unity marca el script con un icono de rueda porque es el engranaje central, fácil de localizar cuando el proyecto crece.
- Coordina estados: menú, en partida y game over.
- Centraliza reglas y evita duplicar lógica.
- Facilita mantenimiento con el enfoque de divide y vencerás.
¿Cómo se crea y por qué aparece el engranaje?
- Crea un nuevo script C# llamado “GameManager”.
- Unity lo resalta con un engranaje para ubicarlo rápido entre muchos scripts.
- Se abre en Visual Studio y hereda de MonoBehaviour como cualquier otro.
¿Qué métodos públicos conviene definir?
- public void StartGame: inicia la partida.
- public void GameOver: finaliza cuando el jugador muere.
- public void BackToMenu: vuelve al menú principal.
- Recuerda visibilidad: si no indicas nada, es privado; si pones public, es público.
- Comenta con “//” para documentar tu intención y facilitar futuras revisiones.
¿Cómo estructurar estados del juego con un enum en C#?
Para guardar el estado global usa un enum accesible desde otros scripts. Decláralo fuera de la clase para poder referenciarlo desde, por ejemplo, un Player Controller.
- enum con tres valores: Menu, InGame, GameOver.
- Variable pública para el estado actual: comienza en Menu para que el jugador decida cuándo empezar.
- Un método privado SetGameState centraliza cambios de estado y actualizaciones de escena.
using UnityEngine;
public enum GameState {
Menu,
InGame,
GameOver
}
public class GameManager : MonoBehaviour {
public GameState currentGameState = GameState.Menu;
// Inicia la partida.
public void StartGame() {
SetGameState(GameState.InGame);
}
// Termina la partida.
public void GameOver() {
SetGameState(GameState.GameOver);
}
// Vuelve al menú principal.
public void BackToMenu() {
SetGameState(GameState.Menu);
}
// Cambia el estado y prepara la escena.
private void SetGameState(GameState newGameState) {
if (newGameState == GameState.Menu) {
// TODO: lógica del menú (mostrar botones, pausar, etc.).
} else if (newGameState == GameState.InGame) {
// TODO: preparar la escena para jugar (activar personaje, etc.).
} else if (newGameState == GameState.GameOver) {
// TODO: preparar el juego para el Game Over.
}
this.currentGameState = newGameState;
}
}
Piensa este flujo como un semáforo: menú en rojo (se detiene todo), in game en verde (todo activo) y game over en amarillo (transición hacia el menú).
¿Por qué sirve el enfoque divide y vencerás?
- Separa una tarea grande en subtareas manejables.
- Reduce errores y acelera depuración.
- Facilita añadir nuevos estados con cambios mínimos.
¿Cómo implementarlo y probarlo en la escena de Unity?
Nada funciona hasta asignar el script a un GameObject en la escena. La forma habitual es usar un objeto vacío para no acoplar el manager a cámara o personaje.
- Crea un GameObject vacío: GameObject > create empty.
- Asigna el script “GameManager” arrastrándolo al Inspector.
- Opcional: añade un gizmo visual para no perderlo en la escena.
- Gracias al enum, verás un desplegable en el Inspector para cambiar el estado.
- Al dar Play, prueba transiciones cambiando entre Menu, InGame y GameOver con un clic.
¿Con ganas de seguir? Comparte cómo organizarías la lógica de menú, in game y game over dentro de SetGameState y qué otras transiciones añadirías.
