Creación de videojuegos para la gamificación de una asignatura

Escuela de Ingenier´ıa Informa ´ tica T RABAJO F IN DE G RADO Grado en Ingenier´ıa Informa ´ tica Creacio ´ n de videojuegos para la gamificacio ´ n de una asignatura Autor: D. Javier Guti´errez Rodr´ıguez Tutores: Dr. Carlos Enrique Vivaracho Pascual D. Alma Pisabarro Marro´n 2 3 Resumen Este Trabajo de Fin de Grado consiste en el desarrollo de dos videojuegos para la gamificaci´on de la asignatura Fundamentos de Programaci´on. Forma parte de un proyecto de investigaci´on que recoger´a datos para comprobar el impacto en los estudiantes. Estos videojuegos estan asociados a conceptos sobre los tipos de datos y la recursividad, ayudando al aprendizaje de ambos. 4 5 Tabla de Contenidos 1. Introduccio´n 11 1.1. Motivaci´on .............................................................................................................................................. 11 1.2. Objetivos ......................................................................................................................................... 12 1.3. Contenido de la Memoria ............................................................................................................... 12 2. Contexto 13 2.1. Concpetos Relacionados con el Desarrollo de Videojuegos ................................................................ 14 2.1.1. Documento de Disen˜o del Juego ........................................................................................ 14 2.1.2. Pruebas Beta .................................................................................................................. 15 3. Herramientas Utilizadas 17 3.1. Unity ....................................................................................................................................................... 17 3.1.1. Scripting con UnityEngine ................................................................................................. 18 4. Plan de Proyecto 23 4.1. Metodolog´ıa ............................................................................................................................................ 23 4.1.1. Descripci´on ................................................................................................................................ 23 4.1.2. Fases ................................................................................................................................................. 24 4.1.3. Ventajas ..................................................................................................................................... 24 4.1.4. Inconvenientes ................................................................................................................................. 25 4.2. Plan de gesti´on de riesgos .............................................................................................................. 25 4.3. Plan de trabajo .......................................................................................................................... 28 4.3.1. Seguimiento ............................................................................................................................... 30 4.4. Costes ..................................................................................................................................................... 34 5. Minijuego 1: Tipos de Datos 35 5.1. GDD ....................................................................................................................................................... 35 5.1.1. Introducci´on ........................................................................................................................ 35 5.1.2. Audiencia y Plataforma ...................................................................................................... 36 5.1.3. Meca´nicas ............................................................................................................................ 36 5.1.4. Niveles ....................................................................................................................................... 37 5.1.5. Multimedia .......................................................................................................................... 39 5.1.6. Versiones .......................................................................................................................................... 40 5.2. An´alisis ................................................................................................................................................... 40 5.2.1. An´alisis de requisitos ......................................................................................................... 40 5.2.2. Casos de uso ....................................................................................................................... 41 5.3. Disen˜o .............................................................................................................................................. 43 5.4. Pruebas ............................................................................................................................................ 44 6 5.4.1. Pruebas Unitarias .......................................................................................................... 44 5.4.2. Pruebas Beta .................................................................................................................. 46 6. Minijuego 2: Recursividad 47 6.1. GDD ....................................................................................................................................................... 47 6.1.1. Introducci´on .........................................................................................................................47 6.1.2. Audiencia y Plataforma .......................................................................................................48 6.1.3. Meca´nicas .............................................................................................................................48 6.1.4. Niveles ....................................................................................................................................... 49 6.1.5. Multimedia ...........................................................................................................................51 6.1.6. Versiones ......................................................................................................................................... 51 6.2. An´alisis ................................................................................................................................................... 52 6.2.1. An´alisis de requisitos ..........................................................................................................52 6.2.2. Casos de uso ........................................................................................................................53 6.3. Disen˜o ...............................................................................................................................................55 6.4. Pruebas .............................................................................................................................................56 6.4.1. Pruebas Unitarias .......................................................................................................... 56 7. Conclusiones 59 7.1. Conclusiones ........................................................................................................................................... 59 7.2. Trabajo futuro ........................................................................................................................... 59 7 Lista de Figuras 3.1. Diagrama estructura de juego en Unity ......................................................................................... 19 3.2. Flujo de ejecucio´n de funciones en Unity ....................................................................................... 20 4.1. Desarrollo en cascada ...................................................................................................................... 23 5.1. Captura de pantalla: Tipos de Datos ......................................................................................... 35 5.2. Boceto: Tipos de Datos ................................................................................................................... 37 5.3. Diagrama de casos de uso menu´ principal: Tipos de datos .......................................................... 42 5.4. Diagrama de casos de uso nivel: Tipos de datos ........................................................................... 43 5.5. Modelo de dominio: Tipos de datos ............................................................................................... 43 5.6. Patr´on Fachada .......................................................................................................................... 44 6.1. Captura de pantalla: Recursividad ................................................................................................. 47 6.2. Iconos: Recursividad ....................................................................................................................... 49 6.3. Diagrama de casos de uso menu´ principal: Recursividad ............................................................. 54 6.4. Diagrama de casos de uso nivel: Recursividad .............................................................................. 54 6.5. Modelo de dominio: Tipos de datos ............................................................................................... 55 6.6. Patr´on Observador .......................................................................................................................... 56 8 9 Lista de Tablas 4.1. Riesgo 1 .................................................................................................................................................. 25 4.2. Riesgo 2 .................................................................................................................................................. 26 4.3. Riesgo 3 .................................................................................................................................................. 26 4.4. Riesgo 4 .................................................................................................................................................. 26 4.5. Riesgo 5 .................................................................................................................................................. 26 4.6. Riesgo 6 .................................................................................................................................................. 27 4.7. Riesgo 7 .................................................................................................................................................. 27 4.8. Riesgo 8 .................................................................................................................................................. 27 4.9. Planificacio´n de la fase inicial ........................................................................................................ 28 4.10. Planificacio´n de la fase de analisis del primer juego ..................................................................... 28 4.11. Planificacio´n de la fase de disen˜o del primer juego ....................................................................... 28 4.12. Planificacio´n de la implementacio´n del primer juego .................................................................... 29 4.13. Planificacio´n de las pruebas del primer juego ............................................................................... 29 4.14. Planificacio´n de la fase de analisis del segundo juego .................................................................. 29 4.15. Planificacio´n de la fase de disen˜o del segundo juego .................................................................... 29 4.16. Planificacio´n de la implementacio´n del segundo juego .................................................................. 30 4.17. Planificacio´n de las pruebas del segundo juego ............................................................................. 30 4.18. Seguimiento de la fase inicial ........................................................................................................ 31 4.19. Seguimiento de la fase de analisis del primer juego ..................................................................... 31 4.20. Seguimiento de la fase de disen˜o del primer juego ....................................................................... 31 4.21. Seguimiento de la fase de implementaci´on del primer juego ....................................................... 32 4.22. Seguimiento de la fase de pruebas del primer juego ..................................................................... 32 4.23. Seguimiento de la fase de analisis del segundo juego ................................................................... 33 4.24. Seguimiento de la fase de disen˜o del segundo juego .................................................................... 33 4.25. Seguimiento de la fase de implementaci´on del segundo juego ..................................................... 33 4.26. Seguimiento de la fase de pruebas del segundo juego .................................................................. 34 5.1. RF-01: Carga del menu´ principal ................................................................................................... 40 5.2. RF-02: Iniciar nivel .............................................................................................................................. 40 5.3. RF-03: Salir del nivel ........................................................................................................................... 40 5.4. RF-04: Mostrar ayuda al iniciar nivel ................................................................................................. 40 5.5. RF-05: Generar pieza de datos ...................................................................................................... 40 5.6. RF-06: Mover pieza de datos ......................................................................................................... 41 5.7. RF-07: Puntuacio´n del jugador ....................................................................................................... 41 5.8. RF-08: Tutorial de inicio ................................................................................................................ 41 5.9. RF-09: Cerrar el juego ................................................................................................................... 41 5.10. RNF-01: Motor de desarrollo ......................................................................................................... 41 16 17 Cap´ıtulo 3 Herramientas Utilizadas 3.1. Unity En el mundo actual los videojuegos han aumentado su presencia en nuestras vidas para convertirse en una parte importante en la vida de muchas personas. Todo esto tambien se ha visto reflejado en un mayor inter´es en su creaci´on. Por ello, han cobrado una gran importancia los motores de desarrollo de videojuegos que consisten en un entorno de herramientas que nos permiten desarrollar los principales componentes de un juego tales como renderizado, animacio´n, modelado, sonido y otros aspectos. Uno de los requisitos de este proyecto era usar Unity, una de las plataformas de desarrollo ma´s populares hoy en d´ıa y que acoge uno de los ecosistemas de desarrolladores mas amplios en la industria. Ofrecen una amplia gama de alternativas para todo tipo de usuarios, desde un uso educativo hasta profesional. En nuestro caso, la plataforma principal del proyecto se desarrollo´ en Unity, por lo tanto, es necesario usarlo para integrar de manera adecuada los videojuegos. La idea de Unity nace en 2004 de la mano de Unity Technologies con un objetivo claro: democratizar el desarrollo de videojuegos. Comienzan la creacio´n de un motor de videojuegos que pequen˜as y grandes empresas puedan utilizar por igual. Un entorno amigable donde puedan trabajar programadores, artistas y disen˜adores sin tener que crear herramientas especificas para cada apartado. Desde entonces no ha parado de crecer hasta convertirse en uno de los motores multiplataforma ma´s potentes y utilizados del mercado. Una de las caracter´ısticas ma´s importantes de Unity [8] es que se trata de un motor multiplataforma. Esto quiere decir que con una sola herramienta podemos desarrollar videojuegos para las principales plataformas del mercado realizando solo ciertos ajustes y no tener que crearlo desde cero con otra herramienta. Entre estas plataformas figuran ordenadores, consolas, mo´viles y plataformas de realidad virtual, es decir con una sola plataforma tenemos la posibilidad de desarrollar para varias plataformas sin un aumento de costes y con la posibilidad de alcanzar un mayor pu´blico. Actualmente Unity es usado por miles de compan˜´ıas para producir sus juegos desde estudios independientes hasta grandes compan˜´ıas. Algunos de los juegos con ma´s repercusio´n creados con esta plataforma son: Hollow Knight, Fall Guys: Ultimate Knockout, League Of Legends: Wild Rift o Outer Wilds. Desde Unity Technologies tambien han intentado dar el salto a otros sectores fuera de los videojuegos como son el cine y la animaci´on, uno de los m´as importantes se trata de una colaboraci´on con Disney Television Animation para crear tres cortos dentro de un proyecto llamado Baymax Dreams. Adem´as de todo lo expuesto, tambien podemos destacar estas otras caracter´ısticas [7]: 18 Documentaci´on: el entorno de desarrollo Unity dispone de una excelente documentacio´n, una de las mejores que existe en motores de desarrollo de videojuegos. En el manual de Unity, se pueden consultar todos y cada uno de sus distintos apartados, ya sea sobre como actualizar a una versi´on concreta o incluso gu´ıas profesionales para realizar tareas de un nivel muy avanzado. Tambien es posible encontrar un historial de las versiones anteriores de la documentaci´on. De manera que podemos consultar cualquier versio´n sin necesidad de estar cerrados a la u´ltima versio´n de Unity. Comunidad: como hemos explicado antes Unity es una de las platformas ma´s populares y gracias a esto posee una gran comunidad por lo que la cantidad de recursos a nuestra disposici´on es muy abundante. Cualquier tipo de duda que nos pueda surgir encontraremos respuesta con mucha facilidad, acceso a tutoriales explicando diversas tecnicas, la posibilidad de ver proyectos de otras personas. Podemos encontrar todo esto directamente en los foros de Unity o buscando diversas fuentes por internet. Unity Asset Store: desde Unity han creado una de las mayores tiendas de recursos para videojuegos que podemos encontrar en internet. En ella podemos encontrar todo tipo de recuros desde modelos, texturas, efectos, ampliaciones del editor, servicios y mucho ma´s. Aparte exite una gran cantidad de contenido gratuito que puedo ayudar a pequen˜os proyectos. Tambien sirve para que creadores de recursos pueden tener un mercado a su disposicio´n en el que vender su trabaja a otras desarrolladores. Herramientas profesionales: incluso con las versiones gratuitas de Unity tenemos acceso a las mismas herramientas que un desarrollador profesional, esto nos permite crear videojuegos con una gran calidad gr´afica y contenido sin necesiad de hacer un gran desembolso. Facilidad de uso: una de las caracter´ısticas ma´s llamativas de Unity es su facilidad de uso incluso si no estas acostumbrado a este tipo de motores de desarrollo. Posee una interfaz muy simple e intuitiva que nos permite visualizar los cambios en tiempo real, muchas acciones pueden realizarse desde interfaces sin necesidad de saber programar. Puedes centrarte en las partes que ma´s te interesen sin requerir un conocimiento completo de todo el sistema. 3.1.1. Scripting con UnityEngine A la hora de desarrollar juego en Unity, una de las maneras fundamentales de trabajar es mediante el uso de scripts. Los componentes integrados de Unity son muy vers´atiles, pero para poder llegar m´as all´a e implementar las caracter´ısticas propias de tu juego se necesita realizar scripts. Unity soporta dos lenguajes nativamente: C#, un lenguaje esta´ndar de la industria similar a Java o C++ y UnityScript, un lenguaje disen˜ado especificamente para uso con Unity y modelado tras JavaScript. Para el desarrollo de estos scripts Unity ofrece una librer´ıa llamada UnityEngine, que sera´ fundamental para poder manejar los elementos del juego. En la figura 3.1 se muestra la estructura ba´sica de un juego en Unity. 19 Figura 3.1: Diagrama estructura de juego en Unity El elemento principal que compone un juego en Unity son las escenas. Las escenas sirven de contenedor donde trabajar con todo el contenido del juego, pueden contener todo el juego o una parte. Por ejemplo, si se esta construyendo un juego simple se puede usar una sola escena, pero en un juego m´as complejo puede ser necesario usar varias escenas, cada una con un decorado, personajes, obsta´culos, e interfaz. De esta manera, se puede estructurar el juego de una manera sencilla y separar las distintas partes. A partir de este punto todos los elementos que se an˜adan a la escena seran GameObject, que es el elemento m´as importante de UnityEngine. Cada objeto de un juego es un GameObject, desde personajes, hasta luces, c´amaras y efectos especiales. Por si mismos no son capaces de realizar ninguna acci´on, pero actu´an como contenedores de los componentes que son los encargados de implementar las distintas funcionalidades. Estos componentes son la clase base que nos permite modificar el comportamiento de los GameObject. Para poder conseguir la funcionalidad deseada se debe an˜adir distintas combinaciones de componentes. Unity incluye una gran cantidad de componentes por defecto pero es posible crear componentes propios si fuese necesario. Uno de los componentes m´as importantes es el componente Transform que siempre esta presente en los GameObject y no puede ser eliminado. Este componente se encarga de definir la posicion, rotacio´n y escala del GameObject dentro de la escena. Existen muchos tipos de componentes en Unity, algunos de los ma´s importantes son los Renders que se encargan de renderizar las distintas imagenes y texturas en el mundo tanto 2D como 3D. Tambien existen componentes que nos permiten aplicar fisicas y colisiones a nuestros GameObject, algunos de los m´as usados son RigidBody y Collider. 20 Una vez creados todos estos elementos vamos a necesitar definir su comportamiento, aqu´ı es donde entran en juego los scripts, que son la parte programable de Unity. Cualquier juego por muy simple que sea har´a uso de scripts para para poder crear las mec´anicas del juego. Desde los controles, pasando por efectos gra´ficos, f´ısicas y cualquier cosa que necesite un juego debera´ ser configurada con ayuda de scripts. Los scripts tambien son componentes que implementan la clase MonoBehaviour y eso les permite ser an˜adidos a un GameObject. Figura 3.2: Flujo de ejecucio´n de funciones en Unity 21 Estos script pueden ser ejecutados por eventos realizados por el jugador pero tambien existen funciones predeterminadas de Unity que los ejecutan. En la figura 3.2 se puede observar el flujo de ejecucion, las llamadas que se realizan con sus condiciones de entrada y salida. Algunas de las funciones m´as importantes son: Start: se llama en la primera actualizaci´on de frame si el script esta activo. Update: se llama una vez por frame y es la funcio´n principal. OnDestroy: se llama despues de todas las actulizaciones de frame para el u´ltimo frame de existencia del objeto. 22 23 Cap´ıtulo 4 Plan de Proyecto 4.1. Metodolog´ıa 4.1.1. Descripci´on Para el desarrollo de este proyecto se ha decidido utilizar un desarrollo en cascada [1] (figura 4.1) como marco de trabajo. El modelo en cascada es un proceso de desarrollo secuencial, en el que el software se concibe como un conjunto de etapas que se ejecutan una tras otra. Al contrario que en los modelos iterativos, cada una de estas etapas solo se ejecuta una vez. Los resultados de cada etapa sirven como punto de partida para la siguiente. Figura 4.1: Desarrollo en cascada 24 4.1.2. Fases Existen muchas variantes del modelo pero los m´as habituales son aquellos que dividen el proceso de desarrollo en cinco fases. Para este proyecto se han incluido ampliaciones de la metodolog´ıa en cascada an˜adidiendo funciones iterativas al modelo ba´sico, de esta manera se puede realizar saltos de etapa hacia atra´s. Esto nos permite comprobar si los resultados obtenidos coinciden con lo planteado en la etapa anterior y en caso negativo repetir la etapa para alcanzar el resultado deseado. Se trata de un modelo lineal, por lo que las diferentes fases se ejecutan una tras como en una cascada. Al finalizar cada una de las fases se obtiene un resultado provisional o hito como, por ejemplo, un acuerdo en el alcance del proyecto o una aplicaci´on prototipo. An´alisis En esta fase se hace un ana´lisis de las necesidades de los usuarios finales para determinar que objetivos debe cubrir sin entrar en detalles t´ecnicos. Por lo tanto, esta es la etapa en la que se recogen la mayor´ıa de los requisitos del software y se identifica el alcance del proyecto, los posibles riesgos que pueden surgir y estimaciones de costes, esfuerzo y tiempo. Disen˜o En esta fase se describe la estructura interna del software y las relacciones entre la entidades que lo componen. Se descompone y organiza el sistema en elementos que puedan elaborarse por separado, de esta manera se obtiene una descripcio´n sobre lo que debe hacer cada una de sus partes y de que manera funcionan en conjunto. Implementaci´on En esta fase se procede a programar los requisitos especificados haciendo uso de la estructura definida en la fase anterior. Se hacen uso de prototipos as´ı como de pruebas y ensayos para corregir errores. Verificaci´on En esta fase se verifica que todos los componentes del sistema funcionan de manera correcta y que cumplen con los requisitos planteados. El objetivo de esta fase es conocer la calidad del software mediante la realizacio´n de pruebas. Esto nos permite encontrar defectos, refinar el c´odigo y aumentar la calidad. Mantenimiento En esta fase se instala la aplicacio´n en el sistema y se comprueba que funciona bien dentro del entorno en el que se va a usar. 4.1.3. Ventajas Se obtiene un proyecto estructurado con unas fases de desarrollo claras y bien definidas 25 La documentacio´n del proceso de desarrollo es buena a traves de objetivos definidos. Los costes y la carga de trabajo se puede estimar al comenzar el proyecto. Los proyecto se pueden representar cronolo´gicamente de forma sencilla. 4.1.4. Inconvenientes El usuario final no participa en el proceso de desarrollo hasta que no finaliza la implementacio´n. Poco margen para realizar ajustes si ocurre un cambion en los requisitos. Los posibles fallos solo se detectan una vez finalizado el proceso de desarrollo. Los proyectos complejos no se pueden dividir correctamente en fases claras y bien definifas. 4.2. Plan de gestio´n de riesgos En esta seccio´n se van a especificar los riesgos que deben tenerse en cuenta para llevar a cabo el desarrollo de proyecto. Es necesario identificarlos ya que pueden ser un incoveniente en el correcto desarrollo del proyecto. Para ello, en el proceso de an´alisis de los riesgos se debe obtener el grado de exposici´on al riesgo. Esto se puede obtener teniendo en cuenta su probabilidad de ocurrir y el impacto que podr´ıan causar. En las figuras 4.1 a 4.8 se muestran los riesgos detectados, su probabilidad e impacto, as´ı como los planes de contingencia previstos para cada uno. Riesgo 1 Enfermedad o situaciones excepcionales Probabilidad: Media Impacto: Medio Proteccio´n ante el riesgo: Mantener un estado de salud correcto. Plan de contingencia: Seguir las recomendaciones adecuadas a la situacio´n. Una enfermedad nos impide realizar el trabajo de manera habitual Tabla 4.1: Riesgo 1 32 La fase de implementaci´on apenas se desv´ıa de los tiempos previstos y solo algunas tareas como la conexio´n con la plataforma web llevan algo ma´s de tiempo del esperado por problemas ajenos al proyecto (tabla 4.21). Tarea Horas estimadas Horas reales Inicio estimado Fin estimado Inicio real Fin real TOTAL 48 52 5/4/2020 20/4/2020 5/7/2020 20/7/2020 Inicio 0 0 5/4/2020 5/4/2020 5/7/2020 5/7/2020 Configuracio´n de Unity 2 2 5/4/2020 6/4/2020 5/7/2020 6/7/2020 Obetencio´n y creacio´n de sprites 8 12 5/4/2020 10/4/2020 5/7/2020 10/7/2020 Implementacio´n de las funcionalidades 25 25 5/4/2020 15/4/2020 5/7/2020 15/7/2020 Implementacio´n de la interfaz de usuario 10 8 12/4/2020 17/4/2020 12/7/2020 17/7/2020 Implementacio´n de la conexio´n con la plataforma web 3 5 15/4/2020 20/4/2020 15/7/2020 20/7/2020 Fin 0 0 20/4/2020 20/4/2020 20/7/2020 20/7/2020 Tabla 4.21: Seguimiento de la fase de implementacio´n del primer juego Las pruebas del primer juego tambien han ido de acuerdo con las estimaciones iniciales y al no ser un proyecto de gr´an taman˜o no ha habido contratiempos (tabla 4.22). La prueba presencial se tuvo que retrasar por la pandemia. Tarea Horas estimadas Horas reales Inicio estimado Fin estimado Inicio real Fin real TOTAL 30 30 20/4/2020 5/5/2020 20/7/2020 10/12/2020 Inicio 0 0 20/4/2020 20/4/2020 20/7/2020 20/7/2020 Pruebas individuales de funcionalidad 10 10 20/4/2020 25/4/2020 20/7/2020 25/7/2020 Pruebas sobre la aplicaci´on completa 10 10 25/4/2020 30/4/2020 25/7/2020 30/7/2020 Pruebas en la plataforma web 5 5 30/4/2020 4/5/2020 30/7/2020 4/8/2020 Prueba presencial con alumnos 2 2 4/5/2020 4/5/2020 10/12/2020 10/12/2020 Elaboracion del videotutorial 3 3 4/5/2020 5/5/2020 4/8/2020 5/8/2020 Fin 0 0 5/5/2020 5/5/2020 5/8/2020 5/8/2020 Tabla 4.22: Seguimiento de la fase de pruebas del primer juego En la fase de analisis del segundo juego vuelven a surgir problemas, ya que se retoma la idea descartada para el primer juego. Esta idea vuelve a ser un problema debido a su dificil adaptacio´n a la gamificacio´n de la asignatura. Pero finalmente y con un retraso considerable se consigui´o llegar a un acuerdo en el concepto del segundo juego (tabla 4.23). 33 Tarea Horas estimadas Horas reales Inicio estimado Fin estimado Inicio real Fin real TOTAL 46 82 5/5/2020 20/5/2020 5/8/2020 20/11/2020 Inicio 0 0 5/5/2020 5/5/2020 5/8/2020 5/8/2020 Definicio´n de requisitos del primer juego 2 2 5/5/2020 6/5/2020 5/8/2020 6/8/2020 Proceso creativo para definir el juego 20 50 5/5/2020 15/5/2020 5/8/2020 25/10/2020 Realizaci´on del GDD 4 5 5/5/2020 15/5/2020 25/10/2020 28/10/2020 Formaci´on sobre Unity 15 20 10/5/2020 18/5/2020 25/10/2020 10/11/2020 Analisis del modelo de dominio 3 3 15/5/2020 20/5/2020 5/11/2020 20/11/2020 Analisis de casos de uso 2 2 15/5/2020 20/5/2020 5/11/2020 20/11/2020 Fin 0 0 20/5/2020 20/5/2020 20/11/2020 20/11/2020 Tabla 4.23: Seguimiento de la fase de analisis del segundo juego La fase de disen˜o del segundo juego no ten´ıa demasiada carga y se ha ajustado a los tiempos previstos (tabla 4.24). Tarea Horas estimadas Horas reales Inicio estimado Fin estimado Inicio real Fin real TOTAL 13 15 20/5/2020 25/5/2020 20/11/2020 25/11/2020 Inicio 0 0 20/5/2020 20/5/2020 20/11/2020 20/11/2020 Investigacio´n de patrones de disen˜o en Unity 10 12 20/5/2020 24/5/2020 20/11/2020 24/11/2020 Arquitectura del juego 3 3 22/5/2020 25/5/2020 22/11/2020 25/11/2020 Fin 0 0 25/5/2020 25/5/2020 25/11/2020 25/11/2020 Tabla 4.24: Seguimiento de la fase de disen˜o del segundo juego La fase de implementacio´n apenas se desv´ıa de los tiempos previstos e incluso gracias a la experiencia adquirida con el primer juego se consigue una implementaci´on m´as r´apida de las funcionalidades (tabla 4.25). Tarea Horas estimadas Horas reales Inicio estimado Fin estimado Inicio real Fin real TOTAL 48 41 25/5/2020 10/6/2020 25/11/2020 10/12/2020 Inicio 0 0 25/5/2020 25/5/2020 25/11/2020 25/11/2020 Configuracio´n de Unity 2 2 25/5/2020 26/5/2020 25/11/2020 26/11/2020 Obetencio´n y creacio´n de sprites 8 8 25/5/2020 30/5/2020 25/11/2020 30/11/2020 Implementacio´n de las funcionalidades 25 20 25/5/2020 5/6/2020 25/11/2020 5/12/2020 Implementacio´n de la interfaz de usuario 10 7 2/6/2020 7/6/2020 2/12/2020 7/12/2020 Implementacio´n de la conexio´n con la plataforma web 3 4 5/6/2020 10/6/2020 5/12/2020 10/12/2020 Fin 0 0 10/6/2020 10/6/2020 10/12/2020 10/12/2020 Tabla 4.25: Seguimiento de la fase de implementacio´n del segundo juego Las pruebas del segundo juego tambien han ido de acuerdo con las estimaciones iniciales y al no ser un proyecto de gr´an taman˜o no ha habido contratiempos (tabla 4.26). La prueba presencial se tuvo que cancelar debido al fin de las clases. 34 Tarea Horas estimadas Horas reales Inicio estimado Fin estimado Inicio real Fin real TOTAL 30 30 10/6/2020 25/6/2020 10/12/2020 25/12/2020 Inicio 0 0 10/6/2020 20/6/2020 10/12/2020 20/12/2020 Pruebas individuales de funcionalidad 10 10 10/6/2020 15/6/2020 10/12/2020 15/12/2020 Pruebas sobre la aplicaci´on completa 10 10 15/6/2020 20/6/2020 15/12/2020 10/1/2021 Pruebas en la plataforma web 5 5 20/6/2020 24/5/2020 20/12/2020 12/1/2021 Prueba presencial con alumnos 2 0 24/6/2020 24/5/2020 24/12/2020 14/1/2021 Elaboracion del videotutorial 3 3 24/6/2020 25/5/2020 24/12/2020 15/1/2021 Fin 0 0 25/6/2020 25/6/2020 25/12/2020 15/1/2021 Tabla 4.26: Seguimiento de la fase de pruebas del segundo juego 4.4. Costes Los costes totales del proyecto han sido de 0 ➾ . Todo el material usado por el alumno ya estaba amortizado y por tanto no se han generado costes adicionales. Se han usado tambi´en herramientas gratuitas. Por el inter´es del an´alisis de costes, se proceder´a a simular los costes de este proyecto de haberse realizado fuera de un contexto acad´emico. Se supondra´ un salario de programador Junior de 18.751 ➾ anuales. Esto ser´ıa el un sueldo aproximado de unos 9,62 ➾ la hora. Suponiendo un contrato flexible por horas hasta fin de obra, el precio del proyecto ser´ıa de 7.138 ➾ de inversio´n en recursos humanos. 35 Cap´ıtulo 5 Minijuego 1: Tipos de Datos 5.1. GDD 5.1.1. Introducci´on Se trata de un videojuego did´actico sobre los tipos de datos en java, centrandonos en los tipos b´asicos. El objetivo es explicar mediante la gamificaci´on los distintos tipos de datos y las diferencias entre ellos as´ı como sus diferentes caracter´ısticas. El videojuego consta de dos elementos principales que son las plataformas de datos y las piezas de datos. Cada pieza de datos representa un valor literal y cada plataforma un tipo de dato, la pieza de datos se puede introducir en cada plataforma asignandole un tipo. El objetivo del juego es asignar una serie de piezas de datos generadas proceduralmente al tipo de dato m´as correcto haciendo uso de las distintas plataformas de datos. Para hacerlo posible el jugador podr´a desplazar horizantalmente la pieza de datos con el fin de introducirla en la plataforma correcta. El juego consta de varios niveles, en cada nivel se van introduciendo distintos tipos de datos. Figura 5.1: Captura de pantalla: Tipos de Datos 36 En la figura 5.1 podemos ver una imagen del juego en uno de sus niveles. En la parte inferior se pueden observar las plataformas de datos cada una de un color distinto y con el nombre del tipo de dato que representan. En el centro de la pantalla se puede ver la pieza de datos que controla el jugador actualmente. En la parte superior izquierda se muestra la pr´oxima pieza que aparecer´a y en la esquina derecha el contador de vidas y la puntuacio´n del jugador. 5.1.2. Audiencia y Plataforma El desarrollo de este juego serio forma parte de un proyecto de gamificaci´on de la asignatura de Fundamentos de programacio´n, que es impartida en el primer curso de los estudios del Grado de Ingenier´ıa Inform´atica. Por lo tanto la audiencia objetivo son los alumnos de dicha asignatura y los profesores que usara´n las estadisticas para comprobar el aprendizaje. La plataforma sera´ una aplicacio´n web que ya ha sido creada anteriormente en otro proyecto. 5.1.3. Mec´anicas Al principio de cada nivel se informara´ al jugador de los tipos de datos con les que trabajara´ mediante un cuadro de informacio´n, una vez use el boto´n de comenzar empezara´ el juego. El elemento ma´s importante es la pieza de datos la cual ser´a el jugador el encargado de mover. Esta pieza siempre se generar´a en la misma posicio´n y cada vez que sea encajada en un plataforma aparecera´ otra que tambien sera´ controlada por el jugador. La pieza es afectada por una fuerza que la hace moverse hacia abajo, dicha fuerza es variable seg´ıu´n en el nivel y sirve para regular la dificultad. El jugador podra´ realizar dos acciones distintas sobre las piezas: Mover horizontalmente la pieza, haciendo uso de las teclas de direccio´n del teclado o en su defecto haciendo click izquierdo en el lado correspondiente de la pantalla. La velocidad de movimiento dependera´ del nivel en el que se encuentre. Aumentar la velocidad de descenso de la pieza, haciendo uso de la tecla de direccio´n del teclado o en su defecto haciendo click izquierdo en la parte inferior de la pantalla. El segundo elemento ma´s importante ser´ıan las plataformas de datos (figura 5.2), las cuales tienen una posicion fija en la parte inferior excepto en el nivel final donde ir´an subiendo su posici´on poco a poco con el fin de aumentar la dificultad. Cada plataforma representa un tipo de dato cuyo nombre aparece representado en la misma, tambien sera´n de un color diferente cada una de ellas. El taman˜o sera´ variable en funcio´n del tipo de dato que representa y su taman˜o de almacenamiento. Los distintos tipos de datos que hay presentes en el juego son: Byte Short Int Long Float Double 37 Char String Los valores generados para cada tipo de dato se corresponder´an con los rangos establecidos en java, tambien se har´a uso de distintas expresiones con operadares donde el jugador deber´a decidir cual es el tipo de dato resultante, algunas expresiones incluira´n funciones propias de java. El jugador contar´a con un total de 3 vidas para completar cada nivel, para poder superarlo debe colocar todas las piezas sin haber perdido todas las vidas. Se perder´a una vida cada vez que una pieza de datos sea colocada en la plataforma de datos incorrecta. El numero de piezas a colocar en cada nivel ser´a distinto. Si el nivel no es superado se le presentara´ al jugador un cuadro de informacio´n a modo de retroalimentacio´n de los errores. La puntuaci´on se calcular´a en base al numero de piezas colocadas correctamente y por cada vida perdida se restara´ una cantidad determinada de puntos, la velocidad tambien sera´ premiada en forma de puntos extras. Figura 5.2: Boceto: Tipos de Datos 5.1.4. Niveles El videojuego constara´ de 6 niveles, uno de ellos, el primero a modo de tutorial. En cada nivel se ira´n an˜adiendo distintos tipos de datos de manera escalonada. Las piezas de datos son generadas de manera dina´mica en cada nivel por tanto la repeticio´n de niveles no facilitara´ su resolucio´n. Nivel 0 Objetivos de aprendizaje: En el nivel tutorial no hay ningu´n objetivo de aprendizaje. 38 Objetivos del nivel: Se deber´an encajar 10 piezas de colores (azul, roja, verde o amarillo) en cuatro plataformas de colores destintas. La velocidad de ca´ıda en este nivel sera´ 3.0 unidades por segundo. En este caso para el tutorial se usara´n plataformas de colores azul, verde, roja y amarilla, como los de las piezas. Es necesario no perder las tres vidas para superar el nivel. Servira´ para ayudar al jugador a familiarizarse con los controles e introducirle en el juego. Nivel 1 Objetivos de aprendizaje: Distinguir entre valores enteros y decimales. Conocer los rangos de los tipos de dato int y double. Entender el tipo de dato resultante en expresiones con operadores. Reconocer funciones que transforman una valor en un tipo de dato concreto. Objetivos del nivel: En este nivel la cantidad de piezas de datos a colocar sera´n 10 con una velocidad de ca´ıda de 2.8 unidades por segundo. Los tipos de datos representados con plataformas sera´n int y double. Es necesario no perder las tres vidas para superar el nivel. Nivel 2 Objetivos de aprendizaje: Ditinguir entre todos los tipos numer´ıcos de java. Conocer los rangos de los tipos de dato byte, short, long y float. Entender el tipo de dato resultante en expresiones con operadores. Aprender el uso de sufijos para denotar distintos tipos de datos. Objetivos del nivel: En este nivel la cantidad de piezas de datos a colocar sera´n 10 con una velocidad de ca´ıda de 3.1 unidades por segundo. Los tipos de datos representados con plataformas sera´n byte, short, int, long, float y double. Es necesario no perder las tres vidas para superar el nivel. Nivel 3 Objetivos de aprendizaje: Ditinguir entre todos los tipos numer´ıcos de java, ann˜adiendo el tipo char. Conocer los rangos de los tipos de dato byte, short, long y float. Entender el tipo de dato resultante en expresiones con operadores. Aprender el uso de sufijos para denotar distintos tipos de datos. Aprender el funcionamiento del tipo char en operaciones con enteros. Objetivos del nivel: En este nivel la cantidad de piezas de datos a colocar sera´n 10 con una velocidad de ca´ıda de 3.45 unidades por segundo. Los tipos de datos representados con plataformas sera´n char, byte, short, int, long, float y double. Es necesario no perder las tres vidas para superar el nivel. 39 Nivel 4 Objetivos de aprendizaje: Ditinguir entre todos los tipos numer´ıcos de java y los tipos de texto char y string. Conocer los rangos de los tipos de dato byte, short, long y float. Entender el tipo de dato resultante en expresiones con operadores. Aprender el uso de sufijos para denotar distintos tipos de datos. Aprender el funcionamiento del tipo char en operaciones con enteros. Comprender el funcionamiento de operaciones en cadenas de caracteres. Objetivos del nivel: En este nivel la cantidad de piezas de datos a colocar sera´n 10 con una velocidad de ca´ıda de 3.45 unidades por segundo. Los tipos de datos representados con plataformas ser´an char, string, byte, short, int, long, float y double. Es necesario no perder las tres vidas para superar el nivel. Nivel 5 Objetivos de aprendizaje: Ditinguir entre todos los tipos numer´ıcos de java y los tipos de texto char y string. Conocer los rangos de los tipos de dato byte, short, long y float. Entender el tipo de dato resultante en expresiones con operadores. Aprender el uso de sufijos para denotar distintos tipos de datos. Aprender el funcionamiento del tipo char en operaciones con enteros. Comprender el funcionamiento de operaciones en cadenas de caracteres. Objetivos del nivel: En este nivel la cantidad de piezas de datos a colocar sera´n 10 con una velocidad de ca´ıda de 4.2 unidades por segundo. Los tipos de datos representados con plataformas ser´an char, string, byte, short, int, long, float y double. Es necesario no perder las tres vidas para superar el nivel. Adicionalmente en este nivel las plataformas de datos ira´n elevando su posicio´n con el fin de aumentar la dificultad en el u´ltimo nivel. 5.1.5. Multimedia Los elementos multimedia empleados en el desarrollo del juego sera´n los siguientes: Sprites: Al tratarse de un juego 2D los elementos del juego sera´n represantados por sprites, con dos sprites se han creado las plataformas modificando el color para diferenciarlas. Tambien se usar´an sprites en la interfaz para representar las vidas y la puntuaci´on as´ı como para la construcci´on del menu´ principal. Fuente: Las piezas de datos sera´n representadas visualmente con texto, para ellos se han empleado una fuente estilo pixelart que estara´ presente en todo el juego. Efectos de sonido: Se usar´an diversos efectos de sonidos para retroalimentar al usuarios de los errores y seleccio´n de opciones en el menu´. Im´agenes: Para cada nivel se usar´a una im´agen de fondo distinto que permitir´a diferenciar los niveles entre si. 40 5.1.6. Versiones Durante el desarrollo del juego se ira´n implementado las distintas caracter´ısticas del juego de manera escalonado y finalmente an˜adiendo el contenido en forma de niveles. Estas son las versiones planeadas: Versi´on 0.5: En la primera versi´on unicamente estar´an implementadas las mec´anicas b´asicas del juego, haciendo uso de un nivel tutorial en el que se usara´n formas de colores en lugar de piezas de datos. Versi´on 1.0: Se an˜ade el primer nivel jugable y sus tipos de datos asociados, tambien se incluye el sistema de vidas y una primera versio´n del menu´. Versi´on 2.0: Se an˜aden todos los niveles restantes y se incluyen efectos de sonido. Tambien se an˜ade la retroalimentacio´n de errores. Versi´on 2.1: Versio´n final del juego con el sistema de puntuacio´n y arreglos varios. 5.2. An´alisis 5.2.1. An´alisis de requisitos La aplicacio´n tiene que satisfacer ciertos requisitos para poder cumplir con las exigencias del proyecto. Estos requisitos marcara´n la solucio´n finalmente elegida para implementar esta aplicacio´n. Se muestran en las tablas 5.1 a 5.13. RF-01 Carga del menu´ principal Descripci´on El juego debera´ cargar un menu´ principal, que permitira´ iniciar un nivel del juego en concreto, salir del juego y ver el tutorial Tabla 5.1: RF-01: Carga del menu´ principal RF-02 Iniciar nivel Descripci´on El sistema deber´a permitir al usuario cargar un nivel Tabla 5.2: RF-02: Iniciar nivel RF-03 Salir del nivel Descripci´on El sistema deber´a permitir al usuario salir de un nivel Tabla 5.3: RF-03: Salir del nivel RF-04 Mostrar ayuda al iniciar nivel Descripci´on El sistema deber´a mostrar un panel con ayuda al principio de cada nivel Tabla 5.4: RF-04: Mostrar ayuda al iniciar nivel RF-05 Generar pieza de datos Descripci´on El sistema deber´a generar datos aleatorios correspondientes al nivel seleccionado Tabla 5.5: RF-05: Generar pieza de datos 41 RF-06 Mover pieza de datos Descripci´on El sistema debera´ permitir al usuario mover la pieza de datos en el eje horizontal y acelerar su ca´ıda hacia abajo Tabla 5.6: RF-06: Mover pieza de datos RF-07 Puntuacio´n del jugador Descripci´on El sistema deber´a generar una puntuacio´n para cada nivel superado en funci´on del desempen˜o del jugador Tabla 5.7: RF-07: Puntuacio´n del jugador RF-08 Tutorial de inicio Descripci´on El sistema deber´a mostrar un tutorial b´asico explicando los controles y mec´anicas principales del juego Tabla 5.8: RF-08: Tutorial de inicio RF-09 Cerrar el juego Descripci´on El sistema deber´a permitir cerrar el juego guardando los progresos Tabla 5.9: RF-09: Cerrar el juego RNF-01 Motor de desarrollo Descripci´on El sistema deber´a ser desarrollado haciendo uso del motor de juego Unity Tabla 5.10: RNF-01: Motor de desarrollo RNF-02 Lenguaje de programacio´n Descripci´on El sistema deber´a ser desarrollado haciendo uso del lenguaje C# Tabla 5.11: RNF-02: Lenguaje de programacio´n RNF-03 Plataforma objetivo Descripci´on El sistema deber´a ser desarrollado y adaptado para el uso en WebGL Tabla 5.12: RNF-03: Plataforma objetivo RNF-04 Comunicacio´n con la plataforma Descripci´on El sistema debera´ comunicarse con la plataforma principal del proyecyo cargando y guardando el progreso del jugador as´ı como las estadisticas Tabla 5.13: RNF-04: Comunicacio´n con la plataforma 5.2.2. Casos de uso En el digrama de las figuras 5.3 y 5.4 se encuentran los diferentes casos de uso que pueden realizarse en nuestra aplicacio´n. El u´nico actor del sistema sera´ el juegador. Se han dividido los casos de uso en dos escenarios distintos, uno correspondiente a cuando el jugador se encuentra en el menu´ principal (Figura 5.3) y otro para cuando se encuentra jugando un nivel (Figura 5.4). 48 En la figura 6.1 podemos ver una imagen del juego en el nivel principal. En la parte izquierda de la pantalla podemos ver los puntos actuales del jugador as´ı como el total de estrellas que ha recogido en esta partida. Tambien existe un boto´n que permite volver al menu principal. En la parte central podemos ver el cuestionario, en la parte superior se encuentra el enunciado de la pregunta asi como un temporizador que indica el tiempo restante, en la parte inferior se encuentran las distintas respuestas y existe un boto´n que permite proceder a la siguiente pregunta. En la parte derecha de la pantalla podemos ver el tablero por el cual el jugador debe desplazarse. 6.1.2. Audiencia y Plataforma El desarrollo de este juego serio forma parte de un proyecto de gamificaci´on de la asignatura de Fundamentos de programacio´n, que es impartida en el primer curso de los estudios del Grado de Ingenier´ıa Inform´atica. Por lo tanto la audiencia objetivo son los alumnos de dicha asignatura y los profesores que usara´n las estadisticas para comprobar el aprendizaje. La plataforma sera´ una aplicacio´n web que ya ha sido creada anteriormente en otro proyecto. 6.1.3. Mec´anicas Al principio de cada partida el jugador ser´a posicionado en una casilla aleatoria dentro del tablero y dara´ comienzo el juego. El elemento m´as importante del juego es el tablero, que consta de 8 casillas, las cuales pueden ser de dos tipos (figura 6.2): Casilla normal: esta casilla es de color blanco con el borde azul. Este tipo de casillas no ofrece ninguna recompensa al resolver las preguntas con ´exito. Casilla estrella: esta casilla es de color azul y tiene el icono de una estrella en blanco y negro. Al resolver de manera correcta las preguntas ser´emos recompensados con una estrella. Al hacerlo el icono cambiara´ por uno de una estrella en color. Las 8 casillas formar´an un circuito cerrado en el cual se podr´a desplazar en ambos sentidos. En el centro del circuito se encontrara´ un dado que al final de cada turno producira´ un valor aleatorio entre 1 y 3 que nos permitir´a saber que numero de casillas podemos desplazarnos en el turno actual. El objetivo principal del juego sera´ conseguir las 4 estrellas que estara´n repartidas en las distintas casillas con estrella. Para ello, debemos resolver cada casilla correctamente y desplazarnos por el tablero con la ayuda del dado. El segundo elemento ma´s importante son los cuestionarios de preguntas. Al seleccionar una casilla sobre la que desplazarnos aparecera´ un cuestionario con una pregunta y cuatro respuestas. Cada casilla tendra´ preguntas diferentes y se seleccionar´a una de manera aleatoria. Las preguntas consisten en funciones recursivas a las que les falta un trozo, el lugar donde falta ser´a resaltado en color rojo. El jugador debe elegir la solucio´n correcta entre las posibles respuestas. En caso de contestar de manera correcta se lanzara´ el dado y podr´as desplazarte a otra casilla, por el contrario en caso de contestar mal se aplicar´a una penalizacio´n de 1000 puntos y se mostrara´ otra pregunta de esta casilla. Pueden existir preguntas tanto de respuesta u´nica como multirespuesta, por defecto existira´ un contador de tiempo l´ımite de 60 segundos para contestar la pregunta. 49 Para poder superar el juego se debe conseguir las 4 estrellas. El jugador tambien contar´a con una puntuacio´n inicial de 8000 puntos. Para que el juego sea completado con ´exito debes mantener al menos la mitad de la puntuacio´n, es decir, 4000 puntos. Por lo tanto se pueden fallar un total de 4 preguntas. Si la puntuacio´n baja de los 4000 puntos el juego se dara´ por finalizado y el jugador debera´ empezar desde el principio. Figura 6.2: Iconos: Recursividad 6.1.4. Niveles El videojuego no tiene niveles pero para evitar la predecibilidad y que el jugador gane por simple repetici´on cada casilla tendr´a una serie de preguntas distintas entra las que se elige una al azar en cada momento. Para cada pregunta se ha tomado una funcio´n recursiva y se han retirado partes tales como la precondicio´n, caso ba´sico o llamada recursiva. Las preguntas esta´n basadas en las siguientes funciones, de las que se han quitado, en cada caso, alguna de sus partes: Factorial 1 2 3 4 5 6 7 8 Potencia 1 2 3 4 5 public static long factorial (long n){ // PRECONDICION: n>=0 if (n == 0) return 1; else return n✯ factorial (n❂1); } public static int potencia ( int a, int b){ // PRECONDICION: (a != 0) y (b > = 0) if (b == 0) return 1; else 50 6 7 8 CuentaAtras 1 2 3 4 5 6 7 8 9 Multiplicar 1 2 3 4 5 6 7 8 Fibonacci 1 2 3 4 5 6 7 8 9 10 SumarNumeros 1 2 3 4 5 return a ✯ potencia(a, b ❂ 1); } public static int fibonacci ( int n){ // PRECONDICION: (n > = 0) if (n == 0) return 0; else if (n == 1) return 1; else return fibonacci (n❂1) + fibonacci(n❂2); } public static int sumarNumeros (int n){ // PRECONDICION: (n > = 0) if (n == 0) return 0; else public static void cuentaAtras ( int sec){ // PRECONDICION: (sec > = 0) if (sec == 0) System.out. println (”Fin de cuenta atrs ”); return ; else return cuentaAtras(sec ❂ 1); } public static void multiplicar ( int a, int b) { // PRECONDICION: (a > = 0) y (b > = 0) if (b == 0) return 0; else return a + multiplicar (a, b❂1); } 51 6 7 8 EsPotencia 1 2 3 4 5 6 7 8 9 10 ContarCifras 1 2 3 4 5 6 7 8 6.1.5. Multimedia Los elementos multimedia empleados en el desarrollo del juego sera´n los siguientes: Sprites: Al tratarse de un juego 2D los elementos del juego sera´n represantados por sprites, se han usado dos sprites distintos para las casillas as´ı como un sprite de estrella. Para el dado se han usados tres sprites distintos para los tres valores. Mu´sica y efectos de sonido: Se usan efectos de sonido para los aciertos y errores, tambien existe un efecto de sonido para el contador de tiempo. Este juego tambien dispone de una pista de mu´sica que suena en bucle durante la partida. Im´agenes: Se usara´ una ima´gen de fondo para el menu´. 6.1.6. Versiones Durante el desarrollo del juego se ira´n implementado las distintas caracter´ısticas del juego de manera escalonado y finalmente an˜adiendo el contenido en forma de niveles. Estas son las versiones planeadas: Versi´on 0.5: En la primera versi´on unicamente estar´an implementadas las mec´anicas b´asicas del juego, haciendo uso de cuestionarios con preguntas de prueba. return n + sumarNumeros(n ❂ 1); } public static boolean esPotencia (int a, int b){ // PRECONDICION: (a > = 0) y (b > = 0) if (a == 0) return false ; else if (a == b) return true ; else return esPotencia(a/b, b); } public static void contarCifras ( int n){ // PRECONDICION: (n > = 0) if (n < 10) return 1; else return 1 + contarCifras(n/10); } 52 Versi´on 1.0: Se an˜ade el primer nivel jugable y algunas preguntas, tambien se incluye el tablero y una primera versio´n del menu´. Versi´on 2.0: Se an˜aden todas las preguntas restantes y se incluyen efectos de sonido. Tambien se an˜ade la retroalimentacio´n de errores. Versi´on 2.1: Versio´n final del juego con el sistema de puntuacio´n y arreglos varios. 6.2. An´alisis 6.2.1. An´alisis de requisitos La aplicacio´n tiene que satisfacer ciertos requisitos para poder cumplir con las exigencias del proyecto. Estos requisitos marcara´n la solucio´n finalmente elegida para implementar esta aplicacio´n. Se muestran en las tablas 6.1 a 6.13. RF-01 Carga del menu´ principal Descripci´on El juego debera´ cargar un menu´ principal, que permitira´ iniciar un nivel del juego en concreto, salir del juego y ver el tutorial Tabla 6.1: RF-01: Carga del menu´ principal RF-02 Iniciar nivel Descripci´on El sistema deber´a permitir al usuario cargar un nivel Tabla 6.2: RF-02: Iniciar nivel RF-03 Salir del nivel Descripci´on El sistema deber´a permitir al usuario salir de un nivel Tabla 6.3: RF-03: Salir del nivel RF-04 Mostrar el tablero Descripci´on El sistema deber´a mostrar el tablero, incluyendo la posici´on del jugador y el dado. Tabla 6.4: RF-04: Mostrar el tablero RF-05 Mostrar cuestionarios Descripci´on El sistema deber´a mostrar correctamente las preguntas y respuestas de cada casilla Tabla 6.5: RF-05: Mostrar cuestionarios RF-06 Mover pieza en el tablero Descripci´on El sistema deber´a permitir al usuario mover su pieza en el tablero Tabla 6.6: RF-06: Mover pieza de datos RF-07 Puntuacio´n del jugador Descripci´on El sistema deber´a generar una puntuacio´n para cada nivel superado en funci´on del desempen˜o del jugador Tabla 6.7: RF-07: Puntuacio´n del jugador 53 RF-08 Tutorial de inicio Descripci´on El sistema deber´a mostrar un tutorial b´asico explicando los controles y mec´anicas principales del juego Tabla 6.8: RF-08: Tutorial de inicio RF-09 Cerrar el juego Descripci´on El sistema deber´a permitir cerrar el juego guardando los progresos Tabla 6.9: RF-09: Cerrar el juego RNF-01 Motor de desarrollo Descripci´on El sistema deber´a ser desarrollado haciendo uso del motor de juego Unity Tabla 6.10: RNF-01: Motor de desarrollo RNF-02 Lenguaje de programacio´n Descripci´on El sistema deber´a ser desarrollado haciendo uso del lenguaje C# Tabla 6.11: RNF-02: Lenguaje de programacio´n RNF-03 Plataforma objetivo Descripci´on El sistema deber´a ser desarrollado y adaptado para el uso en WebGL Tabla 6.12: RNF-03: Plataforma objetivo RNF-04 Comunicacio´n con la plataforma Descripci´on El sistema debera´ comunicarse con la plataforma principal del proyecyo cargando y guardando el progreso del jugador as´ı como las estadisticas Tabla 6.13: RNF-04: Comunicacio´n con la plataforma 6.2.2. Casos de uso En el digrama de las figuras 6.3 y 6.4 se encuentran los diferentes casos de uso que pueden realizarse en nuestra aplicacio´n. El u´nico actor del sistema sera´ el juegador. Se han dividido los casos de uso en dos escenarios distintos, uno correspondiente a cuando el jugador se encuentra en el menu´ principal (figura 6.3) y otro para cuando se encuentra jugando (figura 6.4). 54 Figura 6.3: Diagrama de casos de uso menu´ principal: Recursividad Figura 6.4: Diagrama de casos de uso nivel: Recursividad 55 6.3. Disen˜o En este desarrollo se ha usado Unity, el cual nos brinda una librer´ıa de clases en la que podemos encontrar recursos para el desarrollo de videojuegos, por lo tanto es fundamental el uso de sus clases para nuestra solucio´n. Debido a esta situacio´n, los diagramas de disen˜o no se realizara´n sobre todas las clases, unicamente sobre los scripts que realicemos que ser´an descendientos directos de MonoBehaviour. En la figura 6.5 se muestra el modelo de dominio. Figura 6.5: Modelo de dominio: Tipos de datos En esta solucio´n se ha decidido aplicar el siguiente patro´n de disen˜o: Patr´on Observador (figura 6.6): es un patro´n de comportamiento [5] que define una dependencia del tipo uno a muchos entre objetos, de manera que cuando uno de los objetos cambia su estado, notifica este cambio a todos los dependientes. Este patr´on esta relacionado con algoritmos de funcionamiento y asignaci´on de responsabilidades a clases y objetos. En nuestra soluci´on hemos utilizado este patro´n para actualizar los elementos de la interfaz, cada vez que se genera una pregunta o la pantalla de resultado todos los elementos son notificados para realizar su tarea correctamente. En nuestro caso para implementarlo hemos usado el tipo delegado de C#. 56 Figura 6.6: Patr´on Observador 6.4. Pruebas En esta secci´on se van a mostrar las diferentes pruebas realizadas a lo largo de la implementacio´n de nuestro proyecto. 6.4.1. Pruebas Unitarias PU-01 Visualizar el videotutorial Descripci´on Al pulsar el bot´on tutorial del menu´ principal el juego deber´a cambiar de escena y mostrar el tutorial Resultado Correcto Tabla 6.14: PU-01: Visualizar el videotutorial PU-02 Iniciar el nivel Descripci´on Al pulsar el bot´on de jugar del menu´ principal el juego deber´a cambiar de escena e iniciar nivel Resultado Correcto Tabla 6.15: PU-02: Iniciar un nivel PU-03 Salir del juego Al pulsar el bot´on salir del menu´ principal el juego deber´a cerrarse Resultado Correcto Tabla 6.16: PU-03: Salir del juego PU-04 Completar nivel Al cumplir la condicion de victoria el nivel se marca como superado y se realizan las acciones correspondientes Resultado Correcto Tabla 6.17: PU-04: Completar nivel 57 PU-05 Fallar nivel Al agotar la puntuacio´n, se acaba el juego y se marca como fallado Resultado Correcto Tabla 6.18: PU-05: Fallar nivel PU-06 Salir del nivel Al pulsar el bot´on de salir, el juego vuelve al menu principal Resultado Correcto Tabla 6.19: PU-06: Salir del nivel PU-07 Seleccionar casilla del tablero El jugador puede moverse por el tablero Resultado Correcto Tabla 6.20: PU-7: Mover pieza horizontalmente PU-08 Seleccionar respuesta El jugador puede elegir las respuestas entre las que se muestran Resultado Correcto Tabla 6.21: PU-08: Acelerar movimiento descendente de la pieza PU-09 Corregir pregunta Despues de cambiar de pregunta el juego es capaz de corregir la eleccio´n del jugador Resultado Correcto Tabla 6.22: PU-09: Generacio´n de piezas PU-10 Cambio en la puntuacio´n Dependiendo de los eventos la puntuacio´n cambia acorde con ellos Resultado Correcto Tabla 6.23: PU-10: Cambio en la puntuacio´n