Videojuego 3D en Unity: así creamos Reliquias de Aldoria paso a paso
Introducción
Este artículo explica, paso a paso, cómo se desarrolló Reliquias de Aldoria, un videojuego 3D en Unity de plataformas en tercera persona, creado en Unity 6 por Juan David Cadena Zambrano, Steven Alejandro Beltrán López y Dilan Villota para la asignatura Modelado y Videojuegos de la Universidad Central. En el juego, un duende entra al castillo de Aldoria, tomado por un ogro, para rescatar a los duendecitos bebés encerrados en jaulas. Para lograrlo debe saltar entre plataformas, esquivar trampas y armaduras encantadas, recoger llaves y, al final, derrotar al ogro en la sala del trono.
Cómo está organizado este artículo
El recorrido sigue el orden en que se hizo el trabajo: siete fases y 23 pasos, desde la creación del proyecto hasta la compilación para Windows, navegador web y Android. Cada paso empieza con su propósito, presenta un procedimiento numerado que se puede repetir en otro proyecto, explica cómo funciona lo construido y termina con el resultado obtenido. Los personajes se diseñaron con ChatGPT, se modelaron con Meshy y se retocaron en Blender.
Las figuras provienen de cuatro fuentes. La primera son fotogramas de las grabaciones de pantalla de dos sesiones de trabajo de Juan David Cadena, del 5 y del 8 de noviembre de 2026, que muestran en tiempo real la creación del primer personaje y la construcción del Nivel 1. La segunda son las imágenes de referencia de los personajes y las ilustraciones de la cinemática, generadas con ChatGPT (OpenAI, 2026). La tercera son capturas del espacio de trabajo de Meshy, la herramienta con la que esas imágenes se convirtieron en modelos 3D (Meshy, s. f.).
La cuarta son capturas del editor y del juego tomadas al final del proyecto: como los niveles se construyen con scripts de editor, se pudieron reconstruir por etapas para mostrar cada fase de su construcción. En algunos fotogramas de las grabaciones se ve, a un lado del editor, el panel de Claude Code, el asistente de programación con inteligencia artificial que el equipo usó durante el desarrollo (Anthropic, 2026). La nota de cada figura indica su origen, y el documento sigue las normas de la séptima edición del manual de publicaciones de la American Psychological Association (2020).
Juega este videojuego 3D en Unity desde el navegador
Antes de ver cómo se hizo, puedes jugarlo aquí mismo. Haz clic en el juego para empezar y usa el botón de la esquina inferior derecha para verlo en pantalla completa. Se mueve con W A S D, la cámara con el mouse, se salta con la barra espaciadora (dos veces para el doble salto), se corre con Shift y se pausa con P. En el celular aparecen controles táctiles.
Las versiones para Windows y Android se pueden descargar desde la página del juego en itch.io.
Mira el gameplay del videojuego
Si prefieres verlo antes de jugarlo, este video muestra una partida por los tres niveles de Reliquias de Aldoria, desde el jardín del castillo hasta la pelea contra el ogro.
Objetivos
Objetivo general
Desarrollar un videojuego de plataformas 3D de tres niveles en Unity, con personajes modelados, inteligencia artificial para los enemigos, sonido y una interfaz de juego, aplicando los conceptos de modelado 3D y desarrollo de videojuegos vistos en la asignatura, y documentar el proceso como un tutorial que se pueda seguir paso a paso.
Objetivos específicos
- Diseñar las mecánicas del juego (salto doble, llaves, jaulas, corazones, vidas y tiempo) y documentarlas en un documento de diseño del juego (GDD).
- Crear los personajes en 3D a partir de imágenes de referencia, con un esqueleto que permita animarlos en Unity.
- Construir tres niveles con un estilo visual coherente, cada uno con su ambientación, luces y dificultad propias.
- Programar enemigos con inteligencia artificial basada en máquinas de estados y navegación por NavMesh, además de un jefe final.
- Agregar música, ambiente y efectos de sonido con licencia libre, citando cada fuente.
- Publicar el juego para computador, navegador web y celulares, y coordinar el trabajo del grupo con Git y GitHub.
Descripción del videojuego 3D en Unity
Reliquias de Aldoria es un juego de plataformas 3D en tercera persona. El jugador controla a un duende que puede correr, saltar y hacer un doble salto en el aire. La cámara lo sigue por detrás y se gira con el mouse o, en el celular, deslizando el dedo. En cada nivel hay cinco bebés duende encerrados en jaulas; cada jaula se abre con una llave, y para abrir la salida hay que rescatar al menos tres. La Tabla 1 resume las reglas principales.
Tabla 1
Mecánicas principales del juego
| Elemento | Funcionamiento |
|---|---|
| Salud y vidas | Tres corazones por vida. Un golpe quita un corazón; sin corazones se pierde una vida y se vuelve al último punto de control. Sin vidas aparece la pantalla de Game Over |
| Tiempo | Cada nivel tiene un tiempo límite. En los últimos diez segundos suena un tictac |
| Llaves y jaulas | Las llaves están repartidas por el mapa o las lleva una armadura. Cada jaula gasta una llave y libera a un bebé duende |
| Puntos de control | Estandartes que se izan al pasar; desde ahí se reaparece al caer al vacío o al agua |
| Armadura plateada | Patrulla, persigue y empuja al jugador. Se puede destruir saltándole encima |
| Armadura de pinchos | Más lenta y con casco de pinchos: quita un corazón al tocarla y no se puede aplastar |
| Trampas | Pinchos, hachas péndulo, losas que se caen, troncos rodantes y plataformas móviles |
| Anciano Duende | Personaje que guía al jugador y le regala una vida extra |
| El Ogro (jefe) | Salta hacia el jugador y queda aturdido al caer. Hay que soltarle encima tres lámparas desde las palancas de las torres |
Nota. Elaboración propia.
Los tres niveles forman una sola historia que avanza del exterior al interior del castillo, como se resume en la Tabla 2. Al completar un nivel, el juego carga el siguiente.
Tabla 2
Niveles del juego
| Nivel | Ambientación | Desafíos principales | Responsable |
|---|---|---|---|
| 1. Jardín del castillo | Exterior de día: isla con pasto, agua, árboles, flores y el castillo | Primeras jaulas y llaves, agua peligrosa, primeras armaduras | Juan David Cadena |
| 2. Mazmorra | Interior oscuro con antorchas naranjas y verdes, niebla azul en los fosos | Losas que caen, torre de celdas, guardias con pinchos, galería de hachas | Steven Alejandro Beltrán López |
| 3. Torreón y sala del trono | Exterior nocturno con luna, armería, puente con alfombra y sala circular | Troncos rodantes, plataformas móviles, elevador, pelea contra el Ogro | Steven Alejandro Beltrán López |
Nota. Elaboración propia.
Herramientas y recursos utilizados
El juego se desarrolló en Unity 6 (versión 6000.6.3f1) con el Universal Render Pipeline (URP), que permite publicar el mismo proyecto para Windows, navegador web (WebGL) y Android (Unity Technologies, 2026d, 2026e). Los personajes se diseñaron con ChatGPT y se modelaron con Meshy. La Tabla 3 resume las herramientas y los recursos empleados.
Tabla 3
Herramientas y recursos utilizados
| Herramienta o recurso | Uso en el proyecto |
|---|---|
| Unity 6 con URP | Motor del juego, editor de escenas y render de los tres niveles (Unity Technologies, 2026d, 2026e) |
| C# y Visual Studio | Programación del jugador, los enemigos, las trampas, la interfaz y los scripts que construyen los niveles |
| Input System | Controles con teclado, mouse, control de videojuegos y pantalla táctil (Unity Technologies, 2026c) |
| Cinemachine | Cámara en tercera persona que sigue al duende (Unity Technologies, 2026b) |
| AI Navigation (NavMesh) | Mapa de navegación por el que caminan los enemigos (Unity Technologies, 2026a) |
| Starter Assets – Third Person | Base del controlador del personaje, animaciones y sonidos de pasos (Unity Technologies, s. f.) |
| Claude Code (Claude Opus 5.5) | Asistente de programación con inteligencia artificial: apoyo en la escritura y la depuración de los scripts en C#, en los scripts de editor que construyen los niveles, en las compilaciones y en la preparación de este artículo (Anthropic, 2026) |
| ChatGPT | Imágenes de referencia de los personajes e ilustraciones de la cinemática de introducción (OpenAI, 2026) |
| Meshy | Conversión de las imágenes de referencia en modelos 3D con textura y esqueleto (Meshy, s. f.) |
| Blender | Retoque de las texturas y ajustes de los modelos (Blender Foundation, 2026) |
| Paquetes low poly del Asset Store | Árboles, rocas, plantas, materas, escaleras, objetos de decoración y viento en la vegetación (DinV Studio, s. f.; Gigel3d, s. f.; JustCreate, s. f.; Level13, s. f.; Nicrom, 2026; RCstudio3D, 2025; The PolynestLab, 2026) |
| OpenGameArt.org | Música, ambientes y efectos de sonido con licencia CC0 (Creative Commons, s. f.) |
| FFmpeg | Conversión, volumen y mezcla de los archivos de audio (FFmpeg Developers, 2026) |
| Git y GitHub | Control de versiones y trabajo en ramas por integrante (GitHub, s. f.) |
Nota. Elaboración propia.
Los modelos de los paquetes del Asset Store son gratuitos y los sonidos de OpenGameArt tienen licencia CC0, es decir, son de dominio público. Aun así, todos se citan en este artículo como parte del uso ético de la información. Del mismo modo, cada imagen generada con inteligencia artificial se identifica como tal en la nota de su figura.
Cómo seguir este artículo
Requisitos previos
Para repetir los pasos se necesita lo siguiente:
- Un computador con Unity Hub y Unity 6000.6.3f1, con los módulos Windows Build Support, WebGL Build Support y Android Build Support (este último con OpenJDK y Android SDK y NDK).
- Visual Studio o cualquier editor de C# integrado con Unity.
- Una cuenta en ChatGPT para generar las imágenes de referencia y una cuenta en Meshy para convertirlas en modelos 3D.
- Blender, para retocar las texturas de los modelos.
- Git, Git LFS y una cuenta de GitHub para guardar el proyecto y trabajar en equipo.
Convenciones del artículo
Las rutas de los menús se escriben con flechas, por ejemplo Window → Package Manager. Los nombres de scripts, carpetas, componentes y métodos se escriben con letra de ancho fijo, por ejemplo Assets/Scripts. El proyecto tiene un menú propio llamado Reliquias, creado con scripts de editor, desde el cual se construyen los niveles, la interfaz y los personajes; cuando un paso usa una de sus opciones, se indica la ruta completa.
Cronograma del desarrollo
La Tabla 4 ubica cada fase en el tiempo, según el historial del repositorio de GitHub y las grabaciones de pantalla. El proyecto se construyó en dos semanas, y las dos sesiones grabadas corresponden a los primeros días.
Tabla 4
Cronograma del desarrollo según el historial del repositorio
| Fecha (2026) | Hito |
|---|---|
| 5 de noviembre | Configuración inicial del proyecto, carpetas y GDD (Paso 1). Inicio de la primera sesión grabada |
| 5 y 6 de noviembre | Primer personaje, el Duende Caballero, creado con ChatGPT, Meshy y Blender e importado como jugador; greybox del Nivel 1 y demostración de inteligencia artificial (Pasos 3 a 9) |
| 8 y 9 de noviembre | Segunda sesión grabada: texturas de caricatura, luz de tarde dorada y rediseño del Nivel 1 (Pasos 2 y 10) |
| 13 de noviembre | Nivel 2, la mazmorra: constructor, mecánicas y primera versión (Paso 11) |
| 16 de noviembre | Nivel 3, el torreón: constructor, mecánicas y jefe. Imágenes de referencia de los demás personajes y modelos en Meshy (Pasos 4, 5 y 12) |
| 17 de noviembre | Personajes finales en los niveles, decoración de la mazmorra, sonido, cinemática del ogro, menú, cinemática de introducción, selección, misiones, tutorial y HUD (Pasos 13 a 20) |
| 18 de noviembre | Pulido, sensación de juego, versión web, controles táctiles y compilación para Android (Pasos 21 a 23) |
Nota. Elaboración propia a partir del historial de cambios (commits) del repositorio en GitHub.
Conceptos básicos de Unity para un videojuego 3D
Antes de empezar conviene explicar cómo está organizado Unity, porque todo el juego se construyó con estas piezas. Unity es un motor de videojuegos: un programa que ya resuelve el dibujo en 3D, la física, el sonido y la entrada del jugador, y en el que el desarrollador arma sus escenas y programa el comportamiento con scripts en C# (Unity Technologies, 2026d).
Las ventanas del editor
La Figura 1 muestra el editor con la mazmorra abierta. La Tabla 5 resume para qué se usó cada ventana durante el proyecto.
Figura 1
Editor de Unity con la escena del Nivel 2 abierta

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Tabla 5
Ventanas del editor de Unity utilizadas
| Ventana | Para qué sirve | Uso en el proyecto |
|---|---|---|
| Scene (escena) | Vista 3D editable del nivel | Revisar la construcción de los niveles y ubicar objetos |
| Game (juego) | Lo que ve el jugador a través de la cámara | Probar los niveles en modo de juego (botón Play) |
| Hierarchy (jerarquía) | Lista de todos los objetos de la escena, organizados en grupos | Grupos como Nivel2_Estructura, Nivel2_Mecanicas y Nivel2_Ambiente |
| Inspector | Muestra y edita los componentes del objeto seleccionado | Ajustar velocidades, radios, luces, materiales y sonidos |
| Project (proyecto) | Archivos del proyecto: escenas, scripts, modelos, texturas y audio | Organizar Assets/Scripts, Assets/Levels, Assets/Prefabs y Assets/Resources |
| Console (consola) | Mensajes, advertencias y errores | Revisar errores de compilación y los reportes de los scripts |
| Animator | Editor de máquinas de estados de animación | Transiciones entre reposo, caminar, correr y saltar |
| Lighting (iluminación) | Cielo, luz ambiente y niebla de la escena | Ambiente de día, mazmorra y noche |
| Package Manager | Instala paquetes oficiales de Unity | URP, Input System, Cinemachine y AI Navigation |
| Build Profiles | Configura y compila el juego para cada plataforma | Lista de escenas y compilación para Windows, WebGL y Android |
Nota. Elaboración propia.
Escenas, GameObjects y componentes
Cada nivel es una escena (archivo .unity). Una escena contiene GameObjects, que son contenedores vacíos con nombre y posición. Lo que un objeto hace depende de los componentes que tenga: por ejemplo, un cubo es un GameObject con los componentes MeshFilter (la forma), MeshRenderer (el material) y BoxCollider (el choque). Todo GameObject tiene un componente Transform con su posición, rotación y escala. Los scripts que programamos también son componentes, que se agregan a los objetos igual que los de Unity. La Tabla 6 lista los componentes más usados en el juego.
Tabla 6
Componentes de Unity utilizados en el juego
| Componente | Qué hace | Dónde se usó |
|---|---|---|
| Transform | Posición, rotación y escala | Todos los objetos |
| MeshFilter y MeshRenderer | Forma 3D y material con el que se dibuja | Pisos, muros, plataformas y decoración |
| BoxCollider, CapsuleCollider, MeshCollider | Forma invisible con la que se choca | Muros, pisos, plataformas, jaulas |
| CharacterController | Mueve un personaje sin física de rebote, sube escalones y respeta los muros | El duende |
| Rigidbody | Le da física real a un objeto: gravedad, empujes y choques | Piezas de la armadura al desarmarse |
| Animator | Reproduce animaciones según una máquina de estados | Duende, armaduras, anciano, bebés y Ogro |
| NavMeshAgent | Camina por el NavMesh hacia un destino evitando obstáculos | Armaduras |
| NavMeshSurface | Calcula el área por donde se puede caminar | Un objeto por nivel (se calcula al iniciar) |
| Camera y CinemachineBrain | Dibuja la escena y recibe la posición de la cámara virtual | Cámara principal |
| CinemachineCamera | Cámara virtual que sigue y rodea al jugador | PlayerFollowCamera |
| Light | Luz direccional (sol o luna) o puntual (antorchas) | Iluminación de los tres niveles |
| Volume | Efectos de posprocesado sobre la imagen final | Bloom, color y viñeta |
| AudioSource y AudioListener | Fuente de sonido y oído del jugador | Música, ambiente y efectos 3D |
| Canvas | Lienzo de la interfaz de usuario | HUD, menús, mensajes y cinemáticas |
Nota. Elaboración propia.
Por ejemplo, la Figura 2 muestra el Inspector del duende: tiene un CharacterController, el script DuendeController con sus valores de velocidad, salto y gravedad, el componente de entrada del jugador y su Animator. La Figura 3 muestra una armadura, con su NavMeshAgent y su script de inteligencia artificial.
Figura 2
Inspector del duende con sus componentes

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 3
Inspector de una armadura: NavMeshAgent e inteligencia artificial

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Prefabs
Un prefab es un GameObject guardado como archivo, con todos sus componentes, que se puede repetir muchas veces en las escenas. Si se cambia el prefab, cambian todas sus copias. En el juego son prefabs el jugador, cada personaje (armaduras, anciano, bebés y Ogro) y los objetos de decoración de los paquetes low poly, como escaleras, cajas y barriles (Figura 4).
Figura 4
Prefab del Ogro visto en el Inspector

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Scripts en C# y su ciclo de vida
Cada script es una clase de C# que hereda de MonoBehaviour. Unity llama a ciertos métodos del script en momentos precisos, lo que se conoce como ciclo de vida, que se resume en la Tabla 7. Por ejemplo, la llave usa Update para girar y para comprobar en cada cuadro si el duende la tocó.
Tabla 7
Ciclo de vida de un script en Unity
| Método | Cuándo lo llama Unity | Ejemplo en el juego |
|---|---|---|
| Awake | Al crear el objeto, antes que todo | Se calcula el NavMesh antes de que los enemigos empiecen |
| Start | Antes del primer cuadro | El gestor del nivel busca al jugador y construye el HUD |
| Update | Una vez por cuadro (unas 60 veces por segundo) | Leer controles, mover hachas, revisar si se tocó una llave |
| LateUpdate | Después de todos los Update | Mover la cámara en las cinemáticas y aplicar el temblor |
| Corrutinas (IEnumerator) | Se reparten en varios cuadros con yield return | Abrir jaulas y puertas, secuencias del Ogro |
Nota. Elaboración propia.
Para que cualquier objeto encuentre a los sistemas globales sin buscarlos en cada cuadro se usó el patrón singleton: el gestor del nivel y el de la salud guardan una referencia estática a sí mismos (por ejemplo, GestorNivel.Instancia). Los datos ajustables se exponen en el Inspector con [SerializeField] o como campos públicos, y se explican con [Tooltip], lo que permitió afinar la dificultad sin tocar el código (Figura 5).
Figura 5
Inspector del gestor del nivel: reglas, salud, vidas y tiempo

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Física, capas y rayos
Unity usa el motor de física PhysX. En el juego, los choques los resuelven los colliders, y para muchas comprobaciones se usan rayos (Physics.Raycast): una línea invisible que informa con qué choca. Con rayos se revisa si un enemigo ve al jugador, si un muro tapa la cámara de la cinemática y dónde está el suelo. El jugador está en una capa (layer) propia, la 8, para que esos rayos no lo confundan con un muro. Para los elementos interactivos, como llaves, jaulas o pinchos, en lugar de triggers se comprueba la distancia al jugador en cada cuadro, porque el CharacterController no siempre activa los triggers.
Scripts de editor
Además de los scripts del juego, el proyecto tiene scripts de editor, guardados en la carpeta Editor, que solo funcionan dentro de Unity y no se incluyen en el juego compilado. Con el atributo [MenuItem] aparecen como opciones del menú Reliquias, y usan las herramientas del editor: EditorSceneManager para abrir y guardar escenas, AssetDatabase para crear materiales y texturas, y PrefabUtility para colocar prefabs. La Figura 6 muestra el método que construye la mazmorra completa, etapa por etapa.
Figura 6
Script de editor que construye el Nivel 2 por etapas
[MenuItem("Reliquias/Nivel 2/Construir TODO el nivel (mazmorra)")]
public static void ConstruirTodo()
{
AbrirOCrearEscena(); // abre Level2_Mazmorra.unity
PrepararMateriales2(); // texturas y materiales de la mazmorra
ConstruirEstructura(); // pisos, fosos y muros con la cuadrícula
PrepararJugadorYCamaras(); // prefab del duende y cámaras Cinemachine
ConstruirMecanicas(); // llaves, jaulas, trampas y enemigos
AplicarAmbiente(); // luces, antorchas, niebla y posprocesado
DecorarNivel2(); // decoración low poly
DetallesMazmorra(); // niebla azul, cadenas, vigas y barandas
ModelosEnEscena.Aplicar(); // modelos finales de los personajes
EditorSceneManager.SaveScene(EditorSceneManager.GetActiveScene(), RutaEscena);
}
Nota. Fragmento del código fuente del proyecto, escrito en C#. Elaboración propia.
Metodología de trabajo
Organización del equipo
Antes de construir, el grupo escribió el GDD con la historia, los personajes, las mecánicas, los tres niveles y la división de tareas. Cada integrante tuvo un área a cargo, aunque todos colaboraron en pruebas y ajustes, como se muestra en la Tabla 8.
Tabla 8
Aportes de cada integrante
| Integrante | Aportes principales |
|---|---|
| Juan David Cadena | Repositorio del proyecto, Nivel 1 (jardín del castillo), diseño, modelos y animaciones de los personajes, primera versión de la inteligencia artificial, menú principal, cinemática de introducción, selección de personaje, HUD, misiones, tutorial, efectos de sensación de juego, versión web y controles táctiles |
| Steven Alejandro Beltrán López | Nivel 2 (mazmorra), Nivel 3 (torreón y sala del trono), jefe final y sus cinemáticas, sistema de salud, vidas y tiempo, música y efectos de sonido |
| Dilan Villota | Enemigos y obstáculos, pruebas del juego y compilación para Android, según la división de tareas del GDD |
Nota. Elaboración propia.
Control de versiones
El proyecto se guardó en un repositorio de GitHub. Cada integrante trabajó en su propia rama (por ejemplo, la del Nivel 1, la del Nivel 2 y la del Nivel 3), para no dañar el trabajo de los demás, y los cambios se unieron después. Los archivos pesados, como modelos, texturas y audio, se manejaron con Git LFS. Para las escenas de Unity se configuró la herramienta de mezcla inteligente de Unity (UnityYAMLMerge), que ayuda a unir escenas modificadas por dos personas.
Construcción de los niveles con scripts
En lugar de ubicar cada pared y cada objeto a mano, los niveles se construyen con scripts de editor, que aparecen en el menú Reliquias. Cada script crea una parte del nivel a partir de bloques, cilindros y modelos low poly, en este orden: (a) la estructura de pisos y muros, (b) las mecánicas (llaves, jaulas, trampas y enemigos), (c) el ambiente (luces, cielo y niebla), (d) la decoración y (e) los modelos finales de los personajes. Este método permitió corregir y rehacer un nivel completo en segundos y mantener los tres niveles con el mismo estilo.
Para que los muros nunca dejaran huecos, la mazmorra y el torreón usan una cuadrícula de medio metro: se marcan las zonas abiertas (salas, pasillos y fosos) y el script levanta muros automáticamente alrededor de ellas. Además, el Nivel 3 tiene un verificador del recorrido, que revisa por código que todos los saltos se puedan alcanzar con el salto doble del duende y que nada bloquee el camino.
Uso de herramientas de inteligencia artificial
En el proyecto se usaron tres herramientas de inteligencia artificial generativa, cada una para una tarea distinta. ChatGPT generó las imágenes de referencia de los personajes y las ilustraciones de la cinemática (OpenAI, 2026), y Meshy convirtió esas imágenes en modelos 3D con textura y esqueleto (Meshy, s. f.). Claude Code, con el modelo Claude Opus 5.5, se usó como asistente de programación: ayudó a escribir y depurar los scripts en C#, los scripts de editor que construyen los niveles y la configuración de las compilaciones, y apoyó la redacción y la maquetación de este artículo y del anexo con el código fuente (Anthropic, 2026).
En los tres casos, el equipo definió lo que se quería a partir del GDD, revisó cada resultado y lo probó en Unity antes de incluirlo; lo que no funcionaba se corregía o se volvía a generar. Por ese motivo, cada figura que contiene una imagen generada con inteligencia artificial lo indica en su nota, y las tres herramientas aparecen en la lista de referencias.
Fase 1: preparación del proyecto
En esta fase se deja listo el proyecto de Unity antes de crear cualquier contenido: la versión del motor, los paquetes, las carpetas, el repositorio y el estilo visual común de los tres niveles.
Paso 1: crear y configurar el proyecto
El objetivo de este paso es tener un proyecto vacío, configurado para las tres plataformas y guardado en GitHub, sobre el que los tres integrantes puedan trabajar a la vez.
Procedimiento
- En Unity Hub, crear un proyecto nuevo con la plantilla Universal 3D (URP) y la versión 6000.6.3f1.
- En Unity Hub, en Installs → Add modules, instalar Windows Build Support, WebGL Build Support y Android Build Support.
- Abrir Window → Package Manager e instalar Input System, Cinemachine y AI Navigation (Figura 7).
- Desde el Asset Store, agregar e importar Starter Assets – Third Person y los paquetes low poly de la Tabla 3.
- En Edit → Project Settings → Player, verificar que Active Input Handling use el Input System nuevo, y en Tags and Layers crear la etiqueta
Playery la capa 8 para el jugador. - Crear las carpetas
Assets/Scripts(con las subcarpetas Jugador, Enemigos, Obstaculos, Personajes, Sistemas, UI y Editor),Assets/Levels,Assets/PrefabsyAssets/Resources/Audio(Figura 8). - Iniciar el repositorio con Git, activar Git LFS para modelos, texturas y audio, escribir el archivo README con la versión de Unity y el flujo de trabajo, y subirlo a GitHub.
Cómo funciona
En Project Settings también se revisó el URP Asset, que define la calidad del render y de las sombras. Más adelante se crearon dos perfiles, uno para computador y otro para celulares, con sombras y efectos más livianos. Todo el código quedó dentro de Assets/Scripts, una regla del curso que se respetó durante todo el proyecto.
Figura 7
Package Manager con los paquetes del proyecto

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 8
Ventana Project con la organización de carpetas del proyecto

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Resultado
Un proyecto de Unity 6 con URP, los paquetes necesarios, las carpetas organizadas y el repositorio en GitHub. Corresponde al primer cambio del historial, «Configuración inicial del proyecto Unity», del 5 de noviembre de 2026.
Paso 2: materiales y texturas estilo low poly
El objetivo de este paso es que todos los niveles se vean como un mismo juego. Para eso, los materiales no se pintan a mano en cada objeto: se crean por código con un shader propio.
Procedimiento
- Escribir el shader
TriplanarEstilizado.shaderen la carpetaAssets/Scripts/Shaders. - Escribir el script de editor
MaterialesEstilizados, que dibuja texturas de caricatura (pasto, roca, baldosa, ladrillo, madera y hojas) y crea un material por cada una. - Ejecutar Reliquias → Materiales → Generar texturas y materiales.
- Ejecutar Reliquias → Materiales → Aplicar a la escena por nombre, que asigna el material según el nombre de cada objeto (por ejemplo, los objetos llamados «Pasto» reciben el material de pasto).
- Ajustar en el Inspector de cada material las dos texturas (arriba y lados), su escala en metros, el tinte y la intensidad del borde (Figura 9).
Cómo funciona
Un shader es un pequeño programa que se ejecuta en la tarjeta gráfica y decide el color de cada píxel. Este usa proyección triplanar: en lugar de depender del mapeo UV de cada objeto, proyecta la textura desde arriba y desde los lados según la posición en el mundo. Así, al estirar un cubo para hacer un muro o un piso, la textura no se deforma. Además, oscurece los bordes de cada bloque para que se lean como piezas separadas y usa una luz suave tipo caricatura (wrap lighting). Sobre esta base se hicieron después las variantes de la mazmorra y del torreón.
Figura 9
Material de la mazmorra con el shader Triplanar en el Inspector

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Resultado
Un juego de materiales coherente que cualquier nivel puede usar. En la segunda sesión grabada, del 8 de noviembre, se ve cómo el Nivel 1 pasa de bloques grises a pasto, tierra y piedra con estos materiales (Paso 10).
Fase 2: diseño y modelado de los personajes
Los personajes se crearon con un flujo de cuatro herramientas: ChatGPT para la imagen de referencia, Meshy para convertirla en un modelo 3D con textura y esqueleto, Blender para retocar la textura y Unity para configurarlos y animarlos. El primer personaje, el Duende Caballero, se hizo completo en la primera sesión grabada, el 5 de noviembre de 2026; los demás se hicieron con el mismo flujo el 16 de noviembre.
Paso 3: diseñar la imagen de referencia con ChatGPT
El objetivo de este paso es obtener una imagen limpia de cada personaje que Meshy pueda convertir en 3D. Meshy funciona mejor con una imagen de cuerpo completo, sobre fondo blanco, en pose T (brazos extendidos) y sin sombras fuertes, porque así distingue con claridad los brazos, las piernas y el cuerpo.
Procedimiento
- Escribir en ChatGPT una descripción del personaje que incluya su estilo (low poly, caricatura), su vestuario y sus colores, y pedir explícitamente cuerpo completo, pose T, vista frontal y fondo blanco.
- Revisar la imagen y pedir correcciones hasta que coincida con el GDD: proporciones, colores y accesorios.
- Pedir una hoja de vistas (frente, perfil y espalda) para tener más información del personaje (Figura 10).
- Descargar la imagen final en formato PNG.
Cómo funciona
La Figura 10 muestra este paso en la primera sesión: la imagen frontal del Duende Caballero, con su túnica roja, el casco plateado y la pluma roja, y la hoja con sus tres vistas. Con el mismo método se diseñaron los otros dos duendes jugables y una propuesta de duende arquero que no pasó a la versión final (Figura 11); los personajes secundarios (Figura 12) y las dos armaduras enemigas, que se diferencian por el color del tabardo y por sus pinchos (Figura 13).
Figura 10
Imagen de referencia del Duende Caballero en ChatGPT

Nota. (a) Vista frontal en pose T. (b) Hoja con las vistas de frente, perfil y espalda. Imágenes generadas con ChatGPT (OpenAI, 2026). Fotogramas de la grabación de pantalla de la sesión del 5 de noviembre de 2026 (tiempos 01:06:05 y 01:18:05). Elaboración propia.
Figura 11
Imágenes de referencia de los duendes

Nota. (a) Duende mago. (b) Duende aventurero. (c) Duende arquero, propuesta que no se incluyó en el juego. Imagen generada con ChatGPT (OpenAI, 2026) el 16 de noviembre de 2026 a partir de una descripción escrita por el equipo.
Figura 12
Imágenes de referencia de los personajes secundarios

Nota. (a) Anciano Duende, que guía al jugador. (b) Bebé duende, que el jugador rescata. (c) El Ogro, jefe final, con el Amuleto Esmeralda en el pecho. Imagen generada con ChatGPT (OpenAI, 2026) el 16 de noviembre de 2026 a partir de una descripción escrita por el equipo.
Imágenes de referencia de las armaduras encantadas
Figura 13

Nota. (a) Armadura plateada con tabardo azul, que se puede aplastar. (b) Armadura oscura de pinchos con tabardo rojo, que hace daño al tocarla. Imagen generada con ChatGPT (OpenAI, 2026) el 16 de noviembre de 2026 a partir de una descripción escrita por el equipo.
Resultado
Una imagen de referencia por personaje, todas con el mismo estilo, lista para convertirla en 3D.
Paso 4: generar los modelos 3D en Meshy
El objetivo de este paso es convertir cada imagen de referencia en un modelo 3D con textura. Meshy es una herramienta en línea que genera modelos con inteligencia artificial a partir de un texto o de una imagen (Meshy, s. f.); en este proyecto se usó la opción de imagen a 3D.
Procedimiento
- En Meshy, abrir la sección Modelo y elegir la generación a partir de una imagen.
- Arrastrar la imagen de referencia al recuadro Imagen.
- Configurar la generación como en la Figura 14: modelo Meshy 7.1 – Flagship en modo Alto detalle, resolución Ultra 2K, Textura activada, resolución de la textura en 2K y Mejora de imagen activada.
- Pulsar Generar. Cada modelo tarda unos dos minutos y gasta créditos de la cuenta.
- Revisar el modelo girándolo en el visor. Si algo sale mal, por ejemplo una mano fundida con el cuerpo, generar otra versión; las versiones quedan guardadas en la columna derecha.
Cómo funciona
Figura 14
Ajustes de generación en Meshy con la armadura de pinchos

Nota. A la izquierda, los ajustes de la generación de imagen a 3D; en el centro, el modelo generado (5186 caras y 9007 vértices); a la derecha, el historial de modelos del proyecto. Captura de pantalla del espacio de trabajo de Meshy (Meshy, s. f.), tomada por el equipo el 18 de noviembre de 2026.
En la primera sesión grabada se puede seguir la generación del Duende Caballero: un primer intento, una versión con la textura completa y una versión corregida después de ajustar la imagen de referencia (Figura 15). La columna derecha de Meshy guarda cada intento, lo que permitió comparar versiones antes de elegir la final. Las Figuras 16 y 17 muestran los modelos finales de todos los personajes en el visor de Meshy.
Figura 15
Generación del Duende Caballero en Meshy durante la primera sesión

Nota. (a) Primer intento. (b) Modelo con la textura completa. (c) Versión corregida, en pose T. Espacio de trabajo de Meshy (Meshy, s. f.). Fotogramas de la grabación de pantalla de la sesión del 5 de noviembre de 2026 (tiempos 00:01:00, 00:42:05 y 01:30:05). Elaboración propia.
Figura 16
Modelos 3D de los tres duendes jugables en Meshy

Nota. (a) Duende Caballero. (b) Duende mago. (c) Duende aventurero. Captura de pantalla del espacio de trabajo de Meshy (Meshy, s. f.), tomada por el equipo el 18 de noviembre de 2026.
Modelos 3D de los personajes secundarios y de los enemigos en Meshy
Figura 17

Nota. (a) Anciano Duende. (b) Bebé duende. (c) El Ogro. (d) Armadura plateada. (e) Armadura de pinchos. Captura de pantalla del espacio de trabajo de Meshy (Meshy, s. f.), tomada por el equipo el 18 de noviembre de 2026.
Resultado
Un modelo 3D con textura por personaje, con pocos polígonos, como pide el estilo low poly del juego.
Paso 5: agregar el esqueleto y exportar desde Meshy
Un modelo 3D solo se puede animar si tiene un esqueleto (rig): una jerarquía de huesos que mueve la malla. El objetivo de este paso es que Meshy le ponga a cada personaje un esqueleto compatible con el sistema Humanoid de Unity, para que todos puedan compartir las mismas animaciones.
Procedimiento
- Con el modelo abierto, entrar en Animar → Riggear el modelo.
- En Selecciona el tipo de personaje, elegir Humanoide y pulsar Siguiente (Figura 18a).
- Ubicar los marcadores de barbilla, hombros, codos, muñecas, ingle, rodillas y tobillos sobre el modelo, con Simetría activada para que los dos lados coincidan, y pulsar Confirmar (Figura 18b).
- Abrir la descarga y elegir el formato fbx y la plantilla de esqueleto Unity Humanoid (Figura 19).
- Descargar el archivo y copiarlo en la carpeta de modelos del proyecto, en
Assets/Characters.
Cómo funciona
Figura 18
Asistente de rig de Meshy con el Anciano Duende

Nota. (a) Elección del tipo de personaje: humanoide. (b) Marcadores de las articulaciones sobre el modelo. Captura de pantalla del espacio de trabajo de Meshy (Meshy, s. f.), tomada por el equipo el 18 de noviembre de 2026.
La guía de Meshy recuerda que el rig funciona mejor con personajes en pose T o A, con espacio entre los brazos y el cuerpo, y por eso las imágenes de referencia del Paso 3 se pidieron en pose T. El formato FBX conserva el esqueleto para los motores de juego, y la plantilla Unity Humanoid nombra los huesos como los espera Unity.
Figura 19
Configuración de descarga en Meshy: formato FBX y esqueleto Unity Humanoid

Nota. Captura de pantalla del espacio de trabajo de Meshy (Meshy, s. f.), tomada por el equipo el 18 de noviembre de 2026.
Resultado
Un archivo FBX por personaje, con malla, textura y esqueleto humanoide, listo para Unity.
Paso 6: retocar las texturas en Blender
Las texturas generadas pueden traer manchas, colores mezclados o detalles poco claros, sobre todo en la cara. El objetivo de este paso es corregirlas a mano en Blender (Blender Foundation, 2026).
Procedimiento
- Importar el FBX en Blender con File → Import → FBX.
- Pasar al espacio de trabajo Texture Paint, donde a la izquierda se ve la textura desplegada (mapa UV) y a la derecha el modelo.
- Pintar directamente sobre el modelo para corregir colores y bordes, por ejemplo los ojos, la boca y el cinturón (Figura 20).
- Guardar la imagen de la textura con Image → Save y reemplazarla en la carpeta del personaje en Unity.
Cómo funciona
Figura 20
Retoque de la textura del Duende Caballero en Blender

Nota. (a) Mapa UV de la textura y cuerpo del modelo. (b) Corrección del ojo y la cara. Programa Blender (Blender Foundation, 2026). Fotogramas de la grabación de pantalla de la sesión del 5 de noviembre de 2026 (tiempos 02:30:05 y 02:36:05). Elaboración propia.
Resultado
Texturas limpias, con la cara y los detalles legibles a la distancia de la cámara del juego.
Paso 7: importar los personajes en Unity y animarlos
El objetivo de este paso es que cada modelo quede dentro de Unity como un prefab que camina, corre y salta con las animaciones de los Starter Assets. Al importar un FBX, Unity muestra el modelo gris, sin materiales, hasta que se configuran sus texturas (Figura 21a).
Procedimiento
- Copiar los FBX en
Assets/Charactersy esperar a que Unity los importe. - Ejecutar Reliquias → Personajes → 1. Configurar modelos (Humanoid, texturas, prefabs).
- Para el jugador, seleccionar el modelo y ejecutar Reliquias → Crear jugador con el modelo seleccionado.
- Ejecutar Reliquias → Personajes → 2. Poner modelos en la escena abierta, que reemplaza las cápsulas de prueba por los modelos finales.
- Pulsar Play y comprobar que el personaje camina, corre y salta (Figura 21b).
Cómo funciona
El script del segundo punto hace cuatro cosas: (a) configura cada modelo con un esqueleto Humanoid, (b) extrae sus texturas y crea un material URP por personaje, (c) les asigna controladores de animación compartidos y (d) guarda un prefab por personaje con los pies en el origen y la altura del juego.
Figura 21
El Duende Caballero dentro de Unity

Nota. (a) Modelo recién importado, todavía sin materiales. (b) Personaje con texturas y animaciones en la escena de prueba. Editor de Unity 6 (Unity Technologies, 2026d). Fotogramas de la grabación de pantalla de la sesión del 5 de noviembre de 2026 (tiempos 01:42:05 y 02:54:05). Elaboración propia.
El esqueleto Humanoid es la clave para animar: como todos los personajes tienen la misma estructura de huesos, pueden compartir las mismas animaciones (reposo, caminar, correr, saltar y caer) de los Starter Assets de Unity (Unity Technologies, s. f.). Cada personaje tiene un Animator Controller, una máquina de estados de animación que pasa de una animación a otra según parámetros como la velocidad (Speed), si toca el suelo (Grounded) o si saltó (Jump). En el jugador, esos parámetros los envía el controlador del duende; en los enemigos, un componente copia la velocidad de su agente de navegación al Animator, de modo que caminan más rápido cuando persiguen al jugador. Las animaciones de caminar traen eventos en los pasos, que el juego usa para reproducir el sonido de las pisadas.
La Figura 22 muestra la ventana Animator con el controlador de una armadura. Cada caja es un estado (una animación), las flechas son transiciones y, a la izquierda, están los parámetros que las activan. Para caminar y correr se usa un Blend Tree, que mezcla las dos animaciones según la velocidad. Los tres duendes jugables comparten esqueleto y animaciones; solo cambia el modelo visible, y el Animator del modelo elegido copia cada cuadro los parámetros del jugador.
Ventana Animator con los estados y parámetros de animación
Figura 22

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Resultado
Prefabs de todos los personajes con modelo, material, esqueleto y animaciones, listos para ponerlos en los niveles.
Fase 3: jugabilidad base
Con el primer personaje listo, se programó lo que hace que el juego se sienta como un juego de plataformas: el control del duende, la cámara y los enemigos.
Paso 8: programar el jugador y la cámara
El objetivo de este paso es que el duende responda bien a los controles: que corra, salte, haga doble salto y que la cámara lo siga sin atravesar los muros.
Procedimiento
- Partir del controlador en tercera persona de los Starter Assets (Unity Technologies, s. f.) y crear el script
DuendeControllerenAssets/Scripts/Jugador. - Abrir el archivo de Input Actions y revisar las acciones Move, Look y Jump con sus teclas y botones (Figura 23).
- Programar el salto con la fórmula de la caída libre, el doble salto, el coyote time, el rebote en trampolines y la posibilidad de ser empujado (Figura 24).
- Agregar a la cámara principal un
CinemachineBrain(Figura 25). - Crear una
CinemachineCameraque siga a un punto en la cabeza del duende a una distancia fija (Figura 26).
Cómo funciona
Los controles se definen en un archivo de Input Actions del Input System (Unity Technologies, 2026c). Allí cada acción (moverse, mirar, saltar) se asocia a varias teclas o botones: WASD y flechas, mouse, y los sticks y botones de un control. El código no pregunta por una tecla concreta, sino por la acción, y por eso el mismo juego funciona con teclado, con control y, al final del proyecto, con la pantalla táctil.
Figura 23
Editor de Input Actions con las acciones del jugador

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
El salto se calcula con la fórmula de la caída libre: para subir una altura h con una gravedad g, la velocidad inicial debe ser la raíz de 2·g·h (Figura 24). En cada cuadro la gravedad reduce esa velocidad, y CharacterController.Move desplaza al duende sin atravesar los muros. El doble salto repite la fórmula en el aire con una altura menor, y el coyote time permite saltar un instante después de salir de un borde.
Figura 24
Cálculo del salto en el controlador del duende
private void Saltar(float altura)
{
// velocidad necesaria para subir 'altura' metros: v = raíz(2 · g · h)
_verticalVelocity = Mathf.Sqrt(altura * -2f * Gravity);
_animator.SetBool(_animIDJump, true); // el Animator pasa a la animación de salto
}
// en Update(): la gravedad frena la subida y el CharacterController mueve al duende
_verticalVelocity += Gravity * Time.deltaTime;
_controller.Move(direccion * (velocidad * Time.deltaTime) + Vector3.up * _verticalVelocity * Time.deltaTime);
Nota. Fragmento del código fuente del proyecto, escrito en C#. Elaboración propia.
La cámara usa dos piezas de Cinemachine (Unity Technologies, 2026b). La cámara principal tiene un CinemachineBrain, y una cámara virtual (CinemachineCamera) sigue a un punto ubicado en la cabeza del duende a una distancia fija, con un leve amortiguamiento para que el movimiento sea suave y un componente que la acerca cuando un muro se interpone.
Cámara principal con su CinemachineBrain
Figura 25

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 26
Cámara virtual de Cinemachine que sigue al duende

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Resultado
Un duende que corre, salta y hace doble salto, con una cámara en tercera persona. Es la base del cambio «Agrega el Duende Caballero como jugador con Starter Assets», del 6 de noviembre de 2026.
Paso 9: programar la inteligencia artificial de los enemigos
El objetivo de este paso es que las armaduras patrullen, vean al jugador, lo persigan y lo ataquen. Primero se probó la idea con cápsulas de colores en una escena de demostración, sin modelos, para concentrarse solo en el comportamiento (Figura 27).
Procedimiento
- Crear un objeto con el componente
NavMeshSurfacey un script que llame aBuildNavMeshenAwake(Figura 29). - Crear el enemigo con un
NavMeshAgenty una clase base que perciba al jugador cada 0,2 segundos. - Programar la máquina de estados de la Tabla 9 con un
enumy unswitch(Figura 28). - Darle al enemigo sus puntos de patrulla en el Inspector y probarlo con una cápsula antes de usar el modelo final.
- Programar las otras técnicas de la Tabla 10 en enemigos de prueba y compararlas.
Cómo funciona
Figura 27
Demostración de inteligencia artificial con cápsulas en la primera sesión

Nota. (a) Enemigo de prueba (cápsula azul) en el escenario gris. (b) Enemigo que persigue al duende cerca del agua. La etiqueta sobre cada cápsula muestra su estado actual. Fotogramas de la grabación de pantalla de la sesión del 5 de noviembre de 2026 (tiempos 03:48:05 y 03:54:05). Elaboración propia.
Los enemigos usan el componente NavMeshAgent para moverse por un mapa de navegación (NavMesh) que se genera al iniciar cada nivel (Unity Technologies, 2026a). Todas las IA siguen el mismo ciclo. Primero perciben: miden la distancia al jugador y comprueban si lo ven, es decir, si está dentro de su rango y de su ángulo de visión y si ningún muro lo tapa, lo que se revisa lanzando un rayo. Luego deciden qué hacer. Por último actúan: se mueven con el NavMesh, que calcula la ruta con el algoritmo A*, o atacan. La Tabla 9 muestra la máquina de estados de las armaduras.
Tabla 9
Máquina de estados de las armaduras
| Estado | Qué hace | Pasa a |
|---|---|---|
| Patrullar | Camina despacio entre sus puntos de ruta | Perseguir, si ve al jugador |
| Perseguir | Corre hacia el jugador usando el NavMesh | Atacar, si está cerca; Regresar, si lo pierde de vista unos segundos |
| Atacar | Se detiene, mira al jugador y lo empuja hacia atrás | Perseguir, si el jugador se aleja |
| Regresar | Vuelve a su ruta de patrulla | Perseguir, si lo vuelve a ver; Patrullar, al llegar |
Nota. Elaboración propia.
Figura 28
Máquina de estados de la armadura en C#
protected override void Decidir()
{
switch (estado)
{
case Estado.Patrullar:
if (veAlJugador) { estado = Estado.Perseguir; break; }
IrA(puntosPatrulla[punto].position, velocidadPatrulla);
if (Llego()) punto = (punto + 1) % puntosPatrulla.Length;
break;
case Estado.Perseguir:
if (distanciaJugador <= rangoAtaque) { estado = Estado.Atacar; break; }
if (Time.time - ultimaVezVisto > olvidarTras) { estado = Estado.Regresar; break; }
IrA(jugador.position, velocidadPersecucion); // NavMeshAgent.SetDestination
break;
case Estado.Atacar:
Detener(); MirarHacia(jugador.position); Empujar();
break;
// ... Regresar
}
}
Nota. Fragmento del código fuente del proyecto, escrito en C#. Elaboración propia.
En la Figura 28, un enum guarda el estado actual y un switch decide qué hacer en cada uno. Para moverse, el método IrA le da un destino al NavMeshAgent, que calcula la ruta y mueve a la armadura con la velocidad, la aceleración y el radio configurados en el Inspector. Para la asignatura también se programaron y compararon otras tres técnicas, cada una en un enemigo de prueba, como resume la Tabla 10.
Tabla 10
Técnicas de inteligencia artificial programadas
| Técnica | Cómo decide |
|---|---|
| Máquina de estados | Un estado a la vez y reglas claras para cambiar de estado (la usada en las armaduras del juego) |
| Árbol de comportamiento | Prueba ramas en orden de prioridad: atacar, perseguir, investigar la última posición vista o patrullar |
| IA por utilidad | Da un puntaje a cada acción (perseguir, huir, descansar o patrullar) según la cercanía y su energía, y elige la de mayor puntaje |
| Reglas de los fantasmas de Pac-Man | Cuatro enemigos con reglas distintas para elegir a dónde ir (directo, emboscada, reflejo y huida) que, sin comunicarse, encierran al jugador |
Nota. Elaboración propia.
El NavMesh no se guarda como archivo: se calcula al iniciar cada nivel, antes de que los enemigos se activen. Así, si un nivel se reconstruye, el mapa de navegación siempre coincide con la geometría nueva (Figura 29).
Componente NavMeshSurface que calcula el área de navegación
Figura 29

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Con los modelos del Paso 4 se definieron dos tipos de armadura con colores distintos para que el jugador las reconozca. La plateada con tabardo azul solo empuja y se puede aplastar saltándole encima; al hacerlo, la armadura se desarma y, si llevaba una llave, la suelta. La oscura de pinchos con tabardo rojo quita un corazón al tocarla y hay que esquivarla (Figura 3).
Resultado
Enemigos que patrullan, persiguen y atacan, probados primero con cápsulas y luego con los modelos de las armaduras.
Fase 4: construcción de los niveles
Cada nivel se construyó de lo general a lo particular: primero un greybox, es decir, una maqueta con bloques grises para probar el recorrido y los saltos; después las texturas y el terreno; luego las mecánicas, la luz y la decoración; y por último los modelos finales de los personajes.
Paso 10: construir el Nivel 1, el jardín del castillo
El primer nivel, a cargo de Juan David Cadena, ocurre en el exterior del castillo. Es el que mejor muestra el proceso, porque su construcción quedó grabada en las dos sesiones de trabajo.
Procedimiento
- Ejecutar Reliquias → Generar greybox Nivel 1 (Jardín) para crear la maqueta de bloques grises.
- Recorrer la maqueta con el duende y ajustar distancias y alturas hasta que todos los saltos se sientan justos.
- Ejecutar, en orden, Reliquias → Nivel 1 → 0. Terreno (geografía, agua y caminos), 1. Construir castillo y jardín, 2. Decorar con los assets, 3. Efectos (cascadas, nenúfares, rayos de sol) y 4. Mecánicas (jaulas, llaves, enemigos…).
- Ejecutar Reliquias → Ambiente → Aplicar ambiente del jardín para la luz, el cielo, la niebla y el posprocesado.
- Probar el nivel completo; si algo se corrige en un script, rehacerlo todo con Reliquias → Nivel 1 → Reconstruir TODO el nivel.
Primera versión: el greybox
En la primera sesión, el 5 de noviembre, se armó un greybox sencillo con un camino, un poste rojo de referencia y el castillo hecho de bloques (Figura 30). Esa versión sirvió para la demostración de inteligencia artificial del Paso 9 y quedó guardada en el cambio «Greybox del Nivel 1 y demo de IA para la presentación».
Figura 30
Primer greybox del Nivel 1

Nota. (a) El duende frente al castillo de bloques. (b) Vista general de la isla. Editor de Unity 6 (Unity Technologies, 2026d). Fotogramas de la grabación de pantalla de la sesión del 5 de noviembre de 2026 (tiempos 03:06:05 y 03:30:05). Elaboración propia.
En la segunda sesión, el 8 de noviembre, el nivel se rediseñó desde cero para que tuviera una geografía coherente: una plaza circular, caminos que suben por terrazas y un recorrido más largo (Figura 31).
Figura 31
Rediseño del greybox del Nivel 1 en la segunda sesión

Nota. (a) Primeras plataformas. (b) Plaza circular con el duende. (c) Vista general del recorrido. Editor de Unity 6 (Unity Technologies, 2026d). Fotogramas de la grabación de pantalla de la sesión del 8 de noviembre de 2026 (tiempos 00:18:05, 01:06:05 y 01:36:05). Elaboración propia.
Texturas, agua y castillo
Sobre la maqueta se aplicaron los materiales del Paso 2. En pocas horas el nivel pasó de bloques grises a terrazas de pasto y tierra con caminos de piedra (Figura 32), y luego se agregaron el agua con su recorrido, el castillo al fondo y la vegetación (Figura 33). Al final de la sesión el nivel ya se podía completar (Figura 34).
Figura 32
Texturas de caricatura sobre el greybox del Nivel 1

Nota. (a) Primeras terrazas con pasto, tierra y cercas. (b) Caminos que suben entre terrazas. (c) Vista general del terreno. (d) El terreno con el agua alrededor. Editor de Unity 6 (Unity Technologies, 2026d). Fotogramas de la grabación de pantalla de la sesión del 8 de noviembre de 2026 (tiempos 01:54:05, 02:06:05, 03:18:05 y 03:24:05). Elaboración propia.
Figura 33
Agua, castillo y decoración del Nivel 1

Nota. (a) El duende junto al agua. (b) El terreno con el castillo al fondo. (c) Plataformas sobre el agua frente al castillo. (d) Estandartes, escaleras y árboles low poly. Editor de Unity 6 (Unity Technologies, 2026d). Fotogramas de la grabación de pantalla de la sesión del 8 de noviembre de 2026 (tiempos 03:36:05, 04:12:05, 04:30:05 y 05:24:05). Elaboración propia.
Figura 34
Primera versión jugable del Nivel 1, con el mensaje de nivel completado

Nota. Editor de Unity 6 (Unity Technologies, 2026d). Fotograma de la grabación de pantalla de la sesión del 8 de noviembre de 2026 (tiempo 05:18:05). Elaboración propia.
Versión final por etapas
Después, el nivel se reescribió con los scripts del procedimiento, para poder rehacerlo en segundos. Las siguientes figuras muestran el resultado de cada script: primero el terreno, una isla con colinas, caminos, agua y acantilados (Figura 35); luego el castillo con sus muros, torres y puentes (Figura 36); después las mecánicas, como jaulas, llaves, puntos de control, enemigos y la puerta de salida (Figura 37); la decoración con árboles, flores, rocas y materas de los paquetes low poly (Figura 38); y por último los efectos de cascadas, nenúfares y rayos de sol (Figura 39).
Figura 35
Nivel 1, etapa 1: terreno de la isla con agua y caminos

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 36
Nivel 1, etapa 2: castillo y jardín

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 37
Nivel 1, etapa 3: mecánicas del nivel

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 38
Nivel 1, etapa 4: decoración con vegetación low poly

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 39
Nivel 1, etapa 5: efectos y ambiente final del jardín

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Luz y ambiente
La luz del jardín busca una tarde dorada. Tiene un sol cálido y bajo con sombras suaves; una luz ambiente en degradado de tres colores (cielo azul arriba, tono cálido en el horizonte y tierra abajo); y una niebla azulada que da profundidad y esconde el final del mapa. Encima se aplicó un posprocesado ligero, apto para WebGL, con el sistema de Volumes de URP: corrección de tono, un bloom suave que hace brillar las zonas claras, colores más vivos y una viñeta en los bordes. Los efectos también se hicieron ligeros: las cascadas son láminas con una textura que se desplaza, y los rayos de sol son mallas transparentes inclinadas en la dirección del sol.
En Unity, la luz de una escena se arma con tres herramientas. La primera es la ventana Lighting, con el cielo (skybox), la luz ambiente y la niebla (Figura 40). La segunda son los componentes Light: una luz direccional hace de sol o de luna, y su ángulo define la dirección de las sombras (Figura 41). La tercera es un Volume global con un perfil de posprocesado, en el que se activan Tonemapping, Bloom, Color Adjustments y Vignette (Figura 42). Todos estos valores los aplica un script de ambiente para cada nivel, de modo que se pueden volver a aplicar sin duplicar nada.
Ventana Lighting: cielo, luz ambiente y niebla
Figura 40

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 41
Componente Light de la luz direccional principal

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 42
Volume global con los efectos de posprocesado

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
El Nivel 1 en funcionamiento
Vista desde arriba, el plano del jardín muestra el recorrido completo: el camino de entrada, el estanque central con sus puentes, los jardines laterales y el castillo al fondo (Figura 43). En el juego, al iniciar aparece el objetivo del nivel (Figura 44). En el recorrido hay jaulas junto al agua (Figura 45), armaduras que vigilan las entradas del castillo (Figura 46) y estandartes que sirven de punto de control (Figura 47). La puerta del castillo (Figura 48) solo se abre al rescatar tres bebés.
Figura 43
Nivel 1: plano del jardín visto desde arriba

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 44
Inicio del Nivel 1 con el objetivo y la interfaz de juego

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 45
Jaula con un bebé duende junto al agua del jardín

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 46
Armadura encantada vigilando la entrada del castillo

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 47
Punto de control: estandarte que se iza al pasar

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Puerta del castillo, salida del Nivel 1
Figura 48

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Resultado
El Nivel 1 completo, con terreno, castillo, mecánicas, decoración, efectos y ambiente de tarde, reconstruible desde el menú Reliquias.
Paso 11: construir el Nivel 2, la mazmorra
El segundo nivel, a cargo de Steven Alejandro Beltrán López, transcurre en la mazmorra del castillo. Para que concordara con el Nivel 1 se reutilizaron sus materiales y su estilo, pero con una paleta más fría y oscura. Todo el nivel se construye con un solo script, organizado en etapas (Figura 6).
Procedimiento
- Ejecutar Reliquias → Nivel 2 → Construir TODO el nivel (mazmorra).
- Revisar la estructura generada con la cuadrícula de medio metro: salas, pasillos, fosos y muros (Figura 49).
- Revisar la ubicación de llaves, jaulas, trampas, armaduras, el anciano y los puntos de control (Figura 51).
- Ajustar en el componente
LuzAntorchasel color y el alcance de cada antorcha (Figura 54). - Ejecutar Reliquias → Nivel 2 → Detalles (niebla, cadenas, vigas, barandas) para la decoración final.
Etapa 1: estructura y muros
La Figura 49 muestra la primera etapa. El recorrido pasa por un vestíbulo, un pasillo de celdas, un foso de losas, la sala de guardia, una cornisa, la torre de celdas, la galería de hachas y la sala final con la escalera secreta. El plano de la Figura 50 muestra el resultado de la cuadrícula: cada zona abierta queda rodeada automáticamente por muros gruesos, sin huecos entre ellos.
Figura 49
Nivel 2, etapa 1: estructura de salas, pasillos, fosos y muros

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 50
Nivel 2: plano de la estructura generada con la cuadrícula

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Etapa 2: mecánicas, trampas y enemigos
En la segunda etapa se agregaron llaves, jaulas con bebés, losas que se caen, pinchos, hachas péndulo, armaduras de los dos tipos, el Anciano Duende y los puntos de control (Figura 51 y Figura 52). Tras las primeras pruebas el nivel resultó corto y fácil, así que se amplió, se agregaron más guardias y se obligó a saltar los pinchos de la torre.
Figura 51
Nivel 2, etapa 2: mecánicas, trampas y enemigos

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 52
Nivel 2: plano con la ubicación de las mecánicas

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Etapas 3 y 4: luces, decoración y modelos
Como URP limita la cantidad de luces por objeto, en especial en WebGL y Android, se programó un shader propio (TriplanarMazmorra) que calcula la luz de hasta 24 antorchas a la vez. La mayoría son naranjas y algunas verdes, de tono mágico (Figura 53). Un componente (LuzAntorchas) envía en cada cuadro la posición, el alcance y el color de todas las antorchas al shader con Shader.SetGlobalVectorArray, y les agrega un parpadeo suave con funciones seno para que parezcan fuego (Figura 54). Finalmente se agregó la decoración: niebla azul en los fosos con un shader animado, cadenas, jaulas colgantes, vigas, barandas y estandartes (Figura 55).
Figura 53
Nivel 2, etapa 3: vista superior con la luz de las antorchas

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 54
Componente LuzAntorchas con la lista de antorchas y sus colores

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 55
Nivel 2, etapa 4: decoración, niebla y modelos finales

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
El Nivel 2 en funcionamiento
En el juego, la mazmorra se recorre con la luz de las antorchas (Figura 56). La sala de guardia tiene armaduras que patrullan (Figura 57), los fosos tienen niebla azul y jaulas con brillo verde (Figura 58), hay un punto de control después de la torre de celdas (Figura 59) y, cerca del final, la armadura de pinchos vigila el camino hacia la salida (Figura 60).
Figura 56
Inicio del Nivel 2: vestíbulo de la mazmorra

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 57
Sala de guardia con armaduras patrullando

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 58
Foso con niebla azul, losas que caen y jaula con brillo verde

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 59
Punto de control después de la torre de celdas

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 60
Armadura de pinchos cerca de la salida del Nivel 2

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Resultado
La mazmorra completa, con luz de antorchas propia, niebla en los fosos y una dificultad ajustada después de las pruebas.
Paso 12: construir el Nivel 3, el torreón y la sala del trono
El tercer nivel, también a cargo de Steven Alejandro Beltrán López, se diseñó a partir de un boceto del grupo: el mismo castillo, ahora de noche. Tiene una rampa con troncos rodantes, almenas con plataformas móviles y un elevador, una armería, un puente al aire libre con alfombra y la sala del trono circular, donde ocurre la pelea final.
Procedimiento
- Ejecutar Reliquias → Nivel 3 → Construir TODO el nivel (trono).
- Ejecutar Reliquias → Nivel 3 → Verificar el recorrido, que comprueba por código que todos los saltos se puedan hacer con el doble salto y que nada bloquee el camino.
- Corregir lo que reporte el verificador y volver a construir el nivel.
- Ejecutar Reliquias → Nivel 3 → Enlazar Nivel 2 → Nivel 3 y lista de Build para que la mazmorra lleve al torreón.
Etapa 1: estructura y texturas propias
Para diferenciarlo de la mazmorra se usaron texturas propias: ladrillo del castillo, tablas de madera, mármol en damero y sillares morados (Figura 61). El plano de la Figura 62 muestra en oscuro las zonas al aire libre.
Figura 61
Nivel 3, etapa 1: estructura del torreón, el puente y la sala del trono

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 62
Nivel 3: plano de la estructura, con las zonas al aire libre en oscuro

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Etapas 2 y 3: mecánicas, ambiente nocturno y modelos
En la sala del trono hay cuatro estaciones con andamio, trampolín, palanca y lámpara de araña (Figura 63). Para la noche se cambió el cielo por uno nocturno, se usó una luz direccional azulada como luz de luna y se agregaron rayos de luna, hechos con el mismo material de los rayos de sol del Nivel 1 pero en azul. Las zonas interiores reutilizan la luz de antorchas de la mazmorra, y la sala del trono tiene candelabros y vitrales de colores. Las almenas se generan solas sobre los muros que dan al cielo, y las torres llevan techos cónicos azules como el castillo del Nivel 1 (Figura 64 y Figura 65).
Figura 63
Nivel 3, etapa 2: plataformas, trampas, enemigos y estaciones de la pelea

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 64
Nivel 3, etapa 3: vista superior del nivel terminado

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 65
Nivel 3: vista aérea del nivel terminado

Nota. Captura de pantalla de la escena en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
El Nivel 3 en funcionamiento
El Nivel 3 comienza en la base del torreón (Figura 66). En la rampa ruedan troncos que hay que saltar (Figura 67), en la armería hay otra jaula (Figura 68) y el puente con alfombra que lleva a la sala del trono está vigilado por armaduras (Figura 69) y pinchos (Figura 70).
Figura 66
Inicio del Nivel 3 en la base del torreón

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 67
Rampa con troncos rodantes

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 68
Jaula en la armería del torreón

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 69
Armadura en el pasillo alfombrado hacia la sala del trono

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 70
Pinchos y armadura de pinchos antes de la sala del trono

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Resultado
El torreón nocturno completo, con el recorrido verificado por código y enlazado con la mazmorra.
Fase 5: vida del mundo, jefe final y sonido
Con los tres niveles construidos, se agregó lo que les da vida: el movimiento de los objetos, el jefe final y el sonido.
Paso 13: animar objetos y efectos con código
El objetivo de este paso es animar los objetos del nivel sin crear archivos de animación. Muchos movimientos del juego se programaron con corrutinas de C#, funciones que avanzan un poco en cada cuadro, lo que permite ajustar la velocidad y la distancia de cada movimiento desde el código.
Procedimiento
- Escribir un método que devuelva
IEnumeratory que cambie la posición, la rotación o la escala del objeto poco a poco. - Dentro de un ciclo, avanzar un valor
tde 0 a 1 conTime.deltaTimey suavizarlo conMathf.SmoothStep. - Terminar cada vuelta del ciclo con
yield return nullpara continuar en el siguiente cuadro. - Llamar la corrutina con
StartCoroutinecuando ocurra el evento, por ejemplo al abrir una jaula.
Cómo funciona
La Tabla 11 resume los movimientos programados de esta manera, y la Figura 71 muestra uno de ellos: la puerta del castillo baja poco a poco durante 1,6 segundos, arranca y frena suavemente gracias a Mathf.SmoothStep, y yield return null espera al siguiente cuadro.
Tabla 11
Animaciones programadas con código
| Elemento | Cómo se anima |
|---|---|
| Llaves | Giran sobre sí mismas y suben y bajan siguiendo una onda seno |
| Jaulas | Los barrotes suben; el bebé da dos saltos de alegría, gira y desaparece encogiéndose |
| Puertas y rejas | Se hunden en el suelo como un rastrillo cuando se rescatan los bebés necesarios |
| Estandartes de control | La bandera sube por el asta al pasar el jugador |
| Losas que caen | Tiemblan medio segundo, caen acelerando como con gravedad y reaparecen a los tres segundos |
| Hachas péndulo | Oscilan con una función seno; cada hacha tiene un desfase para que no se muevan todas a la vez |
| Trampolines | La lona se aplasta y se estira al rebotar (efecto de aplastar y estirar) |
| Armadura aplastada | Su modelo cae de espaldas con física (Rigidbody) y las piezas salen volando con impulsos aleatorios |
| Ogro | Se agacha antes de saltar, sigue una parábola en el aire, se infla al rugir y cae de espaldas al ser derrotado |
| Cámara | Tiembla con ruido Perlin en los golpes fuertes y se mueve sola en las cinemáticas |
Nota. Elaboración propia.
Figura 71
Corrutina que abre la puerta del castillo
private IEnumerator Abrir()
{
Sonido.Efecto("puerta");
foreach (var c in hojas.GetComponentsInChildren<Collider>()) c.enabled = false;
Vector3 desde = hojas.position;
for (float t = 0; t < 1f; t += Time.deltaTime / 1.6f)
{
hojas.position = desde + Vector3.down * Mathf.SmoothStep(0, bajar, t);
yield return null; // continúa en el siguiente cuadro
}
}
Nota. Fragmento del código fuente del proyecto, escrito en C#. Elaboración propia.
Resultado
Llaves, jaulas, puertas, trampas y personajes que se mueven con suavidad, sin archivos de animación.
Paso 14: programar el jefe final, el Ogro
El objetivo de este paso es una pelea final con presencia propia. El Ogro usa el modelo creado en los Pasos 3 a 5 (Figura 12c) y funciona con una máquina de estados propia: esperar, presentarse, apuntar, saltar, quedar aturdido y ser derrotado.
Procedimiento
- Programar los estados del Ogro con el mismo esquema de
enumyswitchdel Paso 9. - Mientras apunta, mostrar una sombra roja en el piso que avise dónde va a caer.
- Al aterrizar, dejarlo aturdido unos segundos y hacer temblar la cámara.
- Conectar las palancas de las torres con las lámparas de araña: cada lámpara que le cae encima es un golpe.
- Programar las cinemáticas de presentación y de derrota con franjas de cine y texto que se escribe letra por letra.
Cómo funciona
Mientras el Ogro está aturdido, el jugador debe subir a una torre y pisar la palanca que suelta la lámpara sobre él. Después del segundo golpe, el amuleto del ogro despierta a dos armaduras; al tercero, el amuleto se rompe y el nivel termina. Al verlo por primera vez aparecen franjas de cine, la cámara se acerca al ogro, este ruge y amenaza al jugador (Figura 72 y Figura 73); la Figura 74 muestra el pisotón final antes de que empiece la pelea. Al ser derrotado, la cámara lo muestra cayendo de espaldas.
Figura 72
Cinemática del Ogro: «¿Un duende…? ¿En MI salón del trono?»

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 73
Cinemática del Ogro: «Liberaste a esos mocosos… ¡pero de aquí NO sales!»

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 74
Cinemática del Ogro: amenaza final antes de la pelea

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Resultado
Un jefe final con cinemáticas, temblor de cámara y una pelea de tres golpes que cierra el juego.
Paso 15: agregar el sonido y la música
El objetivo de este paso es que cada nivel tenga su música y su ambiente, y que cada acción suene. El audio se maneja con un sistema propio (Sonido) que se crea solo al iniciar el juego.
Procedimiento
- Descargar música, ambientes y efectos con licencia CC0 de OpenGameArt.org y anotar el autor de cada uno.
- Igualar el volumen de todos los archivos con FFmpeg; los golpes del ogro se hicieron más graves y se mezclaron en capas para darles más fuerza (FFmpeg Developers, 2026).
- Copiar los archivos en
Assets/Resources/Audio, para cargarlos por nombre desde el código. - Ejecutar Reliquias → Audio → Verificar sonidos, que revisa que no falte ningún archivo y aplica los ajustes de importación (Figura 75).
- Escribir los créditos en el archivo
CREDITOS_AUDIO.mddel repositorio.
Cómo funciona
En Unity, cada sonido es un AudioClip y se reproduce con un componente AudioSource. El AudioListener, que va en la cámara, es el oído del jugador. El sistema de sonido crea sus propias fuentes al iniciar: dos para la música (así puede pasar de una pista a otra con un fundido), una para el ambiente y dieciséis voces para los efectos. Para los efectos 3D, el Spatial Blend indica cuánto se oye por la izquierda o la derecha según la posición, y el volumen baja con la distancia. La música se importa en modo Streaming, para no ocupar memoria en WebGL y Android, y los efectos en mono y descomprimidos al cargar, para que suenen sin retraso. La Tabla 12 resume la música y algunos efectos.
Figura 75
Ajustes de importación de un efecto de sonido en el Inspector

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Tabla 12
Música y efectos de sonido utilizados
| Uso en el juego | Sonido | Autor |
|---|---|---|
| Música del Nivel 1 | Medieval: Minstrel Dance | RandomMind (s. f.-b) |
| Música del Nivel 2 | Dungeon Ambience | yd (s. f.) |
| Música del Nivel 3 | Fantasy: Lament for a Warrior’s Soul | RandomMind (s. f.-a) |
| Pelea contra el Ogro | Boss Battle Theme | CleytonKauffman (s. f.) |
| Ambientes | Forest Ambience, Loopable Dungeon Ambience, Wind | TinyWorlds (s. f.); JaggedStone (s. f.); IgnasD (s. f.) |
| Llaves, jaulas, puertas, saltos | Paquetes de efectos RPG | Kenney (s. f.-a); rubberduck (s. f.-d) |
| Golpes, armaduras, agua | Paquetes de golpes, criaturas y agua | rubberduck (s. f.-a, s. f.-b, s. f.-c) |
| Rugido del Ogro | Big Scary Troll Sounds | Darsycho (s. f.) |
| Fanfarrias e interfaz | 85 Short Music Jingles, Interface Sounds | Kenney (s. f.-b, s. f.-c) |
| Hacha y doble salto | Swishes Sound Pack | artisticdude (s. f.) |
Nota. Elaboración propia. Todos los sonidos tienen licencia CC0 (Creative Commons, s. f.).
Resultado
Música por nivel con cambio a la música de pelea, ambiente y más de 40 efectos, todos con licencia libre y citados.
Fase 6: interfaz y experiencia del jugador
Esta fase convirtió los tres niveles en un juego completo: con una interfaz propia, un menú, una historia, la elección de personaje y ayudas para el jugador.
Paso 16: crear la interfaz de juego y su estilo visual
El objetivo de este paso es una interfaz que se lea bien en cualquier pantalla y que tenga el estilo de un cuento medieval, de madera y pergamino, en lugar del aspecto de un programa cualquiera.
Procedimiento
- Ejecutar Reliquias → Menú → Generar piezas gráficas de la UI, que dibuja por código las piezas de la Figura 76.
- Crear cada interfaz como un
Canvasen modo Screen Space – Overlay con unCanvasScalerde referencia 1920 × 1080. - Ubicar los paneles con
RectTransformy anclas: bebés y llaves arriba a la izquierda; salud, vidas y tiempo arriba a la derecha; mensajes en el centro superior. - Agregar a cada botón el componente
BotonAnimadoy usar la fuente Lilita One en los textos.
Cómo funciona
Las piezas se dibujan en gris para teñirlas con el color del componente Image, de modo que un solo botón sirve en rojo, turquesa u oliva. Los corazones, por ejemplo, se dibujan con una fórmula matemática de distancia, píxel por píxel. Los textos usan la fuente Lilita One, de licencia libre OFL (Montoreano, 2011). Los botones crecen y se aclaran al pasar el mouse o al elegirlos con el teclado, se hunden al hacer clic y suenan; esos sonidos de madera también se generan por código. Las ventanas (PanelEmergente) aparecen con un pequeño rebote y se desvanecen con un CanvasGroup.
Figura 76
Piezas gráficas de la interfaz generadas por código

Nota. Elaboración propia. Imágenes de Assets/UI/Estilo generadas con el script GenerarEstiloUI.
Resultado
Un juego de piezas gráficas propias y una interfaz que se ajusta sola a computador, navegador y celular.
Paso 17: construir el menú principal
El objetivo de este paso es que el juego empiece en un menú con el logo y cuatro opciones: Jugar, Configuración, Créditos y Salir (Figura 77).
Procedimiento
- Ejecutar Reliquias → Menú → Construir menú principal.
- Revisar en la jerarquía el
Canvascon el fondo, el logo, el panel de botones y las ventanas de configuración y créditos (Figura 78). - Comprobar que el script
MenuPrincipalconecte cada botón con su acción. - Ejecutar Reliquias → Menú → Actualizar escenas del Build para que el menú sea la primera escena.
Cómo funciona
Figura 77
Menú principal del juego

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Jugar abre la cinemática de introducción; si esa escena todavía no está en la lista de compilación, va directo al Nivel 1, así el juego nunca se rompe a mitad del desarrollo. En Configuración se ajustan el volumen general, la sensibilidad de la cámara y la calidad gráfica (Figura 79). Los valores se guardan con PlayerPrefs, el sistema de Unity que guarda datos pequeños en el equipo del jugador, y el script AjustesJuego los aplica al arrancar el juego. Créditos muestra al equipo y los recursos usados, con un texto que se desplaza solo (Figura 80).
Figura 78
Escena del menú principal en el editor de Unity

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 79
Ventana de configuración: volumen, sensibilidad y calidad

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 80
Ventana de créditos

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Resultado
Un menú principal con configuración guardada y créditos, que es la puerta de entrada al juego.
Paso 18: crear la cinemática de introducción
El objetivo de este paso es contar la historia en unos 60 segundos antes de jugar. El proceso tuvo tres partes: escribir el guion a partir del GDD, dividirlo en ocho escenas y generar una ilustración para cada una.
Procedimiento
- Escribir el guion: el Amuleto Esmeralda, guardado entre las reliquias de Aldoria, da vida a las armaduras, y el ogro se lo roba y se corona rey del castillo.
- Dividir el guion en ocho escenas, cada una con su imagen, su narración y su transición.
- Generar cada ilustración en ChatGPT describiendo a los personajes tal como son los modelos 3D del juego, para que coincidan con lo que el jugador ve después (Figura 81).
- Guardar las imágenes como
Escena1.pngaEscena8.pngenAssets/UI/cinematica. - Ejecutar Reliquias → Menú → Construir cinemática y ajustar cada escena en el Inspector (Figura 85).
Cómo funciona
Figura 81
Las ocho ilustraciones de la cinemática de introducción

Nota. (a) «En el valle de Aldoria, junto a un viejo castillo dormido, vivía en paz el pueblo de los duendes». (b) «En lo más alto del castillo se guardaban las reliquias de Aldoria. La más poderosa era el Amuleto Esmeralda, capaz de dar vida a lo que toca». (c) «Una noche de tormenta llegó un ogro enorme. Robó el amuleto, se puso una corona y se proclamó rey del castillo». (d) «Con el poder del amuleto despertó a las viejas armaduras y las convirtió en sus guardias».
(e) «Para que nadie reclamara la reliquia, las armaduras bajaron al pueblo y se llevaron a los duendecitos bebés». (f) «Los encerraron por todo el castillo: en el jardín, en la mazmorra y en la sala del trono». (g) «El Anciano Duende reunió a los más valientes del pueblo. Eran pequeños… pero saltaban como nadie». (h) Escena del título, con los tres duendes frente a la puerta del castillo. Ilustraciones generadas con ChatGPT (OpenAI, 2026) a partir del guion del equipo; la narración es del guion del juego.
En Unity, la cinemática es una escena con un Canvas. El script Cinematica muestra cada ilustración con un movimiento lento de cámara (efecto Ken Burns: un acercamiento o paneo suave sobre una imagen fija), la cambia con fundidos o con un destello blanco de relámpago en la escena de la tormenta, y escribe la narración letra por letra sobre un pergamino (Figura 82, Figura 83 y Figura 84). Con un clic o con Espacio se completa el texto o se pasa a la siguiente escena, y con Esc se salta toda la cinemática. Al terminar, carga la selección de personaje.
Cinemática de introducción en el juego, con la narración en pergamino
Figura 82

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 83
Transición con destello de relámpago antes de la escena de la tormenta

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 84
Escena de la cinemática: el ogro con el Amuleto Esmeralda

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Cada escena es un elemento de una lista en el Inspector del componente Cinematica (Figura 85). Allí se elige su ilustración, su narración, los segundos mínimos que dura y el tipo de entrada: desde negro, fundido cruzado, a negro y de vuelta, o destello. El movimiento de cámara se define con una escala y un punto de enfoque al inicio y al final, entre los que el script interpola, y un resplandor opcional, por ejemplo el brillo verde del amuleto. Así, los textos y tiempos se pueden cambiar sin tocar el código.
Figura 85
Componente Cinematica en el Inspector, con la lista de escenas

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Resultado
Una introducción de ocho escenas que presenta la historia, los personajes y el objetivo del juego.
Paso 19: construir la selección de personaje
El objetivo de este paso es que el jugador elija entre los tres duendes modelados en la Fase 2: caballero, mago o aventurero (Figura 86).
Procedimiento
- Ejecutar Reliquias → Menú → Construir selección de personaje.
- Revisar la escena: tres pedestales con los modelos y una cámara fija (Figura 87).
- Probar que la elección cambie con las flechas, con el control o haciendo clic sobre un duende.
- Comprobar que, al pulsar ¡A JUGAR!, la elección se guarde en
PlayerPrefsy se cargue el Nivel 1.
Cómo funciona
Como se vio en el Paso 7, los tres duendes comparten esqueleto y animaciones, así que en los niveles solo cambia el modelo visible: el componente de apariencia del jugador lee la elección guardada y activa el modelo que corresponde.
Figura 86
Pantalla de selección de personaje con los tres duendes en 3D

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 87
Escena de selección de personaje en el editor

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Resultado
Una pantalla de selección que usa los modelos 3D reales y guarda la elección del jugador.
Paso 20: agregar el HUD, las misiones y el tutorial
El objetivo de este paso es guiar al jugador sin que tenga que leer un manual: un HUD con el estilo del juego, misiones que dicen qué hacer y un tutorial que enseña los controles mientras se juega.
Procedimiento
- Ejecutar Reliquias → Niveles → Agregar misiones y tutorial a todos los niveles.
- Abrir cada nivel y revisar en el Inspector la lista del componente
Misiones(Figura 89). - Jugar el Nivel 1 y comprobar que cada misión se cumpla al hacer la acción y que el marcador apunte al objetivo (Figura 88).
- Probar la pausa con Esc, P o el botón Start del control, y las pantallas de nivel completado y Game Over.
Cómo funciona
El HUD (HudNivel) muestra arriba a la izquierda los bebés rescatados como cinco caritas, con una marca en los tres necesarios, y las llaves; arriba a la derecha, los corazones, las vidas y el reloj, que se pone rojo en los últimos 30 segundos. Lo importante de su diseño es que solo dibuja: las reglas siguen en el gestor del nivel y en el de salud, que le envían los datos.
En el Nivel 1 las misiones son, en orden: hablar con el Anciano Duende, encontrar una llave, abrir una jaula, rescatar a los bebés necesarios y entrar al castillo. Sobre el objetivo flota el Amuleto Esmeralda como marcador, con la distancia en metros; si el objetivo está fuera de la pantalla, el marcador se queda en el borde con una flecha. Para lograrlo se convierte la posición 3D del objetivo a coordenadas de pantalla con Camera.WorldToScreenPoint. Cada misión tiene un tipo (hablar con el anciano, conseguir una llave, rescatar bebés o llegar a la salida), un texto y una cantidad.
Figura 88
HUD nuevo con la misión actual y el marcador del objetivo

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Componente Misiones en el Inspector del Nivel 1
Figura 89

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
El tutorial es progresivo: enseña una sola cosa a la vez con una tarjeta abajo al centro (Figura 90). Primero los controles (moverse, mover la cámara, saltar y doble salto), y cada tarjeta se va sola cuando el jugador hace la acción. Muestra la tecla, el botón del control o el control táctil según lo último que se haya usado. Después aparecen pistas la primera vez que el duende se acerca a algo nuevo, como una llave, una jaula, un trampolín, una armadura, el agua o un estandarte.
Figura 90
Tutorial progresivo con la tarjeta de controles

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
También se agregaron la pausa, con opciones para continuar, reiniciar el nivel o volver al menú (Figura 91), y las pantallas de nivel completado (Figura 92) y Game Over (Figura 93). Para pausar, el tiempo del juego se detiene con Time.timeScale = 0.
Figura 91
Menú de pausa

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Figura 92
Pantalla de nivel completado

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Pantalla de Game Over
Figura 93

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Resultado
Un jugador nuevo sabe qué hacer y cómo hacerlo desde el primer minuto, sin salir del juego.
Paso 21: mejorar la sensación de juego
El objetivo de este paso es que cada acción se sienta. Se agregó un sistema de efectos (Efectos) basado en la idea de game feel: un golpe se nota de verdad cuando varias respuestas cortas llegan juntas, en menos de una décima de segundo (grapefrukt, 2012; Swink, 2009).
Procedimiento
- Ejecutar Reliquias → Efectos → Crear materiales de partículas, que guarda los materiales en
Resources. - Llamar al sistema
Efectosdesde cada acción: saltar, aterrizar, aplastar una armadura, recoger una llave, rescatar a un bebé o golpear al ogro. - Combinar en las acciones importantes varias respuestas de la Tabla 13, y dejar solo un poco de polvo en las acciones de todo el tiempo.
- Jugar y ajustar la intensidad de cada efecto hasta que se note sin cansar.
Cómo funciona
Tabla 13
Respuestas combinadas para la sensación de juego
| Respuesta | Para qué sirve | Ejemplo en el juego |
|---|---|---|
| Partículas | Muestran dónde pasó algo | Polvo al saltar y aterrizar, chispas al aplastar una armadura, destellos en llaves y bebés |
| Congelar el tiempo un instante (hit-stop) | Le da peso al golpe | Al aplastar una armadura |
| Temblor de cámara | Le da fuerza | Aterrizajes del ogro y golpes de la lámpara |
| Destello de pantalla | Avisa que pasó algo importante | Destello rojo al recibir daño |
| Sonido | Lo confirma | Cada efecto lleva su sonido |
Nota. Elaboración propia.
Las partículas usan el Particle System de Unity, y el sistema de efectos se crea solo la primera vez que se usa (Figura 94).
Figura 94
Efecto de partículas del doble salto

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Resultado
Acciones con respuesta inmediata y proporcional a su importancia.
Fase 7: pruebas y publicación
Paso 22: pulir el juego, la versión web y los controles táctiles
El objetivo de este paso es corregir los errores que solo aparecen en el juego compilado y llevarlo al navegador y al celular.
Procedimiento
- Compilar el juego y jugarlo completo fuera del editor, anotando cada error.
- Corregir los errores encontrados y volver a compilar hasta que no aparezcan nuevos.
- Ajustar la versión web: pausa con la tecla P y shader de vegetación compatible con WebGL2.
- Agregar el script
ControlesTactiles, que solo aparece en Android y en el navegador del celular (Figura 95). - Probar los controles táctiles en un celular real.
Cómo funciona
Al probar el juego compilado se encontraron y corrigieron varios errores. Los botones de pausa no respondían porque al Canvas del HUD le faltaba el componente GraphicRaycaster, que es el que detecta los clics. En las plataformas móviles el duende salía empujado, porque medía su velocidad con la del CharacterController, que incluía el arrastre de la plataforma; ahora mide solo su propio movimiento y conserva el impulso al saltar desde ella. Las armaduras parecían flotar, porque el NavMesh queda unos centímetros sobre el piso, así que ahora se ajustan al suelo real con un rayo. Además, el script ControlCursor esconde y bloquea el mouse mientras se juega y lo deja visible, pero encerrado en la ventana, cuando hay un menú abierto.
En el navegador, la tecla Esc libera el mouse, por eso la pausa también funciona con P. Los controles táctiles son un joystick flotante en la mitad izquierda, que aparece donde se apoya el pulgar; la mitad derecha, donde arrastrar el dedo gira la cámara; un botón para saltar, en el que dos toques en el aire hacen el doble salto; y un botón de pausa. Los controles escriben directamente en el mismo componente de entrada que usa el teclado, así que el controlador del duende no tuvo que cambiar.
Controles táctiles en pantalla para celulares
Figura 95

Nota. Captura de pantalla del juego en ejecución en Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Resultado
Un juego sin los errores encontrados en las pruebas, que se puede jugar con teclado, control o pantalla táctil.
Paso 23: unir los niveles y compilar para cada plataforma
El objetivo de este paso es entregar el juego completo: los tres niveles unidos en una sola rama y compilados para Windows, navegador web y Android.
Procedimiento
- Unir en GitHub las ramas de los tres integrantes en una sola y resolver los conflictos de las escenas.
- Ejecutar Reliquias → Menú → Actualizar escenas del Build para dejar las escenas en el orden de juego: menú principal, cinemática, selección de personaje, Nivel 1, Nivel 2 y Nivel 3.
- Abrir File → Build Profiles, elegir la plataforma (Windows, Web o Android) y pulsar Switch Platform (Figura 96).
- Pulsar Build y elegir la carpeta de salida; para Android se genera un archivo APK que se instala en el celular.
- Jugar cada versión compilada de principio a fin.
Cómo funciona
Cada nivel se probó varias veces y se ajustó según lo que se encontraba: llaves que faltaban, enemigos imposibles de esquivar, saltos que se podían evitar o puertas que no abrían. El cambio de nivel se hace por código con SceneManager.LoadScene, usando el nombre de la escena siguiente que guarda el gestor de cada nivel.
Figura 96
Ventana Build Profiles para elegir la plataforma de compilación

Nota. Captura de pantalla del editor de Unity 6 (Unity Technologies, 2026d). Elaboración propia.
Resultado
El juego completo, de tres niveles enlazados, compilado para Windows, navegador web y Android.
Resultados del videojuego 3D en Unity
Como resultado se obtuvo un juego completo de tres niveles que se juegan en orden: al terminar el jardín se carga la mazmorra, y al bajar su escalera secreta se llega al torreón y a la pelea final. La Tabla 14 resume lo logrado frente a lo planeado en el GDD.
Tabla 14
Resumen de resultados
| Aspecto | Resultado |
|---|---|
| Niveles | Tres niveles completos y enlazados, con estilo low poly coherente y ambientación propia (día, mazmorra y noche) |
| Mecánicas | Salto doble, llaves, jaulas, cinco bebés por nivel, puntos de control, salud, vidas, tiempo y Game Over |
| Personajes | Tres duendes jugables, dos armaduras, el anciano, los bebés y el Ogro, diseñados con ChatGPT, modelados con Meshy, retocados en Blender y animados en Unity |
| Enemigos | Dos tipos de armadura con máquina de estados y NavMesh, y un jefe final con cinemáticas |
| Trampas | Pinchos, hachas, losas, troncos rodantes, plataformas móviles, trampolines y agua |
| Audio | Música por nivel, ambiente, más de 40 efectos y sonidos 3D, todos con licencia CC0 |
| Experiencia del jugador | Menú principal con configuración y créditos, cinemática de introducción, selección de personaje, misiones, tutorial, pausa y pantallas de fin |
| Plataformas | Windows, navegador web (WebGL) y Android con controles táctiles |
| Verificación | Recorrido del Nivel 3 comprobado por código y pruebas de cada versión compilada |
Nota. Elaboración propia.
Conclusiones
Desarrollar un videojuego 3D en Unity de principio a fin, con un equipo de tres personas, dejó varias lecciones.
Construir los niveles con scripts de editor, en lugar de armarlos a mano, fue la decisión más útil del proyecto. Permitió rehacer un nivel completo en segundos después de cada prueba, mantener el mismo estilo en los tres niveles y, al final, reconstruirlos por etapas para documentar el proceso.
Personajes creados con inteligencia artificial
El flujo de ChatGPT, Meshy, Blender y Unity permitió que un equipo sin modeladores tuviera personajes propios y coherentes entre sí. La clave fue preparar bien la imagen de referencia, en pose T y sobre fondo blanco, y exportar con un esqueleto humanoide, porque así todos los personajes pudieron compartir las mismas animaciones. Aun así, las texturas generadas necesitaron retoques a mano, y cada imagen generada con inteligencia artificial se citó como tal.
Pruebas de juego y trabajo en equipo
Grabar las sesiones de trabajo resultó valioso para este artículo: muestran cómo el Nivel 1 pasó de una maqueta de bloques grises a un jardín con texturas, agua y castillo en una sola noche, algo que las capturas finales no pueden mostrar. Las pruebas de juego también cambiaron mucho el diseño: la primera versión de la mazmorra se terminaba muy rápido y los enemigos eran casi imposibles de esquivar, y ampliar el nivel, diferenciar las armaduras por color y ubicar bien los puntos de control dejaron una dificultad más justa.
Trabajar en ramas separadas en GitHub permitió que cada integrante avanzara en su nivel sin dañar el de los demás, aunque unir escenas de Unity exige cuidado. Por último, el sonido, las cinemáticas y la sensación de juego, aunque se agregaron al final, cambiaron por completo la experiencia, sobre todo en la pelea contra el Ogro.
Un agradecimiento especial al profesor Carlos Iván Pinzón Romero y a la Universidad Central por el acompañamiento durante el desarrollo de este videojuego.
Créditos:
Autores: Juan David Cadena Zambrano, Steven Alejandro Beltrán López y Dilan Villota
Editor: Carlos Iván Pinzón Romero
Código: UCMV-10
Universidad: Universidad Central
Fuentes
American Psychological Association. (2020). Publication manual of the American Psychological Association (7.ª ed.). https://doi.org/10.1037/0000165-000
Anthropic. (2026). Claude Code (modelo Claude Opus 5.5) [Asistente de programación con inteligencia artificial]. https://claude.com/claude-code
artisticdude. (s. f.). Swishes sound pack [Efectos de sonido]. OpenGameArt. https://opengameart.org/content/swishes-sound-pack
Blender Foundation. (2026). Blender [Software de computador]. https://www.blender.org/download/
CleytonKauffman. (s. f.). Boss battle theme [Música]. OpenGameArt. https://opengameart.org/content/boss-battle-theme
Creative Commons. (s. f.). CC0 1.0 Universal: Dedicación de dominio público. https://creativecommons.org/publicdomain/zero/1.0/deed.es
Darsycho. (s. f.). Big scary troll sounds [Efectos de sonido]. OpenGameArt. https://opengameart.org/content/big-scary-troll-sounds
DinV Studio. (s. f.). Poly Low Trees Pack FREE [Recurso 3D]. Unity Asset Store. https://assetstore.unity.com/packages/3d/vegetation/trees/poly-low-trees-pack-free-204089
FFmpeg Developers. (2026). FFmpeg (versión 9.0) [Software de computador]. https://ffmpeg.org/
Gigel3d. (s. f.). RPG Poly Pack - Lite [Recurso 3D]. Unity Asset Store. https://assetstore.unity.com/packages/package/148410
GitHub. (s. f.). Documentación de GitHub. Recuperado el 18 de noviembre de 2026, de https://docs.github.com/es
grapefrukt. (2012, 24 de mayo). Juice it or lose it - a talk by Martin Jonasson & Petri Purho [Video]. YouTube. https://www.youtube.com/watch?v=Fy0aCDmgnxg
IgnasD. (s. f.). Wind [Efecto de sonido]. OpenGameArt. https://opengameart.org/content/wind
JaggedStone. (s. f.). Loopable dungeon ambience [Ambiente sonoro]. OpenGameArt. https://opengameart.org/content/loopable-dungeon-ambience
JustCreate. (s. f.). Low-Poly Simple Nature Pack [Recurso 3D]. Unity Asset Store. https://assetstore.unity.com/packages/3d/environments/landscapes/low-poly-simple-nature-pack-162153
Kenney. (s. f.-a). 50 RPG sound effects [Efectos de sonido]. OpenGameArt. https://opengameart.org/content/50-rpg-sound-effects
Kenney. (s. f.-b). 85 short music jingles [Música]. OpenGameArt. https://opengameart.org/content/85-short-music-jingles
Kenney. (s. f.-c). Interface sounds [Efectos de sonido]. OpenGameArt. https://opengameart.org/content/interface-sounds
Level13. (s. f.). Low Poly Interior Flower Pots [Recurso 3D]. Unity Asset Store. https://assetstore.unity.com/packages/3d/vegetation/flowers/low-poly-interior-flower-pots-386694
Meshy. (s. f.). Meshy: Generador de modelos 3D con IA [Aplicación web]. https://www.meshy.ai/
Montoreano, J. (2011). Lilita One [Fuente tipográfica]. Google Fonts. https://fonts.google.com/specimen/Lilita+One
Nicrom. (2026). Low Poly Wind (versión 1.4.0) [Recurso de software]. Unity Asset Store. https://assetstore.unity.com/packages/vfx/shaders/low-poly-wind-182586
OpenAI. (2026). ChatGPT [Modelo de lenguaje y generación de imágenes]. https://chatgpt.com/
RandomMind. (s. f.-a). Fantasy: Lament for a warrior's soul [Música]. OpenGameArt. https://opengameart.org/content/fantasy-lament-for-a-warriors-soul
RandomMind. (s. f.-b). Medieval: Minstrel dance [Música]. OpenGameArt. https://opengameart.org/content/medieval-minstrel-dance
RCstudio3D. (2025). 3D Low Poly Forest Pack FREE [Recurso 3D]. Unity Asset Store. https://assetstore.unity.com/packages/3d/environments/3d-low-poly-forest-pack-free-336748
rubberduck. (s. f.-a). 40 CC0 water / splash / slime SFX [Efectos de sonido]. OpenGameArt. https://opengameart.org/content/40-cc0-water-splash-slime-sfx
rubberduck. (s. f.-b). 75 CC0 breaking / falling / hit SFX [Efectos de sonido]. OpenGameArt. https://opengameart.org/content/75-cc0-breaking-falling-hit-sfx
rubberduck. (s. f.-c). 80 CC0 creature SFX [Efectos de sonido]. OpenGameArt. https://opengameart.org/content/80-cc0-creature-sfx
rubberduck. (s. f.-d). 80 CC0 RPG SFX [Efectos de sonido]. OpenGameArt. https://opengameart.org/content/80-cc0-rpg-sfx
Swink, S. (2009). Game feel: A game designer's guide to virtual sensation. Morgan Kaufmann.
The PolynestLab. (2026). FREE Low Poly Plants & Pots Demo with Growth System / Cosmic Retro [Recurso 3D]. Unity Asset Store. https://assetstore.unity.com/packages/3d/vegetation/plants/free-low-poly-plants-pots-demo-with-growth-system-cosmic-retro-406664
TinyWorlds. (s. f.). Forest ambience [Ambiente sonoro]. OpenGameArt. https://opengameart.org/content/forest-ambience
Unity Technologies. (s. f.). Starter Assets – ThirdPerson [Recurso de software]. Unity Asset Store. https://assetstore.unity.com/packages/essentials/starter-assets-thirdperson-updates-in-new-charactercontroller-pa-196526
Unity Technologies. (2026a). AI Navigation. Unity Documentation. Recuperado el 18 de noviembre de 2026, de https://docs.unity3d.com/Packages/com.unity.ai.navigation@latest
Unity Technologies. (2026b). Cinemachine. Unity Documentation. Recuperado el 18 de noviembre de 2026, de https://docs.unity3d.com/Packages/com.unity.cinemachine@latest
Unity Technologies. (2026c). Input System. Unity Documentation. Recuperado el 18 de noviembre de 2026, de https://docs.unity3d.com/Packages/com.unity.inputsystem@latest
Unity Technologies. (2026d). Unity (versión 6000.6.3f1) [Software de computador]. https://unity.com/download
Unity Technologies. (2026e). Universal Render Pipeline. Unity Documentation. Recuperado el 18 de noviembre de 2026, de https://docs.unity3d.com/Manual/urp/urp-introduction.html
yd. (s. f.). Dungeon ambience [Música]. OpenGameArt. https://opengameart.org/content/dungeon-ambience
