{"id":68145,"date":"2025-05-31T08:47:20","date_gmt":"2025-05-31T13:47:20","guid":{"rendered":"https:\/\/niixer.com\/?p=68145"},"modified":"2025-05-31T09:40:19","modified_gmt":"2025-05-31T14:40:19","slug":"desarrollo-del-videojuego-speedandjump-en-unity-superacion-de-retos-hasta-el-castillo-final","status":"publish","type":"post","link":"https:\/\/niixer.com\/index.php\/2025\/05\/31\/desarrollo-del-videojuego-speedandjump-en-unity-superacion-de-retos-hasta-el-castillo-final\/","title":{"rendered":"Desarrollo del Videojuego \u201cSpeedAndJump\u201d en Unity \u2013 Superaci\u00f3n de Retos hasta el Castillo Final"},"content":{"rendered":"\n

Este documento describe el proceso de desarrollo del videojuego SpeedAndJump<\/em>, un proyecto en Unity dise\u00f1ado en perspectiva de primera persona. El juego consiste en guiar a un personaje a trav\u00e9s de diversos retos, plataformas m\u00f3viles, enemigos y trampas, con el objetivo final de alcanzar un castillo. Durante el desarrollo se implementaron sistemas de vida, detecci\u00f3n de ca\u00eddas, animaciones controladas por condiciones, inteligencia artificial b\u00e1sica en enemigos (como abejas voladoras), y una interfaz de usuario que refleja el estado del jugador. Adem\u00e1s, se incluyeron men\u00fas interactivos con m\u00fasica y video, as\u00ed como escenas de Game Over y Victoria. El documento incluye tambi\u00e9n los scripts utilizados, explicados con su funcionalidad y prop\u00f3sito, brindando una visi\u00f3n completa del dise\u00f1o t\u00e9cnico y jugable del proyecto.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n
\"\"<\/figure>\n\n\n\n
\"\"\/<\/figure>\n\n\n\n

figura 1<\/p>\n\n\n\n

Importaci\u00f3n de Assets y Configuraci\u00f3n Inicial del Personaje<\/strong><\/h2>\n\n\n\n

Todos los modelos 3D y animaciones utilizados en el juego fueron importados desde el paquete Ultimate Platformer Pack<\/strong> de Quaternius<\/strong>, descargado desde el sitio oficial de Unity Asset Store<\/a>. El paquete fue incorporado al proyecto arrastrando su carpeta directamente al panel Project<\/strong> de Unity, permitiendo as\u00ed su reconocimiento autom\u00e1tico por el motor. Desde esta ubicaci\u00f3n se seleccionaron los modelos, animaciones y objetos f\u00edsicos requeridos para el desarrollo del entorno y la mec\u00e1nica del juego.<\/p>\n\n\n\n

\"figura<\/figure>\n\n\n\n

figura 2<\/p>\n\n\n\n

\"figura<\/figure>\n\n\n\n

figura 3<\/p>\n\n\n\n

\"\"\/<\/figure>\n\n\n\n

figura 4<\/p>\n\n\n\n

Se llevaron a cabo los siguientes pasos clave para la configuraci\u00f3n inicial del personaje principal y los elementos f\u00edsicos del entorno:<\/p>\n\n\n\n

    \n
  • Importaci\u00f3n del Modelo del Jugador: El modelo 3D fue importado en formato\u00a0.<\/code>FBX<\/code>\u00a0<\/em>desde el paquete\u00a0Ultimate Platformer Pack<\/em>. En la pesta\u00f1a\u00a0Rig<\/em>\u00a0del Inspector, se configur\u00f3 el tipo de animaci\u00f3n como Humanoid para facilitar la integraci\u00f3n con el sistema de animaci\u00f3n de Unity.<\/li>\n<\/ul>\n\n\n\n
    \"\"<\/figure>\n\n\n\n
      \n
    • Sistema de Animaciones: Las animaciones correspondientes fueron arrastradas a un Animator Controller, donde se definieron los estados y transiciones. Se configuraron par\u00e1metros como\u00a0isRunning<\/code>\u00a0(booleano) para controlar el movimiento, y\u00a0Die<\/code>\u00a0(Trigger) para gestionar la animaci\u00f3n de muerte. Se desactiv\u00f3 la opci\u00f3n Has Exit Time en la transici\u00f3n hacia la animaci\u00f3n de muerte para permitir una respuesta inmediata ante eventos de colisi\u00f3n letal.<\/li>\n<\/ul>\n\n\n\n
      \"\"<\/figure>\n\n\n\n
        \n
      • F\u00edsica del Entorno: A los elementos del entorno (como plataformas, obst\u00e1culos y superficies) se les asignaron componentes Rigidbody (cuando se requer\u00eda din\u00e1mica) y Collider (BoxCollider, MeshCollider o CapsuleCollider, seg\u00fan el objeto), con el fin de gestionar las colisiones y simular interacciones f\u00edsicas realistas.<\/li>\n<\/ul>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
          \n
        • Control del Personaje: Se utiliz\u00f3 el componente CharacterController para el movimiento del jugador, acompa\u00f1ado de scripts personalizados que gestionan la l\u00f3gica de salto, detecci\u00f3n de ca\u00edda, y condiciones de muerte (por ejemplo, ca\u00edda desde cierta altura o colisi\u00f3n con elementos hostiles).<\/li>\n<\/ul>\n\n\n\n
          \"\"<\/figure>\n\n\n\n

          figura 8<\/p>\n\n\n\n

          Sistema de Vida y Detecci\u00f3n de Ca\u00eddas<\/strong><\/h1>\n\n\n\n

          Se implement\u00f3 un sistema de vidas que determina cu\u00e1ntas veces el jugador puede caer desde una altura peligrosa antes de activar el estado de Game Over. La l\u00f3gica se basa en dos condiciones principales:<\/p>\n\n\n\n

          \"\"<\/figure>\n\n\n\n

          figura 9<\/p>\n\n\n\n

          Detecci\u00f3n de Ca\u00edda por Altura:<\/strong> Si el jugador cae desde una altura superior al valor definido como minFallHeight<\/code>, se considera una ca\u00edda peligrosa y se decrementa el contador de vidas disponibles.<\/p>\n\n\n\n

          \"\"<\/figure>\n\n\n\n

          figura 10<\/p>\n\n\n\n

          L\u00edmite de Posici\u00f3n Vertical:<\/strong> Independientemente de la altura desde la que se cay\u00f3, si la posici\u00f3n vertical del jugador (transform.position.y<\/code>) desciende por debajo de un umbral cr\u00edtico definido (por ejemplo, deathYThreshold<\/code>), se ejecuta autom\u00e1ticamente la p\u00e9rdida de una vida. Esta condici\u00f3n asegura que ca\u00eddas prolongadas fuera del escenario tambi\u00e9n sean detectadas como fallos<\/p>\n\n\n\n

          \"\"\/<\/figure>\n\n\n\n

          figura 11<\/p>\n\n\n\n

          Sistemas de animaci\u00f3n<\/h2>\n\n\n\n

          Las animaciones del personaje fueron gestionadas a trav\u00e9s de un Animator Controller, que defini\u00f3 el flujo de estados como:<\/p>\n\n\n\n

          Idle<\/code> <\/strong><\/em>\u2013 cuando el personaje est\u00e1 detenido.<\/p>\n\n\n\n

          Walk<\/code> \/ Run<\/code><\/strong><\/em> \u2013 durante el movimiento a baja o alta velocidad.<\/p>\n\n\n\n

          Die<\/code> \u2013<\/em><\/strong> animaci\u00f3n de muerte activada tras una ca\u00edda o evento letal.<\/p>\n\n\n\n

          \"\"\/<\/figure>\n\n\n\n

          figura 12<\/p>\n\n\n\n

          Para activar la animaci\u00f3n de muerte, se defini\u00f3 un par\u00e1metro de tipo Trigger<\/strong> llamado Die<\/code>, el cual es invocado desde el script del controlador de vida en el momento en que el jugador pierde una vida.<\/p>\n\n\n\n

          Con el fin de asegurar que la animaci\u00f3n de muerte se reproduzca completamente antes de que el personaje reaparezca, se utiliz\u00f3 una corrutina<\/strong> (Coroutine<\/code>) que introduce un retardo basado en la duraci\u00f3n exacta de la animaci\u00f3n. Solo despu\u00e9s de ese intervalo se restablece la posici\u00f3n del jugador al punto de inicio o respawn<\/code>.<\/p>\n\n\n\n

          \"\"<\/figure>\n\n\n\n

          figura 13<\/p>\n\n\n\n

          Interfaz de Usuario (UI) y Control de Da\u00f1o<\/strong><\/h2>\n\n\n\n

          El sistema de interfaz de usuario fue dise\u00f1ado para reflejar en tiempo real el estado de vidas del jugador. Para ello, se implement\u00f3 un script llamado UIManager<\/code><\/strong>, encargado de actualizar din\u00e1micamente los elementos visuales (como \u00edconos de vidas o contadores num\u00e9ricos) cada vez que se produce una p\u00e9rdida de vida.<\/p>\n\n\n\n

          \"\"<\/figure>\n\n\n\n

          figura 14<\/p>\n\n\n\n

          Creaci\u00f3n e Integraci\u00f3n del Enemigo: Abeja<\/strong><\/h2>\n\n\n\n

          Importaci\u00f3n del Modelo 3D<\/strong><\/h3>\n\n\n\n

          El modelo de la abeja fue importado en formato .FBX<\/code> y ubicado en la ruta: Assets\/Enemies\/Bee<\/code>.<\/p>\n\n\n\n

          En el panel Inspector<\/strong>, se configur\u00f3 el tipo de Rig<\/strong> como Humanoid<\/code> o Generic<\/code>, dependiendo del formato del asset original y la compatibilidad de las animaciones.<\/p>\n\n\n\n

          Configuraci\u00f3n del Prefab<\/h3>\n\n\n\n
            \n
          • Se gener\u00f3 un\u00a0Prefab<\/strong>\u00a0denominado\u00a0Bee<\/code>\u00a0arrastrando el modelo desde el proyecto a la carpeta\u00a0Assets\/Prefabs<\/code>.<\/li>\n\n\n\n
          • Se a\u00f1adieron los siguientes componentes:\n
              \n
            • Animator<\/strong>: con el\u00a0BeeAnimatorController<\/code>\u00a0asignado.<\/li>\n\n\n\n
            • Rigidbody<\/strong>: configurado con:\n
                \n
              • Mass = 1<\/code><\/li>\n\n\n\n
              • Drag = 0.5<\/code><\/li>\n\n\n\n
              • Use Gravity = false<\/code>\u00a0(para simular vuelo continuo).<\/li>\n<\/ul>\n<\/li>\n\n\n\n
              • SphereCollider<\/strong>: utilizado para detectar colisiones f\u00edsicas. Se mantuvo\u00a0Is Trigger = false<\/code>\u00a0para permitir interacci\u00f3n f\u00edsica con el jugador.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
              • El objeto fue etiquetado con:\n
                  \n
                • Tag = Enemy<\/code><\/li>\n\n\n\n
                • Layer = Enemies<\/code>
                  Esto facilita la identificaci\u00f3n mediante scripts y la gesti\u00f3n de colisiones con capas espec\u00edficas.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                  \"\"<\/figure>\n\n\n\n

                  figura 15<\/p>\n\n\n\n

                  Configuraci\u00f3n del Animator Controller<\/strong><\/h3>\n\n\n\n

                  Se configur\u00f3 el BeeAnimatorController<\/code> con los siguientes par\u00e1metros y estados:<\/p>\n\n\n\n

                    \n
                  • Par\u00e1metros:<\/strong>\n
                      \n
                    • isFlying<\/code>\u00a0(bool): activado por defecto para mantener el estado de vuelo.<\/li>\n\n\n\n
                    • Attack<\/code>\u00a0(Trigger): utilizado para iniciar la animaci\u00f3n de ataque cuando se detecta al jugador.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                    • Estados:<\/strong>\n
                        \n
                      • BeeFlying<\/code>: clip de animaci\u00f3n de vuelo, configurado como\u00a0Default State<\/strong>\u00a0(flecha naranja), con la opci\u00f3n\u00a0Loop Time<\/strong>\u00a0activada.<\/li>\n\n\n\n
                      • Attack<\/code>: animaci\u00f3n de ataque activada mediante trigger.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                      • Transiciones:<\/strong>\n
                          \n
                        • Any State \u2192 Attack<\/code>: condici\u00f3n\u00a0Attack<\/code>\u00a0(Trigger activado).<\/li>\n\n\n\n
                        • Any State \u2192 BeeFlying<\/code>: condici\u00f3n\u00a0isFlying == true<\/code>.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                        • Se desactivaron\u00a0Has Exit Time<\/strong>\u00a0y\u00a0Write Defaults<\/strong>\u00a0en transiciones espec\u00edficas para asegurar una respuesta inmediata y optimizar el control sobre los par\u00e1metros del Animator.<\/li>\n<\/ul>\n\n\n\n
                          \"\"\/<\/figure>\n\n\n\n

                          figura 16<\/p>\n\n\n\n

                          Script BeeMovement.cs<\/code> \u2014 Movimiento y Ataque del Enemigo Abeja<\/strong><\/p>\n\n\n\n

                          El script BeeMovement.cs<\/code> controla el comportamiento de patrullaje, persecuci\u00f3n y ataque del enemigo tipo abeja. Sus principales componentes funcionales son:<\/p>\n\n\n\n

                          Inicializaci\u00f3n (Start()<\/code>)<\/h3>\n\n\n\n
                          void Start() {
                              animator = GetComponent<Animator>();
                              animator.SetBool(\"isFlying\", true); \/\/ Estado inicial de vuelo
                              player = GameObject.FindGameObjectWithTag(\"Player\").transform; \/\/ Referencia al jugador
                          }<\/code><\/pre>\n\n\n\n
                          Actualizaci\u00f3n de Comportamiento (Update()<\/code>)<\/h3>\n\n\n\n
                          En cada frame, se eval\u00faa la distancia al jugador y se ejecutan distintas acciones:<\/p>\n\n\n\n
                          void Update() {
                              float distanceToPlayer = Vector3.Distance(transform.position, player.position);
                              
                              if (distanceToPlayer <= followRange) {
                                  \/\/ Movimiento hacia el jugador
                                  transform.position = Vector3.MoveTowards(transform.position, player.position, speed * Time.deltaTime);
                                  animator.SetBool(\"isFlying\", true);
                                  
                                  \/\/ Ataque si est\u00e1 en rango y respetando el cooldown
                                  if (distanceToPlayer <= attackRange && Time.time - lastAttackTime >= attackCooldown) {
                                      animator.SetTrigger(\"Attack\");
                                      lastAttackTime = Time.time;
                                  }
                              } else {
                                  \/\/ Patrullaje flotante (Idle)
                                  FloatIdle();
                              }
                          }<\/code><\/pre>\n\n\n\n
                            \n
                          • followRange<\/code><\/strong>: distancia m\u00e1xima para comenzar a seguir al jugador.<\/li>\n\n\n\n
                          • attackRange<\/code><\/strong>: distancia m\u00ednima para activar el ataque.<\/li>\n\n\n\n
                          • lastAttackTime<\/code><\/strong>\u00a0y\u00a0attackCooldown<\/code><\/strong>: variables para controlar la frecuencia de ataque y evitar ataques continuos.<\/li>\n<\/ul>\n\n\n\n
                            \"\"<\/figure>\n\n\n\n
                            figura 17<\/p>\n\n\n\n
                            M\u00e9todo de Movimiento Flotante (Idle)<\/h3>\n\n\n\n
                            void FloatIdle() {
                                float yOffset = Mathf.Sin(Time.time * floatSpeed) * floatAmplitude;
                                transform.position = new Vector3(transform.position.x, initialY + yOffset, transform.position.z);
                            }<\/code><\/pre>\n\n\n\n
                              \n
                            • Simula un movimiento vertical suave con\u00a0Mathf.Sin<\/strong>\u00a0para dar sensaci\u00f3n de vuelo o patrullaje sin jugador cerca.<\/li>\n\n\n\n
                            • Se recomienda almacenar el valor\u00a0initialY<\/code>\u00a0en\u00a0Start()<\/code>\u00a0para conservar el nivel base del eje Y.<\/li>\n<\/ul>\n\n\n\n
                              \n\n\n\n
                              \"\"\/<\/figure>\n\n\n\n
                              figura 18<\/p>\n\n\n\n
                              Evento de Ataque: DealDamage()<\/code><\/h3>\n\n\n\n
                              public void DealDamage() {
                                  \/\/ Este m\u00e9todo se llama desde un evento en el clip de animaci\u00f3n 'Attack'
                                  if (Vector3.Distance(transform.position, player.position) <= attackRange) {
                                      player.GetComponent<PlayerHealth>().TakeDamage(damageAmount);
                                  }
                              }<\/code><\/pre>\n\n\n\n
                                \n
                              • Este m\u00e9todo se conecta directamente desde el\u00a0evento de animaci\u00f3n<\/strong>\u00a0del clip de ataque.<\/li>\n\n\n\n
                              • Asegura que el da\u00f1o se inflija solo si el jugador est\u00e1 dentro del rango al momento del impacto.<\/li>\n\n\n\n
                              • Llama al m\u00e9todo\u00a0TakeDamage()<\/code>\u00a0del componente\u00a0PlayerHealth<\/code>\u00a0para reducir vidas<\/li>\n<\/ul>\n\n\n\n
                                \"\"<\/figure>\n\n\n\n
                                figura 19<\/p>\n\n\n\n
                                Implementaci\u00f3n de Men\u00fa Principal con Canvas<\/h2>\n\n\n\n
                                Creaci\u00f3n de Escena MainMenu<\/code><\/strong><\/h4>\n\n\n\n
                                  \n
                                • Se cre\u00f3 una nueva escena\u00a0MainMenu.unity<\/code>.<\/li>\n\n\n\n
                                • Se a\u00f1adi\u00f3 a\u00a0Build Settings<\/strong>\u00a0para garantizar su correcta carga como primera escena del juego.<\/li>\n<\/ul>\n\n\n\n
                                  \"\"<\/figure>\n\n\n\n
                                  figura 20<\/p>\n\n\n\n
                                  Configuraci\u00f3n del Canvas<\/strong><\/h4>\n\n\n\n
                                    \n
                                  • Se a\u00f1adi\u00f3 un\u00a0Canvas<\/code>\u00a0al escenario.<\/li>\n\n\n\n
                                  • Render Mode<\/strong>:\u00a0Screen Space - Overlay<\/code>\u00a0para una interfaz n\u00edtida y adaptativa en cualquier resoluci\u00f3n.<\/li>\n\n\n\n
                                  • Se ajustaron dimensiones y anclajes para una experiencia responsiva.<\/li>\n<\/ul>\n\n\n\n
                                    \"\"<\/figure>\n\n\n\n
                                    figura 21<\/p>\n\n\n\n
                                    Elementos de UI<\/strong><\/h4>\n\n\n\n
                                      \n
                                    • Bot\u00f3n \u201cPlay\u201d<\/strong>:\n
                                        \n
                                      • Tipo:\u00a0Button (TextMeshPro)<\/code>.<\/li>\n\n\n\n
                                      • Evento\u00a0OnClick()<\/code>\u00a0asignado a\u00a0MainMenuController.PlayGame()<\/code>, encargado de cargar la siguiente escena de juego.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                      • Texto descriptivo<\/strong>:\n
                                          \n
                                        • A\u00f1adido al Canvas.<\/li>\n\n\n\n
                                        • Tipograf\u00eda elegante con\u00a0TextMeshPro<\/code>, tama\u00f1o y color ajustados para legibilidad y est\u00e9tica.<\/li>\n\n\n\n
                                        • Centrado y estilizado para acompa\u00f1ar el dise\u00f1o general del men\u00fa.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                                          \"\"<\/figure>\n\n\n\n
                                          figura 22<\/p>\n\n\n\n
                                          Fondo de Video<\/strong><\/p>\n\n\n\n
                                            \n
                                          • Se cre\u00f3 la carpeta\u00a0Assets\/Videos<\/code>\u00a0e import\u00f3 un archivo\u00a0.mp4<\/code>.<\/li>\n\n\n\n
                                          • Se a\u00f1adi\u00f3 un componente\u00a0VideoPlayer<\/code>\u00a0al Canvas:\n
                                              \n
                                            • Render Mode<\/strong>:\u00a0Camera Near Plane<\/code>\u00a0(se renderiza detr\u00e1s de los elementos UI).<\/li>\n\n\n\n
                                            • Target Camera<\/strong>:\u00a0MainCamera<\/code>.<\/li>\n\n\n\n
                                            • Loop<\/strong>: activado.<\/li>\n\n\n\n
                                            • Play On Awake<\/strong>: activado.<\/li>\n\n\n\n
                                            • Audio Output Mode<\/strong>:\u00a0None<\/code>\u00a0(audio silenciado para no interferir con la m\u00fasica de fondo).<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                            • Se ajust\u00f3 el orden de render para mantener los elementos UI por encima del video.<\/li>\n<\/ul>\n\n\n\n
                                              \"\"<\/figure>\n\n\n\n
                                              figura 23<\/p>\n\n\n\n
                                              M\u00fasica de Fondo<\/strong><\/p>\n\n\n\n
                                                \n
                                              • Se import\u00f3\u00a0MenuMusic.mp3<\/code>\u00a0en la carpeta\u00a0Assets\/Audio<\/code>.<\/li>\n\n\n\n
                                              • Se cre\u00f3 un\u00a0GameObject<\/code>\u00a0llamado\u00a0MusicPlayer<\/code>\u00a0con componente\u00a0AudioSource<\/code>:\n
                                                  \n
                                                • AudioClip<\/strong>: asignado a\u00a0MenuMusic.mp3<\/code>.<\/li>\n\n\n\n
                                                • Play On Awake<\/strong>: activado.<\/li>\n\n\n\n
                                                • Loop<\/strong>: activado.<\/li>\n\n\n\n
                                                • Volumen<\/strong>: ajustado a\u00a00.3<\/code>\u00a0para no opacar efectos futuros del juego.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                                                  \"\"<\/figure>\n\n\n\n
                                                  figura 24<\/p>\n\n\n\n
                                                  Anexo Completo de Scripts con C\u00f3digo y Descripci\u00f3n<\/p>\n\n\n\n
                                                  AnimationEventRelay.cs.<\/h2>\n\n\n\n
                                                  Sirve como conexi\u00f3n entre una acci\u00f3n animada y la forma en que el jugador ataca.Captura un Evento de Animaci\u00f3n y redirige la solicitud al m\u00e9todo de ataque del PlayerController. Coordina las animaciones con la implementaci\u00f3n del da\u00f1o, garantizando precisi\u00f3n en el tiempo. con tecla E<\/p>\n\n\n\n
                                                  using UnityEngine;

                                                  public class AnimationEventRelay : MonoBehaviour
                                                  {
                                                      public PlayerController playerController;

                                                      \/\/ Este m\u00e9todo ser\u00e1 llamado por el evento de animaci\u00f3n
                                                      public void PerformAttack()
                                                      {
                                                          if (playerController != null)
                                                          {
                                                              playerController.PerformAttack();
                                                          }
                                                      }
                                                  }<\/code><\/pre>\n\n\n\n
                                                  BeeMovement.cs<\/h2>\n\n\n\n
                                                  Regula las acciones de la abeja rival: flotaci\u00f3n sin movimiento, seguimiento al jugador, animaci\u00f3n de ataque y asistencia de da\u00f1o.Administra los estados de inactividad en el aire y la persecuci\u00f3n\/ataque seg\u00fan las distancias.Presenta un enemigo que se mueve de forma din\u00e1mica y pone a prueba al jugador.<\/p>\n\n\n\n
                                                  using UnityEngine;

                                                  public class BeeMovement : MonoBehaviour
                                                  {
                                                      public float floatSpeed = 2f;
                                                      public float floatAmount = 0.2f;
                                                      public float followRange = 6f;
                                                      public float attackRange = 1.2f;
                                                      public float moveSpeed = 3f;
                                                      public float attackCooldown = 1.0f;

                                                      private Vector3 startPosition;
                                                      private Transform player;
                                                      private Animator animator;
                                                      private float lastAttackTime = -Mathf.Infinity;

                                                      void Start()
                                                      {
                                                          startPosition = transform.position;
                                                          animator = GetComponent<Animator>();
                                                          GameObject playerObj = GameObject.FindGameObjectWithTag(\"Player\");
                                                          if (playerObj != null)
                                                              player = playerObj.transform;
                                                      }

                                                      void Update()
                                                      {
                                                          if (player == null)
                                                          {
                                                              FloatIdle();
                                                              return;
                                                          }

                                                          float distance = Vector3.Distance(transform.position, player.position);

                                                          if (distance <= followRange)
                                                          {
                                                              \/\/ Seguir al jugador
                                                              Vector3 targetPos = player.position;
                                                              targetPos.y = transform.position.y;
                                                              transform.position = Vector3.MoveTowards(transform.position, targetPos, moveSpeed * Time.deltaTime);

                                                              \/\/ Atacar si est\u00e1 en rango
                                                              if (distance <= attackRange)
                                                              {
                                                                  if (Time.time - lastAttackTime >= attackCooldown)
                                                                  {
                                                                      if (animator != null)
                                                                          animator.SetTrigger(\"Attack\");
                                                                      lastAttackTime = Time.time;
                                                                  }
                                                              }
                                                          }
                                                          else
                                                          {
                                                              FloatIdle();
                                                          }
                                                      }

                                                      void FloatIdle()
                                                      {
                                                          float newY = startPosition.y + Mathf.Sin(Time.time * floatSpeed) * floatAmount;
                                                          transform.position = new Vector3(transform.position.x, newY, transform.position.z);
                                                      }

                                                      \/\/ Este m\u00e9todo debe ser llamado por un evento en la animaci\u00f3n de ataque
                                                      public void DealDamage()
                                                      {
                                                          if (player == null) return;
                                                          float distance = Vector3.Distance(transform.position, player.position);
                                                          if (distance <= attackRange)
                                                          {
                                                              PlayerLifeSystem pls = player.GetComponent<PlayerLifeSystem>();
                                                              if (pls != null && pls.CurrentLives > 0)
                                                                  pls.TakeDamage();
                                                          }
                                                      }
                                                  }<\/code><\/pre>\n\n\n\n
                                                  CameraFollow.cs<\/h2>\n\n\n\n
                                                  Establece una c\u00e1mara en tercera persona que se maneje con el rat\u00f3n y que tenga un seguimiento fluido. Modifica el movimiento vertical y horizontal con el rat\u00f3n, y haz que la posici\u00f3n y la vista hacia el jugador sean m\u00e1s suaves. Brinda al jugador un control visual total y una experiencia inmersiva.<\/p>\n\n\n\n
                                                  using UnityEngine;
                                                  using UnityEngine.InputSystem;

                                                  public class CameraFollow : MonoBehaviour
                                                  {
                                                      public Transform target;
                                                      public Vector3 offset = new Vector3(0, 3, -6);
                                                      public float followSpeed = 10f;
                                                      public float mouseSensitivity = 2f;
                                                      public float minY = -35f;
                                                      public float maxY = 60f;

                                                      private float currentYaw = 0f;
                                                      private float currentPitch = 10f;

                                                      void LateUpdate()
                                                      {
                                                          if (!enabled || target == null) return;

                                                          float mouseX = Mouse.current.delta.x.ReadValue() * mouseSensitivity;
                                                          float mouseY = Mouse.current.delta.y.ReadValue() * mouseSensitivity;

                                                          currentYaw += mouseX;
                                                          currentPitch -= mouseY;
                                                          currentPitch = Mathf.Clamp(currentPitch, minY, maxY);

                                                          target.rotation = Quaternion.Euler(0, currentYaw, 0);

                                                          Quaternion rotation = Quaternion.Euler(currentPitch, currentYaw, 0);
                                                          Vector3 desiredPosition = target.position + rotation * offset;

                                                          transform.position = Vector3.Lerp(transform.position, desiredPosition, followSpeed * Time.deltaTime);
                                                          transform.LookAt(target.position + Vector3.up * offset.y * 0.5f);
                                                      }
                                                  }<\/code><\/pre>\n\n\n\n
                                                  CoinSpawner.cs<\/h2>\n\n\n\n
                                                  Crea monedas de vida sobre cada dificultad.Al comenzar, identifica elementos con la etiqueta \u2018Obst\u00e1culo\u2019 y crea monedas. Automatiza las recogidas, incentivando la exploraci\u00f3n.<\/p>\n\n\n\n
                                                  using UnityEngine;

                                                  public class CoinSpawner : MonoBehaviour
                                                  {
                                                      public GameObject coinPrefab; \/\/ Asigna el prefab desde el editor
                                                      public float coinOffsetY = 1.0f; \/\/ Altura sobre el cubo

                                                      void Start()
                                                      {
                                                          GameObject[] obstacles = GameObject.FindGameObjectsWithTag(\"Obstacle\");
                                                          foreach (GameObject obstacle in obstacles)
                                                          {
                                                              Vector3 spawnPosition = obstacle.transform.position + new Vector3(0, coinOffsetY, 0);
                                                              Instantiate(coinPrefab, spawnPosition, Quaternion.identity);
                                                          }
                                                      }
                                                  }<\/code><\/pre>\n\n\n\n
                                                  Enemy.cs<\/h2>\n\n\n\n
                                                  Clase fundamental para oponentes con puntos de vida y fin de existencia.Reduce los puntos de vida y elimina el objeto cuando llegan a cero.Estructura consistente para todos los oponentes, permite una f\u00e1cil ampliaci\u00f3n.<\/p>\n\n\n\n
                                                  using UnityEngine;

                                                  public class Enemy : MonoBehaviour, IDamageable
                                                  {
                                                      public int maxHealth = 3;
                                                      private int currentHealth;

                                                      void Start()
                                                      {
                                                          currentHealth = maxHealth;
                                                      }

                                                      public void TakeDamage(int amount)
                                                      {
                                                          currentHealth -= amount;
                                                          if (currentHealth <= 0)
                                                          {
                                                              Die();
                                                          }
                                                      }

                                                      void Die()
                                                      {
                                                          Destroy(gameObject);
                                                      }
                                                  }<\/code><\/pre>\n\n\n\n
                                                  FallingPlatform.cs<\/h2>\n\n\n\n
                                                  Plataforma que cae al pisarla y resetea su estado. Retraso, ca\u00edda con gravedad extra y reinicio.<\/p>\n\n\n\n
                                                  using UnityEngine;

                                                  public class FallingPlatform : MonoBehaviour
                                                  {
                                                      public float fallDelay = 0.5f;
                                                      public float extraGravityMultiplier = 3f;

                                                      private Rigidbody rb;
                                                      private bool hasFallen = false;
                                                      private bool isInactive = false;
                                                      private Vector3 initialPosition;
                                                      private Quaternion initialRotation;
                                                      private Collider platformCollider;
                                                      private Renderer platformRenderer;

                                                      void Start()
                                                      {
                                                          rb = GetComponent<Rigidbody>();
                                                          platformCollider = GetComponent<Collider>();
                                                          platformRenderer = GetComponent<Renderer>();
                                                          initialPosition = transform.position;
                                                          initialRotation = transform.rotation;
                                                          rb.isKinematic = true;
                                                      }

                                                      public void TriggerFall()
                                                      {
                                                          if (!hasFallen && !isInactive)
                                                          {
                                                              hasFallen = true;
                                                              Invoke(nameof(Fall), fallDelay);
                                                          }
                                                      }

                                                      void Fall()
                                                      {
                                                          rb.isKinematic = false;
                                                          rb.velocity = Vector3.down * Physics.gravity.magnitude * extraGravityMultiplier;
                                                      }

                                                      void OnCollisionEnter(Collision collision)
                                                      {
                                                          if (collision.gameObject.CompareTag(\"MainPlatform\") && !isInactive)
                                                          {
                                                              isInactive = true;
                                                              platformCollider.enabled = false;
                                                              platformRenderer.enabled = false;
                                                              rb.isKinematic = true;
                                                          }
                                                      }

                                                      public void ResetPlatform()
                                                      {
                                                          isInactive = false;
                                                          transform.position = initialPosition;
                                                          transform.rotation = initialRotation;
                                                          rb.isKinematic = true;
                                                          hasFallen = false;
                                                          if (platformCollider != null) platformCollider.enabled = true;
                                                          if (platformRenderer != null) platformRenderer.enabled = true;
                                                      }
                                                  }<\/code><\/pre>\n\n\n\n
                                                  GameOverUI.cs<\/h2>\n\n\n\n
                                                  Controlador del men\u00fa Game Over.Reinicia o cierra el juego y permite al jugador reintentarlo o salir.<\/p>\n\n\n\n
                                                  using UnityEngine;
                                                  using UnityEngine.SceneManagement;

                                                  public class GameOverUI : MonoBehaviour
                                                  {
                                                      public void Retry()
                                                      {
                                                          SceneManager.LoadScene(\"SampleScene\");
                                                      }

                                                      public void QuitGame()
                                                      {
                                                          Application.Quit();
                                                      }
                                                  }<\/code><\/pre>\n\n\n\n
                                                  GreenCoin.cs<\/h2>\n\n\n\n
                                                  RMoneda que otorga vida al jugador. Comprueba si necesita vida y la otorga.<\/p>\n\n\n\n
                                                  using UnityEngine;

                                                  public class GreenCoin : MonoBehaviour
                                                  {
                                                      private void OnTriggerEnter(Collider other)
                                                      {
                                                          PlayerLifeSystem playerLife = other.GetComponent<PlayerLifeSystem>();
                                                          if (playerLife != null)
                                                          {
                                                              if (playerLife.NeedsLife())
                                                              {
                                                                  playerLife.GainLife();
                                                                  Destroy(gameObject);
                                                              }
                                                              else
                                                              {
                                                                  Debug.Log(\"Vidas completas, no se puede recoger la moneda.\");
                                                              }
                                                          }
                                                      }
                                                  }<\/code><\/pre>\n\n\n\n
                                                  KillZone.cs<\/h2>\n\n\n\n
                                                  Zona letal que da\u00f1a al jugador. OnTriggerEnter quita una vida y define zonas de peligro en el nivel.<\/p>\n\n\n\n
                                                  using UnityEngine;

                                                  public class KillZone : MonoBehaviour
                                                  {
                                                      private void OnTriggerEnter(Collider other)
                                                      {
                                                          if (other.CompareTag(\u201cPlayer\u201d))
                                                          {
                                                              PlayerLifeSystem pls = other.GetComponent<PlayerLifeSystem>();
                                                              if (pls != null)
                                                              {
                                                                  pls.TakeDamage();
                                                              }
                                                          }
                                                      }
                                                  }<\/p>\n\n\n\n
                                                  MainMenu.cs<\/h2>\n\n\n\n
                                                  Maneja botones del men\u00fa principal.Inicia, muestra opciones y cierra con navegaci\u00f3n inicial del juego.<\/p>\n\n\n\n
                                                  using UnityEngine;
                                                  using UnityEngine.SceneManagement;

                                                  public class MainMenu : MonoBehaviour
                                                  {
                                                      public void StartGame()
                                                      {
                                                          SceneManager.LoadScene(\"YourGameScene\");
                                                      }

                                                      public void Options()
                                                      {
                                                          Debug.Log(\"Opciones\");
                                                      }

                                                      public void QuitGame()
                                                      {
                                                          Application.Quit();
                                                          Debug.Log(\"Juego cerrado\");
                                                      }
                                                  }<\/code><\/pre>\n\n\n\n
                                                  MainMenuManager.cs<\/h2>\n\n\n\n
                                                  Controla inicializaci\u00f3n y transici\u00f3n del men\u00fa al juego.Pausa, oculta UI y reanuda con Play.Transici\u00f3n fluida entre UI y gameplay.<\/p>\n\n\n\n
                                                  using UnityEngine;

                                                  public class MainMenuManager : MonoBehaviour
                                                  {
                                                      public CameraFollow cameraFollowScript;
                                                      public GameObject Canvas;

                                                      void Start()
                                                      {
                                                          Time.timeScale = 0;
                                                          Cursor.lockState = CursorLockMode.None;
                                                          Cursor.visible = true;
                                                          cameraFollowScript.enabled = false;
                                                          Canvas.SetActive(false);
                                                      }

                                                      public void PlayGame()
                                                      {
                                                          Time.timeScale = 1;
                                                          Cursor.lockState = CursorLockMode.Locked;
                                                          Cursor.visible = false;
                                                          cameraFollowScript.enabled = true;
                                                          Canvas.SetActive(true);
                                                          gameObject.SetActive(false);
                                                      }
                                                  }<\/code><\/pre>\n\n\n\n
                                                  MovingPlatform.cs<\/h2>\n\n\n\n
                                                  Plataforma que se mueve entre dos puntos,Kinematic MoveBetween A-B con velocidad definida. Desaf\u00edo de sincronizaci\u00f3n y dinamismo al nivel.<\/p>\n\n\n\n
                                                  using UnityEngine;
                                                  [RequireComponent(typeof(Rigidbody))]
                                                  public class MovingPlatform : MonoBehaviour
                                                  {
                                                      public Vector3 pointA = Vector3.zero;
                                                      public Vector3 pointB = new Vector3(3, 0, 0);
                                                      public float speed = 2f;
                                                      public float tolerance = 0.05f;

                                                      private Vector3 worldPointA, worldPointB, target, velocity;
                                                      private Rigidbody rb;

                                                      private void Start()
                                                      {
                                                          rb = GetComponent<Rigidbody>();
                                                          rb.isKinematic = true;
                                                          rb.interpolation = RigidbodyInterpolation.Interpolate;
                                                          worldPointA = transform.position + pointA;
                                                          worldPointB = transform.position + pointB;
                                                          target = worldPointB;
                                                      }

                                                      private void FixedUpdate()
                                                      {
                                                          Vector3 current = rb.position;
                                                          Vector3 newPos = Vector3.MoveTowards(current, target, speed * Time.fixedDeltaTime);
                                                          velocity = (newPos - current) \/ Time.fixedDeltaTime;
                                                          rb.MovePosition(newPos);
                                                          if (Vector3.Distance(newPos, target) < tolerance)
                                                              target = target == worldPointA ? worldPointB : worldPointA;
                                                      }

                                                      public Vector3 GetVelocity() => velocity;

                                                  #if UNITY_EDITOR
                                                      private void OnDrawGizmosSelected()
                                                      {
                                                          Vector3 a = Application.isPlaying ? worldPointA : transform.position + pointA;
                                                          Vector3 b = Application.isPlaying ? worldPointB : transform.position + pointB;
                                                          Gizmos.color = Color.green; Gizmos.DrawSphere(a, 0.1f);
                                                          Gizmos.color = Color.red;   Gizmos.DrawSphere(b, 0.1f);
                                                          Gizmos.color = Color.yellow;Gizmos.DrawLine(a, b);
                                                      }
                                                  #endif
                                                  }<\/code><\/pre>\n\n\n\n
                                                  PlayerController.cs<\/h2>\n\n\n\n
                                                  Control principal de jugador: movimiento, salto, ataque y plataforma. Input System, animaciones, detecci\u00f3n OverlapSphere y TriggerFall.<\/p>\n\n\n\n
                                                  using UnityEngine;
                                                  using UnityEngine.InputSystem;

                                                  [RequireComponent(typeof(CharacterController))]
                                                  public class PlayerController : MonoBehaviour
                                                  {
                                                      public float speed = 5f; public float gravity = -9.81f; public float jumpHeight = 2f; public float speedSmooth = 10f;
                                                      public float attackRange = 1.5f; public int attackDamage = 1; public LayerMask enemyLayer;

                                                      private CharacterController controller; private PlayerControls inputActions;
                                                      private Vector2 moveInput; private Vector3 velocity; private bool jumpRequested = false;
                                                      private Animator animator; private float currentAnimSpeed = 0f;

                                                      private void Awake()
                                                      {
                                                          controller = GetComponent<CharacterController>();
                                                          inputActions = new PlayerControls();
                                                          animator = GetComponentInChildren<Animator>();
                                                      }

                                                      private void OnEnable()
                                                      {
                                                          inputActions.Player.Enable();
                                                          inputActions.Player.Move.performed += ctx => moveInput = ctx.ReadValue<Vector2>();
                                                          inputActions.Player.Move.canceled += ctx => moveInput = Vector2.zero;
                                                          inputActions.Player.Jump.performed += ctx => jumpRequested = true;
                                                          inputActions.Player.Attack.performed += ctx => animator.SetTrigger(\"Attack\");
                                                      }

                                                      public void PerformAttack()
                                                      {
                                                          Collider[] hits = Physics.OverlapSphere(transform.position, attackRange, enemyLayer);
                                                          foreach (Collider c in hits)
                                                              c.GetComponent<IDamageable>()?.TakeDamage(attackDamage);
                                                      }

                                                      private void Update()
                                                      {
                                                          bool isGrounded = controller.isGrounded;
                                                          animator.SetBool(\"isGrounded\", isGrounded);
                                                          float targetSpeed = new Vector2(moveInput.x, moveInput.y).magnitude;
                                                          currentAnimSpeed = Mathf.Lerp(currentAnimSpeed, targetSpeed, speedSmooth * Time.deltaTime);
                                                          animator.SetFloat(\"Speed\", currentAnimSpeed);
                                                          animator.SetBool(\"isRunning\", targetSpeed > 0.1f);

                                                          if (isGrounded)
                                                          {
                                                              if (velocity.y < 0) velocity.y = -2f;
                                                              if (jumpRequested)
                                                              {
                                                                  velocity.y = Mathf.Sqrt(jumpHeight * -2f * gravity);
                                                                  jumpRequested = false;
                                                                  animator.ResetTrigger(\"Jump\"); animator.SetTrigger(\"Jump\");
                                                              }
                                                          }
                                                          velocity.y += gravity * Time.deltaTime;
                                                          Vector3 move = transform.right * moveInput.x + transform.forward * moveInput.y;
                                                          controller.Move((move * speed + Vector3.up * velocity.y) * Time.deltaTime);
                                                      }

                                                      private void OnControllerColliderHit(ControllerColliderHit hit)
                                                      {
                                                          hit.gameObject.GetComponent<FallingPlatform>()?.TriggerFall();
                                                      }

                                                      private void OnDrawGizmosSelected()
                                                      {
                                                          Gizmos.color = Color.red;
                                                          Gizmos.DrawWireSphere(transform.position, attackRange);
                                                      }
                                                  }<\/code><\/pre>\n\n\n\n
                                                  PlayerLifeSystem.cs<\/h2>\n\n\n\n
                                                  Sistema de puntos de vida del jugador con respawn y Game Over.Ca\u00eddas, ca\u00edda fuera del mapa, UI de vidas, reinicio plataformas. Control del ciclo de vida del jugador y gesti\u00f3n de errores en ca\u00edda.<\/p>\n\n\n\n
                                                  using System.Collections;
                                                  using UnityEngine;
                                                  using UnityEngine.SceneManagement;

                                                  public class PlayerLifeSystem : MonoBehaviour
                                                  {
                                                      public int maxLives = 3; public Transform respawnPoint; public float minFallHeight = 2.357f; public float deathYLimit = -20f;
                                                      public UIManager uiManager;

                                                      private int currentLives; private float highestY; private bool isFalling = false; private bool wasGroundedLastFrame = true; private bool lifeLostThisFall = false;
                                                      private CharacterController controller; private GameObject lastGroundedObject;
                                                      public Vector3 velocity = Vector3.zero;
                                                      public int CurrentLives => currentLives;

                                                      void Start()
                                                      {
                                                          controller = GetComponent<CharacterController>();
                                                          if (controller == null || respawnPoint == null) { enabled = false; return; }
                                                          currentLives = maxLives; highestY = transform.position.y;
                                                          uiManager?.UpdateLives(currentLives);
                                                      }

                                                      void Update()
                                                      {
                                                          bool isGrounded = controller.isGrounded; float currentY = transform.position.y;
                                                          if (!isGrounded)
                                                          {
                                                              if (currentY > highestY) highestY = currentY;
                                                              if (!isFalling) { isFalling = true; lifeLostThisFall = false; }
                                                          }
                                                          if (isGrounded && !wasGroundedLastFrame && isFalling)
                                                          {
                                                              float fallDistance = highestY - currentY;
                                                              RaycastHit hit; if (Physics.Raycast(transform.position, Vector3.down, out hit, 2f)) lastGroundedObject = hit.collider.gameObject;
                                                              if (fallDistance >= minFallHeight && !lifeLostThisFall && lastGroundedObject.CompareTag(\"MainPlatform\"))
                                                              { LoseLife(); lifeLostThisFall = true; }
                                                              ResetFallTracking();
                                                          }
                                                          if (transform.position.y < deathYLimit && !lifeLostThisFall) { LoseLife(); lifeLostThisFall = true; }
                                                          wasGroundedLastFrame = isGrounded;
                                                      }

                                                      void OnControllerColliderHit(ControllerColliderHit hit) { if (controller.isGrounded) lastGroundedObject = hit.gameObject; }

                                                      void LoseLife()
                                                      {
                                                          currentLives--; uiManager?.UpdateLives(currentLives);
                                                          if (currentLives > 0) Respawn(); else GameOver();
                                                      }
                                                      void Respawn()
                                                      {
                                                          velocity = Vector3.zero; controller.enabled = false; transform.position = respawnPoint.position; controller.enabled = true; ResetFallTracking();
                                                          foreach (var p in FindObjectsByType<FallingPlatform>(FindObjectsSortMode.None)) p.ResetPlatform();
                                                      }
                                                      void GameOver() { SceneManager.LoadScene(\"GameOverScene\"); }
                                                      void ResetFallTracking() { highestY = transform.position.y; isFalling = false; }
                                                      public bool NeedsLife() => currentLives < maxLives;
                                                      public void GainLife() { if (NeedsLife()) { currentLives++; uiManager?.UpdateLives(currentLives); } }
                                                      public void TakeDamage() { LoseLife(); }
                                                  }<\/code><\/pre>\n\n\n\n
                                                  Roller.cs<\/h2>\n\n\n\n
                                                  Rodillo que da\u00f1a al jugador y se destruye al finalizar recorrido.Detecta triggers y colisiones con el Player.<\/p>\n\n\n\n
                                                  using UnityEngine;

                                                  public class Roller : MonoBehaviour
                                                  {
                                                      public bool HasLeftPlatform { get; private set; } = false;
                                                      public bool IsDone { get; private set; } = false;
                                                      public bool HasTouchedPlazaRoll { get; private set; } = false;

                                                      void OnTriggerEnter(Collider other)
                                                      {
                                                          if (other.CompareTag(\"PlazaRoll\"))
                                                              HasTouchedPlazaRoll = true;
                                                          else if (other.CompareTag(\"RollerEnd\"))
                                                          {
                                                              HasLeftPlatform = true;
                                                              IsDone = true;
                                                              Destroy(gameObject);
                                                          }
                                                      }

                                                      void OnCollisionEnter(Collision collision)
                                                      {
                                                          if (collision.gameObject.CompareTag(\"Player\"))
                                                          {
                                                              collision.gameObject.GetComponent<PlayerLifeSystem>()?.TakeDamage();
                                                          }
                                                      }
                                                  }<\/code><\/pre>\n\n\n\n
                                                  RollerSpawner.cs<\/h2>\n\n\n\n
                                                  Generador alternado de rodillos en puntos izquierdo\/derecho. Controla spawn y evita repeticiones.Ritmo de obst\u00e1culos y variabilidad.<\/p>\n\n\n\n
                                                  using UnityEngine;
                                                  using System.Collections;

                                                  public class RollerSpawner : MonoBehaviour
                                                  {
                                                      public GameObject[] rollerPrefabs;
                                                      public Transform leftSpawnPoint;
                                                      public Transform rightSpawnPoint;
                                                      public float spawnDelay = 1.5f;

                                                      private bool spawnLeftNext = true;
                                                      private int lastPrefabIndex = -1;

                                                      void Start()
                                                      {
                                                          StartCoroutine(SpawnRollersAlternately());
                                                      }

                                                      IEnumerator SpawnRollersAlternately()
                                                      {
                                                          while (true)
                                                          {
                                                              Transform sp = spawnLeftNext ? leftSpawnPoint : rightSpawnPoint;
                                                              int idx = GetRandomPrefabIndex();
                                                              GameObject roller = Instantiate(rollerPrefabs[idx], sp.position, Quaternion.identity);
                                                              Roller rs = roller.GetComponent<Roller>();
                                                              if (rs != null)
                                                                  yield return new WaitUntil(() => rs.HasTouchedPlazaRoll);
                                                              else
                                                                  yield return new WaitForSeconds(spawnDelay);
                                                              spawnLeftNext = !spawnLeftNext;
                                                          }
                                                      }

                                                      int GetRandomPrefabIndex()
                                                      {
                                                          int idx;
                                                          do { idx = Random.Range(0, rollerPrefabs.Length); }
                                                          while (idx == lastPrefabIndex);
                                                          lastPrefabIndex = idx;
                                                          return idx;
                                                      }
                                                  }<\/code><\/pre>\n\n\n\n
                                                  UIManager.cs<\/h2>\n\n\n\n
                                                  Gestiona UI de vidas.Actualiza contador en pantalla.Feedback inmediato al jugador sobre sus vidas restantes.<\/p>\n\n\n\n
                                                  using UnityEngine;
                                                  using TMPro;

                                                  public class UIManager : MonoBehaviour
                                                  {
                                                      public TextMeshProUGUI livesText;

                                                      public void UpdateLives(int currentLives)
                                                      {
                                                          livesText.text = \"Vidas: \" + currentLives;
                                                      }
                                                  }<\/code><\/pre>\n\n\n\n
                                                  VictoryTrigger.cs<\/h2>\n\n\n\n
                                                  Detecta llegada a meta y activa UI de victoria<\/p>\n\n\n\n
                                                  using UnityEngine;

                                                  public class VictoryTrigger : MonoBehaviour
                                                  {
                                                      public VictoryUIManager victoryUI;

                                                      void OnCollisionEnter(Collision collision)
                                                      {
                                                          if (collision.gameObject.CompareTag(\"Player\"))
                                                          {
                                                              victoryUI.ShowVictoryScreen();
                                                          }
                                                      }
                                                  }<\/code><\/pre>\n\n\n\n
                                                  VictoryUIManager.cs<\/h2>\n\n\n\n
                                                  Controla panel de victoria y navegaci\u00f3n entre niveles.<\/p>\n\n\n\n
                                                  using UnityEngine;
                                                  using UnityEngine.SceneManagement;

                                                  public class VictoryUIManager : MonoBehaviour
                                                  {
                                                      public GameObject victoryPanel;

                                                      void Start()
                                                      {
                                                          if (victoryPanel != null)
                                                              victoryPanel.SetActive(false);
                                                      }

                                                      public void ShowVictoryScreen()
                                                      {
                                                          if (victoryPanel != null)
                                                          {
                                                              Time.timeScale = 0f;
                                                              victoryPanel.SetActive(true);
                                                          }
                                                      }

                                                      public void RetryLevel()
                                                      {
                                                          Time.timeScale = 1f;
                                                          SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);
                                                      }

                                                      public void NextLevel()
                                                      {
                                                          Time.timeScale = 1f;
                                                          int nextSceneIndex = SceneManager.GetActiveScene().buildIndex + 1;
                                                          if (nextSceneIndex < SceneManager.sceneCountInBuildSettings)
                                                              SceneManager.LoadScene(nextSceneIndex);
                                                          else
                                                              Debug.Log(\"\u00a1No hay m\u00e1s niveles!\");
                                                      }
                                                  }


                                                  <\/code><\/pre>\n\n\n\n
                                                  Video explicaci\u00f3n <\/h2>\n\n\n\n
                                                  \n