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.

fullscreen
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.