¿Y qué pasa si NO heredas de MonoBehaviour?

Tu clase no podrá:

• Usar métodos del ciclo de vida (Start, Update, etc.)
• Ser añadida como componente a un GameObject
• Acceder directamente a funciones de Unity como transform, gameObject, StartCoroutine, Invoke, etc.

Ejemplo 1 de una clase normal

public class Inventario
{
    public int monedas;
}

No hereda de MonoBehaviour, por lo tanto no puede usarse como componente en Unity directamente (pero tiene otros usos como scripts comunes y corrientes que no dependen del ciclo de vida de Unity).

Ejemplo 2 de una clase normal

Puedes separar la lógica del juego en controladores independientes del motor Unity (como un Sistema de daño):

public class DamageSystem
{
    public static int CalcularDaño(int ataque, int defensa)
    {
        return Mathf.Max(ataque - defensa, 1);
    }
}

Y después puedes llamarlo desde cualquier MonoBehaviour así:

using UnityEngine; 

public class MiGranCodigo : MonoBehaviour { 

void Update() { 
 if (damage){
  int daño = DamageSystem.CalcularDaño(jugador.ataque, enemigo.defensa);
  }
}

Conclusión

MonoBehaviour es la base de todos los scripts de comportamiento en Unity.

Si quieres que Unity ejecute tu código automáticamente (cada frame, al colisionar, etc.), tu clase debe heredar de MonoBehaviour.

También habilita la integración con el Inspector, permitiéndote editar variables públicas desde el Editor de Unity.

Usar clases que no heredan de MonoBehaviour se usan comúnmente para mantener el código limpio, modular y reutilizable (se usan como estructuras de datos, controladores lógicos, ScriptableObjects, modelos, o herramientas internas).

Acerca del Ciclo de Vida de Unity.

Cada script que hereda de MonoBehaviour puede contener métodos especiales que Unity llama automáticamente durante el juego. El orden de ejecución típico es:

1. Awake()
2. OnEnable()
3. Start()
4. Update() (cada frame)
5. LateUpdate() (cada frame, después de Update)
6. FixedUpdate() (cada frame de física)

A continuación veremos cada uno de estos métodos.

1.2 Awake().

Se ejecuta una vez cuando se instancia el objeto o se carga la escena, antes de cualquier otro método.

Usos comunes:

• Inicializar referencias internas del propio objeto.
• Configurar datos que no dependan de otros objetos.

void Awake()
{
    Debug.Log("Awake llamado.");
    health = 100;
    rb = GetComponent<Rigidbody>();
}

Awake() se usa para asegurarse de que todas tus variables estén listas, incluso antes de que otros scripts empiecen a usarte.

1.3 OnEnable().

En Unity, el método OnEnable() es una función especial que forma parte del ciclo de vida de los scripts que heredan de MonoBehaviour. Se ejecuta automáticamente cuando el componente o el GameObject en el que está se activa, y específicamente en las siguientes condiciones:

• El script se activa por primera vez
• El GameObject que lo contiene es activado (SetActive(true))
• El componente en sí es habilitado (miScript.enabled = true)
• Se llama antes de Start(), y cada vez que el objeto o componente se vuelve a activar.

Usos comunes:

• Suscribirse a eventos
• Inicializar valores temporales o estados
• Reiniciar condiciones cada vez que se activa el objeto
• Reiniciar animaciones o temporizadores

void OnEnable()
{
    salud = saludMaxima;
    gameObject.SetActive(true);
}

Ideal para enemigos o objetos que se reutilizan (con pooling).

1.4 OnDisable().

OnDisable() es un método especial de Unity que se ejecuta automáticamente cuando un componente que hereda de MonoBehaviour es desactivado, o cuando su GameObject es desactivado, y se manda a llamar en las siguientes situaciones:

• El GameObject se desactiva (por ejemplo, usando SetActive(false)).
• El componente (script) se deshabilita (por ejemplo, usando miGranScript.enabled = false;).
• El objeto se destruye.
• La escena se cierra o recarga.
• Se llama antes de que el objeto desaparezca de la escena activa.

Usos comunes:

• Cancelar corutinas
• Desuscribirse de eventos (¡muy importante!)
• Guardar estado temporal
• Limpiar referencias o detener lógica temporal
• Evitar bugs relacionados con eventos mal manejados
• Detener procesos innecesarios o peligrosos (como corutinas)
• Mejorar el rendimiento y estabilidad del juego

Coroutine reloj;

void OnEnable()
{
    reloj = StartCoroutine(TiempoLimite());
}

void OnDisable()
{
    if (reloj != null)
        StopCoroutine(reloj);
}

Evita que una corutina siga ejecutándose después de que el objeto fue desactivado.

void OnDisable()
{
    PlayerPrefs.SetInt("Monedas", monedasActuales);
    PlayerPrefs.Save();
}

Ideal para sistemas de UI o estadísticas al cerrar ventanas.

1.5 Start().

Se ejecuta una vez, pero después de Awake() y solo si el script está habilitado.

Usos comunes:

• Inicializar valores que dependen de otros objetos o scripts.
• Llamar a métodos de otros GameObjects.

void Start()
{
    player = GameObject.Find("Player");
    enemyCount = GameObject.FindGameObjectsWithTag("Enemy").Length;
}

Start() se usa cuando se necesita que otras instancias del juego estén listas primero.

1.6 Update().

Se ejecuta una vez por frame (cada ciclo de renderizado).

Usos comunes:

• Lectura de entradas del jugador (Input)
• Movimiento o rotaciones suaves
• Timers y lógica dependiente del tiempo

void Update()
{
    float move = Input.GetAxis("Horizontal");
    transform.Translate(move * speed * Time.deltaTime, 0, 0);
}

Hay que evita realizar cálculos de física aquí; usa FixedUpdate() para eso.

1.7 FixedUpdate().

Se ejecuta en intervalos fijos (por defecto, cada 0.02 segundos), independientemente del framerate.

Usos comunes:

• Aplicar fuerzas con Rigidbody
• Lógica de físicas (colisiones, movimientos físicos)

void FixedUpdate()
{
    rb.AddForce(Vector3.forward * force);
}

Si usas física, asegúrate de mover tus objetos aquí para mantener una simulación estable.

1.8 LateUpdate().

Se ejecuta después de Update() en cada frame.

Usos comunes:

• Seguir al jugador con una cámara
• Ajustes finales después del movimiento (por ejemplo, para animaciones)

void LateUpdate()
{
    transform.position = player.position + offset;
}

Si necesitas que tu acción ocurra después del movimiento de todos los objetos, usa LateUpdate().

1.9 Conclusión.

Comparando los métodos.

Un ejemplo de uso para un personaje con movimiento basado en física y una cámara que lo sigue:

Rigidbody rb;
Transform player;

void Awake()
{
    rb = GetComponent<Rigidbody>();
}

void OnEnable()
{
    salud = saludMaxima;
    gameObject.SetActive(true);
}

void Start()
{
    player = GameObject.FindWithTag("Player").transform;
}

void FixedUpdate()
{
    float move = Input.GetAxis("Vertical");
    rb.AddForce(transform.forward * move * 10f);
}

void LateUpdate()
{
    transform.position = player.position + new Vector3(0, 5, -10);
}

void OnDisable()
{
    PlayerPrefs.SetInt("Monedas", monedasActuales);
    PlayerPrefs.Save();
}

Como se pudo observar, entender y dominar estos métodos es fundamental para organizar bien tus scripts en Unity. Elegir dónde poner cada parte de tu código no solo mejora el rendimiento, también reduce errores difíciles de rastrear.

Ejercicios.

Para reforzar lo aprendido, es necesario practicarlo, por ello intenta realizar los siguientes ejercicios:

1. Crea tu propio script (como lo vimos en los tutoriales anteriores) y coloca un “Hola Mundo” en cada método del ciclo de vida de Unity (usa solo un método por cada vez que le des play).
2. Crea un script simple (sin heredar de MonoBehaviour) y mándalo llamar desde otro que si lo haga usando el ejemplo de este tutorial y algún ejemplo de la serie de tutoriales anteriores.

Este Tutorial de Unity termina aquí. Acompáñanos en el siguiente tutorial donde veremos “Herencias”.

Siguiente Tutorial de Unity: “2.”