TESIS - .:Centro de Desarrollo Bibliotecario:.biblio.uabcs.mx/tesis/te3314.pdf · Hoy en día, para...
61
UNIVERSIDAD AUTÓNOMA DE BAJA CALIFORNIA SUR ÁREA DE CONOCIMIENTO DE CIENCIAS DEL MAR DEPARTAMENTO ACADÉMICO DE SISTEMAS COMPUTACIONALES TESIS INGENERÍA DE SOFTWARE APLICADA AL DESARROLLO DE VIDEOJUEGOS QUE PARA OBTENER EL TÍTULO DE: LICENCIADO EN COMPUTACIÓN PRESENTA: BERNARDO CHAPARRO GARCÍA DIRECTOR: M.S.C. ITALIA ESTRADA COTA LA PAZ, B.C.S. ABRIL DEL 2015.
Transcript of TESIS - .:Centro de Desarrollo Bibliotecario:.biblio.uabcs.mx/tesis/te3314.pdf · Hoy en día, para...
UNIVERSIDAD AUTÓNOMA DE BAJA CALIFORNIA SUR
ÁREA DE CONOCIMIENTO DE CIENCIAS DEL MAR
DEPARTAMENTO ACADÉMICO DE SISTEMAS COMPUTACIONALES
TESIS
INGENERÍA DE SOFTWARE APLICADA AL DESARROLLO DE VIDEOJUEGOS
QUE PARA OBTENER EL TÍTULO DE: LICENCIADO EN COMPUTACIÓN
PRESENTA:
BERNARDO CHAPARRO GARCÍA
DIRECTOR:
M.S.C. ITALIA ESTRADA COTA
LA PAZ, B.C.S. ABRIL DEL 2015.
Contenido
Capítulo I “Antecedentes” .................................................................................................. 1
Antecedentes ................................................................................................................. 1
Descripción del problema ............................................................................................... 3
Propuesta de solución .................................................................................................... 4
Objetivo general ............................................................................................................. 5
Estado del arte ............................................................................................................... 6
Ingeniería de Software ................................................................................................ 6
Metodología de cascada para el desarrollo del videojuego ......................................... 6
Tecnologías de desarrollo ........................................................................................... 8
Beneficio y alcance ...................................................................................................... 10
Capítulo II “Marco Teórico” .............................................................................................. 11
Ingeniería del Software ................................................................................................ 11
Ciclo de Vida ................................................................................................................ 12
Metodología de Cascada para los Videojuegos ............................................................ 14
Lenguajes de programación ......................................................................................... 17
Python ...................................................................................................................... 17
Eclipse ...................................................................................................................... 18
Pygame .................................................................................................................... 19
Capitulo III “Desarrollo del videojuego” ............................................................................ 21
Especificación del juego ............................................................................................... 21
La biblia del arte y la historia ........................................................................................ 21
Especificaciones técnicas............................................................................................. 25
Construcción ................................................................................................................ 32
Aseguramiento de calidad ............................................................................................ 45
Pruebas de juego ......................................................................................................... 45
Pruebas alfa ................................................................................................................. 45
Golden master .............................................................................................................. 45
Capitulo IV “Breve recorrido por el videojuego” ................................................................ 46
Iniciar el juego .............................................................................................................. 46
Head-Up Displays (HUD) ........................................................................................... 47
Inventario de armas ...................................................................................................... 49
Controles del Juego ..................................................................................................... 50
Gameplay ..................................................................................................................... 52
Capítulo V “Resultado y conclusiones” ............................................................................ 55
Resultados ................................................................................................................... 55
Conclusiones ................................................................................................................ 55
Bibliografía ....................................................................................................................... 56
Tabla de figuras
1.1 Metodología de Cascada para el desarrollo del videojuego .............................. 7
2.1 Metodología de Cascada para el desarrollo del videojuego ............................ 14
3.1 Diagrama de casos de uso del videojuego ...................................................... 25
3.2 Diagrama de secuencia para Jugar ................................................................. 26
3.3 Diagrama de secuencia para Comprar armas ................................................ .26
3.4 Diagrama de secuencia para Crédito .............................................................. 27
3.5 Diagrama de clases del videojuego ................................................................. 28
3.6 Interfaz principal .............................................................................................. 29
3.7 Interfaz créditos ............................................................................................... 29
3.8 Interfaz de venta de armas y cargadores ........................................................ 29
3.9 Interfaces del pueblo según el nivel del juego ................................................. 30
3.10 Zombies para el videojuego .......................................................................... 31
3.11 Objetos del videojuego .................................................................................. 31
3.12 Armas para derrotar a los zombies ............................................................... 31
4.1 Interfaz inicial del videojuego .......................................................................... 46
4.2 Interfaz del videojuego .................................................................................... 47
4.3 Interfaz de armas del videojuego .................................................................... 49
4.4 Teclas de control del videojuego .................................................................... 51
1
Capítulo I “Antecedentes”
Antecedentes
Hoy en día la tecnología está presente en todos los aspectos de la vida cotidiana;
actualmente cualquier persona tiene acceso al uso de computadoras, tanto en
instituciones educativas como en sus hogares, lo que ha generado que utilicen
videojuegos para su entretenimiento. El uso de videojuegos por parte de niños y
jóvenes se ha vuelto muy común, lo que ha provocado el interés de explorar al
máximo los beneficios que se pueden lograr con estas herramientas en el ámbito
educativo y social.
A través del uso de videojuegos se pueden adquirir habilidades manuales, de
coordinación y orientación especial. Además permite la posibilidad de fortalecer
normas de comportamiento, así como de generar situaciones de interrelación con
otros compañeros de juegos, posibilitando el aprendizaje cooperativo [1].
Los videojuegos tiene un potencial educativo importante, pero el valor de
videojuegos no es sólo su factor motivacional, sino que, a través del juego se
puede aprender, se pueden desarrollar destrezas, habilidades, estrategias [2]. Se
puede aprender jugando.
El desarrollo de videojuegos es la actividad por la cual se diseña y crea un
videojuego, desde el concepto inicial hasta el videojuego en su versión final. Ésta
es una actividad multidisciplinaria, que involucra profesionales de la informática, el
diseño, el sonido, la actuación, entre otros. El desarrollo de un videojuego
generalmente sigue el siguiente proceso:
Concepción de la idea del videojuego
Diseño
Planificación
Pruebas
2
Producción
Mantenimiento
El proceso es similar a la creación de software en general, aunque difiere en la
gran cantidad de aportes creativos (música, historia, diseño de personajes,
niveles, entre otros) necesarios. El desarrollo también varía en función de la
plataforma objetivo (PC, móviles, consolas), el género (estrategia en tiempo real,
rpg, aventura gráfica, plataformas, entre otros) y la forma de visualización (2d,
2.5d y 3d). [3]
En [4] se mencionan que existen siete características que hacen de los
videojuegos un medio de aprendizaje más atractivo y efectivo:
1) Permiten el ejercicio de la fantasía, sin limitaciones espaciales, temporales o de gravedad.
2) Facilitan el acceso a “otros mundos” y el intercambio de unos a otros a través de los gráficos, contrastando de manera evidente con las aulas convencionales y estáticas.
3) Favorecen la repetición instantánea y el intentarlos otra vez, en un ambiente sin peligro.
4) Permiten el dominio de habilidades. Aunque sea difícil, los jugadores pueden repetir las acciones, hasta llegar a dominarlas, adquiriendo sensación de control.
5) Facilitan la interacción con otras personas.
6) Hay una claridad de objetivos. El jugador juega al videojuego sabe que hay una tarea clara y concreta: abrir una puerta, rescatar a alguien, hallar un tesoro, etc., lo cual proporciona un alto nivel de motivación.
7) Favorece un aumento de la atención y del autocontrol favoreciendo el éxito individual.
3
Descripción del problema
Hoy en día existen gran cantidad de videojuegos, pero ellos han presentado
algunas deficiencias, esto se debe principalmente a que no se siguió una
metodología de desarrollo de software para garantizar su calidad.
El desarrollo de los videojuegos es la fase por la cual se crea, desde su concepto
inicial hasta su etapa final. Para eso es necesario de utilizar una buena
metodología para el desarrollo de software que permita un buen control durante su
desarrollo.
Para garantizar su calidad del videojuego es necesario apoyarse en la Ingeniería
de Software, debido a que esta disciplina proporciona normas, estándares,
herramientas, métodos y técnicas que permiten desarrollar un software de calidad.
Es por ello que utilizando a la Ingeniería de Software garantizamos la calidad del
videojuego que se desarrollara a lo largo de esta tesis.
4
Propuesta de solución
Realizar un videojuego denominado “Ataque Zombie”, para ello se apoyara en los
métodos, estándares y las herramientas que proporciona la Ingeniería del
Software para el desarrollo y el mantenimiento de un videojuego de calidad.
Este videojuego se desarrollara utilizando el ciclo de vida de Cascada, ya que
proporciona una manera práctica y sencilla para el desarrollo de videojuego,
debido a que consiste en una adaptación del método del proceso de creación de
software.
5
Objetivo general
Desarrollar un videojuego de tipo shooters denominado “Ataque Zombie”,
utilizando a la Ingeniería de Software, específicamente al ciclo de vida de cascada
pura para garantizar su calidad.
6
Estado del arte
El propósito de desarrollar un videojuego utilizando la Ingeniería de Software se
debe a que nos permite analizar, diseñar y programar un software de manera
correcta. Así permitiendo cumplir con las especificaciones.
Ingeniería de Software
Hoy en día, para el desarrollo de software, se toma en cuenta la Ingeniería de
Software, ya que ofrece métodos y técnicas para desarrollar y mantener software
de calidad [5].
La ingeniería del software tiene diversas definiciones; una definición desarrollada
por la IEEE es: “La ingeniería de software es la aplicación de un enfoque
sistemático, disciplinado y cuantificable hacia el desarrollo, operación y
mantenimiento del software” [6].
Metodología de cascada para el desarrollo del videojuego
Para la realización del videojuego se utilizará a la Ingeniería de Software,
específicamente la metodología propuesta por el ciclo de vida Cascada. Este ciclo
de vida, permite realizar de manera ordenada el desarrollo del videojuego, para
ello propone un conjunto de etapas ordenadas, cada una con sus tareas
específicas que permiten obtener un software de calidad. En la figura 1 se ilustra
la metodología y cada una de las etapas que lo componen, siendo estas:
7
Fig. 1. 1 Metodología de Cascada para el desarrollo del videojuego
Especificación del juego
Se realiza un documento que especifica el juego desde la perspectiva del usuario
(jugador). Es el equivalente a la fase de planeación del ciclo de vida de un
software.
Biblia del arte y la historia
Realizado por los productores y los directores artísticos donde especifican las
herramientas y los conceptos a usar desde la parte artística. Se define también la
historia, el guion y el diseño del juego desde distintos escenarios. Es el
equivalente a la fase de análisis del ciclo de vida de un software.
Especificaciones técnicas
Describe las herramientas ingenieriles como UML o diagramas de sistema, e
interacción entre tareas y el código (esta es la única fase estrictamente ingenieril).
Es el equivalente a la fase de diseño del ciclo de vida de un software.
8
Construcción
Se inicia la programación del videojuego, la creación de modelos, texturas,
niveles, arte conceptual y toda aquella tarea que dependa del diseño. Es el
equivalente a la fase de programación del ciclo de vida de un software.
Aseguramiento de calidad
El equipo de calidad debe verificar que todo se contraste con lo planteado en los
diseños originales de los documentos adecuadamente. Es el equivalente a la fase
de pruebas del ciclo de vida de un software.
Pruebas de juego
Sesiones con los directivos y productores donde se les muestran las
características del juego y se hace realimentación que debería modificar el
proceso para obtener un producto a total satisfacción.
Pruebas
Una vez se determina que el juego está en una fase estable, se libera a un selecto
grupo de evaluadores que determinan la calidad del juego, y plantean cambios
para mejorar la experiencia del juego en general (se supone que no deben surgir
cambios radicales). Pruebas beta: Se libera el juego a una gran audiencia y se
determinan aspectos que gustan o disgustan del juego para el mercado en
general.
Golden master
Momento en el que se libera el juego para el consumo masivo. Es el equivalente a
la fase de mantenimiento del ciclo de vida de un software de gestión empresarial
Tecnologías de desarrollo
Eclipse con la perspectiva de PyDev es un IDE (Integrated Development
Environment (Entorno De Desarrollo Integrado)) abierto y extensible al cual se le
agrego la perspectiva de PyDev para que interprete el código de Python.
9
Python es un lenguaje de programación interpretado multiparadigma, ya que
soporta orientación a objetos, programación imperativa y, en menor
medida, programación funcional. [7]
Pygame es un motor de juegos, conformado por un conjunto de librerías cuya
finalidad es facilitar la tarea del programador a la hora de realizar un videojuego.
Permite la creación y desarrollo de videojuegos de una forma clara y sencilla, sin
que esto nos impida obtener los resultados esperados puesto que puede
combinarse con otras librerías, como PyOpenGl, para incluir gráficos 3D.[8]
10
Beneficio y alcance
Con el apoyo de las técnicas, y herramientas que proporciona la Ingeniería de
software a través del uso del ciclo de vida de cascada pura se prende obtener un
software de calidad, es decir, un videojuego denominado “Ataque Zombie”. A su
vez el utilizar este ciclo de vida permitirá incorporar nuevas características de una
manera fácil y así poder darle un buen mantenimiento cuando este lo requiera.
El videojuego Ataque Zombi tendrá un alcance de 3 niveles para su mejor
rendimiento.
11
Capítulo II “Marco Teórico”
Ingeniería del Software
Hoy en día, para el desarrollo de software, se toma en cuenta la Ingeniería de
Software, ya que ofrece métodos y técnicas para desarrollar y mantener software
de calidad [5].
La ingeniería del software tiene diversas definiciones; una definición desarrollada
por la IEEE es: “La ingeniería de software es la aplicación de un enfoque
sistemático, disciplinado y cuantificable hacia el desarrollo, operación y
mantenimiento del software” [6].
Con independencia del área de aplicación, tamaño o complejidad del proyecto,
cualquier sistema se encontrará al menos en una de las siguientes fases
genéricas: definición, desarrollo y mantenimiento [5]. Esto es:
Definición.- Se centra sobre el qué; esta fase intenta identificar: que
información va a ser procesada, que función y rendimiento desea, que
compartimiento, que criterios de validación, entre otros.
Desarrollo.- Se centra en el cómo. Esta fase define como son las estructuras
de datos, como se traduce el diseño en una codificación, como son las
interfaces, entre otros.
Mantenimiento.- Se centra en el cambio que va asociado a la corrección de
errores, a las adaptaciones requeridas a medida que evoluciona el entorno del
software, entre otros.
12
La ingeniería del software permite desarrollar software de calidad, para ello
actualmente existen dos enfoques: estructurado y orientado a objetos [9]. En el
enfoque estructurado, la descomposición del problema es fundamentalmente por
funciones o procesos, lo cual origina una división jerárquica de procesos
constituidos por subprocesos; por otro lado el enfoque orientado a objetos busca
ante todo descomponer un espacio de problema por objetos.
La ingeniería de software orientada a objetos permite crear software modelando el
mundo de forma tal que ayuda a entenderlo, controlarlo y gobernarlo de una mejor
manera. [5].
Ciclo de Vida
El término ciclo de vida del software describe el desarrollo de software, desde la
fase inicial hasta la fase final. El propósito de este es definir las distintas fases
intermedias que se requieren para validar el desarrollo de la aplicación, es decir,
para garantizar que el software cumpla los requisitos para la aplicación y
verificación de los procedimientos de desarrollo: se asegura de que los métodos
utilizados son apropiados. [10]
El ciclo de vida permite que los errores se detecten lo antes posible y por lo tanto,
permite a los desarrolladores concentrarse en la calidad del software, en los
plazos de implementación y en los costos asociados.
El ciclo de vida de un software consta de los siguientes procedimientos:
Definición de objetivos: definir el resultado del proyecto y su papel en la
estrategia global.
13
Análisis de los requisitos y su viabilidad: recopilar, examinar y formular los
requisitos del cliente y examinar cualquier restricción que se pueda aplicar.
Diseño general: requisitos generales de la arquitectura de la aplicación.
Diseño en detalle: definición precisa de cada subconjunto de la aplicación.
Programación (programación e implementación): es la implementación de
un lenguaje de programación para crear las funciones definidas durante la
etapa de diseño.
Prueba de unidad: prueba individual de cada subconjunto de la aplicación
para garantizar que se implementaron de acuerdo con las especificaciones.
Prueba de integración: para garantizar que los diferentes módulos se
integren con la aplicación. Éste es el propósito de la prueba de integración
que está cuidadosamente documentada.
Prueba beta (o validación), para garantizar que el software cumple con las
especificaciones originales.
Documentación: sirve para documentar información necesaria para los
usuarios del software y para desarrollos futuros.
Implementación: es implementar el software resultado en el sitio
correspondiente.
Mantenimiento: para todos los procedimientos correctivos (mantenimiento
correctivo) y las actualizaciones secundarias del software (mantenimiento
continuo).
El orden y la presencia de cada uno de estos procedimientos en el ciclo de vida de
una aplicación dependen del tipo de modelo de ciclo de vida acordado entre el
cliente y el equipo de desarrolladores. [10]
Un ciclo de vida para un proyecto se compone de fases sucesivas compuestas por
tareas que se pueden planificar. Según el modelo de ciclo de vida, la sucesión de
fases puede ampliarse con bucles de realimentación, de manera que lo que
conceptualmente se considera una misma fase se pueda ejecutar más de una vez
a lo largo de un proyecto, recibiendo en cada pasada de ejecución aportaciones a
los resultados intermedios que se van produciendo (realimentación).
14
Metodología de Cascada para los Videojuegos
La metodología más común en el desarrollo de videojuegos es la de cascada, que
consiste en una adaptación del método de proceso de desarrollo de software.
(Ver figura 2.1)
Fig. 2. 1 Metodología de Cascada para el desarrollo del videojuego
Para el desarrollo de un videojuego las fases adaptables del método de cascada
son:
Especificación del juego
Se realiza un documento que especifica el juego desde la perspectiva del usuario
(jugador). Es el equivalente a la fase de planeación del ciclo de vida de un
software.
Biblia del arte y la historia
Realizado por los productores y los directores artísticos donde especifican las
herramientas y los conceptos a usar desde la parte artística. Se define también la
historia, el guión y el diseño del juego desde distintos escenarios. Es el
equivalente a la fase de análisis del ciclo de vida de un software.
15
Especificaciones técnicas
Describe las herramientas ingenieriles como UML o diagramas de sistema, e
interacción entre tareas y el código (esta es la única fase estrictamente ingenieril).
Es el equivalente a la fase de diseño del ciclo de vida de un software.
Construcción
Se inicia la programación del videojuego, la creación de modelos, texturas,
niveles, arte conceptual y toda aquella tarea que dependa del diseño. Es el
equivalente a la fase de programación del ciclo de vida de un software.
Aseguramiento de calidad
El equipo de QA debe verificar que todo se contraste con lo planteado en los
diseños originales de los documentos adecuadamente. Es el equivalente a la fase
de pruebas del ciclo de vida de un software.
Pruebas de juego
Sesiones con los directivos y productores donde se les muestran las
características del juego y se hace realimentación que debería modificar el
proceso para obtener un producto a total satisfacción.
Pruebas alfa
Una vez se determina que el juego está en una fase estable, se libera a un
selecto grupo de evaluadores que determinan la calidad del juego, y plantean
cambios para mejorar la experiencia del juego en general (se supone que no
deben surgir cambios radicales). Pruebas beta: Se libera el juego a una gran
audiencia y se determinan aspectos que gustan o disgustan del juego para el
mercado en general.
16
Golden master
Momento en el que se libera el juego para el consumo masivo. Es el equivalente a
la fase de Mantenimiento del ciclo de vida de un software de gestión empresarial.
Ventajas
La planificación es sencilla.
Si se conocen el total de los requerimientos desde el principio, la calidad del
videojuego resultante es alta.
Permite trabajar con personal poco calificado.
Se tiene todo bien organizado
No se mezclan las fases.
Es perfecto para aquellos videojuegos que son rígidos donde se
especifiquen muy bien los requerimientos y se conozcan muy bien las
herramientas a utilizar
Desventajas
La duración de todo el ciclo es muy larga.
Probabilidad alta de fracaso dado que existe poca comunicación con el
usuario final.
El mantenimiento se realiza en el código fuente.
Las revisiones de videojuegos de gran complejidad son muy difíciles.
17
Impone una estructura de gestión de proyectos.
Para que el videojuego tenga éxito deben desarrollarse todas las
iteraciones.
Si se cambia el orden de las fases el videojuego final será de menor
calidad.
Puede producir videojuegos poco llamativos para los jugadores ya que no
se le pueden hacer muchas modificaciones según la marcha.
Inflexibilidad del modelo: dificultad para responder a cambios en los
requerimientos. [8]
Lenguajes de programación
Python
Python es un lenguaje de programación interpretado, orientado a objetos e
interactivo es comparado a Lisp, Tcl, Ruby, Perl, C#, Visual Basic, Visual Fox Pro,
Scheme o Java. Python tiene el poder de una sintaxis muy limpia y clara. Tiene
módulos, clases, excepciones, data types de muy alto nivel y tipado dinámico.
Existe interfaz para hacer llamadas al sistema y librerías. [11]
Python es simple, pero es un lenguaje de programación, es un lenguaje
interpretado que proporciona las siguientes ventajas a los programadores: [12]
Ofrece más apoyo e infraestructura para programas grandes que el
intérprete de órdenes.
Incluye tipos de datos de alto nivel, como matrices flexibles y diccionarios.
18
Tipos de datos más generales, que se pueden aplicar a un rango de
problemas más amplios que Awk o Perl.
Permite dividir el programa en módulos reutilizables desde otros programas
Python.
Posee una gran colección de módulos estándar que se pueden utilizar
como base para programas.
Es ampliable, es decir, se puede añadir alguna nueva funciona en C.
Los programas son más cortos que C o C++.
Estas y otras características son las que hacen que Python sea un lenguaje de
programación idóneo para el desarrollo de videojuegos.
Eclipse
Eclipse es un entorno de desarrollo integrado- IDE (por sus siglas en inglés-
Integrated Development Environment), de código abierto y multiplaforma. [13]. Se
utiliza para desarrollar lo que se conoce como “Aplicaciones de Cliente
enriquecido” y es una potente y completa plataforma de programación, desarrollo y
compilación de elementos tan viariados como sitios web, programas en C++,
aplicaciones Java, entre otros. En este entorno de desarrollo el programador se
encuentra con herramientas y funciones necesarias para realizar el trabajo,
además de una interfaz atractiva permitiendo que sea fácil y agradable de usar.
Utilizar Eclipse trae consigo ventajas, entre las que se encuentran [13]:
El IDE emplea módulos (en inglés plug-in) para proporcionar toda su
funcionabilidad al frente de la plataforma de cliente.
Este mecanismos de modulos es una plataforma ligera para componentes de
software. Se puede extender usando otros lenguas de programación como son
C/C++; también permite trabajar con otros lenguajes para procesado de texto
19
como LaTeX, aplicaciones en red como Telnet y Sistema de gestión de base
de datos.
La arquitectura plug-in permite escribir cualquier extensión deseada en el
ambiente, como sería Gestión de la configuración.
Provee al programador Frameworks para el desarrollo de aplicaciones
gráficas, definición y manipulación de modelos de Software, Aplicaciones web,
entre otras.
El SDK de Eclipse incluye las herramientas de desarrollo de Java.
Esto permite que el uso de Eclipse sea más fácil de usar y por lo tanto más
fácil de programar, en este caso el videojuego.
Pygame
Pygame es un conjunto de módulos que permiten crear videojuego o aplicaciones
graficas (no necesariamente videojuegos) en dos dimensiones. Pygame incluye
gráficos y bibliotecas de sonido diseñados para ser utilizados directamente bajo
Python. Esta construido bajo Simple DirectMedia Layer (SDL), que a su vez son
un conjunto de bibliotecas desarrolladas en lenguaje C, proporcionando las
funciones básicas para realizar operaciones de dibujado 2D, gestión de efectos de
sonido y música, y carga y gestión de imágenes. De esta manera, a través de
Pygame se abstrae la lógica del juego (o aplicación) en sí mismo, haciendo
posible el uso de un lenguaje de alto nivel como Python para estructurar el juego.
[14]
20
Pygame permite la creación y desarrollo de videojuegos de una forma clara y
sencilla, sin que estos impida obtener resultados esperados puesto que puede
combinarse con otras librerías, como PyOpenGl, para incluir gráficos en 3D.
Las características de Pygame son: [15]
Lenguaje de muy alto nivel lo que implica un código claro.
Multiplataforma.
Basado en SDL.
Múltiples usos, juego interfaces gráficas y multimedia.
2D.
21
Capitulo III “Desarrollo del videojuego”
En este capítulo se seguirá el ciclo de vida de cascada pura para la realización del
videojuego, esto garantiza la calidad del videojuego.
Especificación del juego
La idea general de este videojuego es que un jugador se encuentre inmerso en un
pueblo en el cual se aparecerán varios zombies, para los cuales el jugador deberá
matar utilizando armas (adquiridas por la acumulación de puntos obtenidos con la
matanza de estos zombies). Dependiente del número de zombies derrumbados,
este podrá pasar a los siguientes niveles.
Para la realización de este videojuego es necesario seguir rigurosamente cada
una de las fases del ciclo de vida, a continuación se describen cada una de ellas.
La biblia del arte y la historia
En la siguiente tabla se especificaron los conceptos necesarios para definir la
parte artística del videojuego, así como la historia, guion y diseño de los diferentes
escenarios del videojuego, entre otros.
Rubro Descripción
Género Shooters
Jugadores
Modalidad de juego (individual o colectivo). Si, éstos son
humanos o humano contra máquina.
Historia
El jugador se encuentra en las cercanías de un pueblo
donde saldrán varios zombies.
Look and Feel
En esta etapa se analizó todos los bocetos gráficos y
artísticos que contempla el juego, así como la música del
22
juego.
Interfaz de Usuario
Se analizaron los tipos de usuarios entre los que se
encontró que la característica principal es que van dirigidos
hacia jóvenes de cualquier edad con conocimientos
básicos de computación, para ello estas tendrán que ser
vistosas, amigables, intuitivas, consistentes.
Objetivos
Resistir las oleadas de Zombies.
Reglas
Para pasar de nivel tiene que destruir las oleadas de
Zombies; estas oleadas dependen del nivel del juego.
Características
Zombie
Es un personaje que actúa como enemigo en el juego, al
que se le debe de destruir.
Armas
Son una colección de armas, las cuales se deben de
comprar por el jugador y a su vez tiene diferentes
características, cada una de ellas puede ser usada en
cualquier nivel, siempre y cuando se pueda comprar por el
jugador.
Diseño de Niveles
AtaqueZombie, se va a diseñar para 3 niveles, cada uno de
ellos con su nivel de complejidad.
Requerimientos
técnicos
El juego que se diseñara necesitara ser ejecutado en una
computadora de al menos 1 GB en memoria RAM, sistema
operativo Windows XP o superior.
23
A su vez fue necesario, establecer cuál es la lógica del videojuego, esto es:
Inicio del juego
Créditos
Créditos
Nombre del programador
Versión
Mostrar el escenario del
pueblo del nivel 1
Muestra las armas que
puede adquirir el jugador
Mostrar el escenario del
pueblo del nivel 2
24
Nota: Este proceso se repite mientras el jugador desee jugar, y a su vez va
acumulando para la compra de armas.
Una vez terminada la
compra de armas, inicia el
nivel 2
Terminado el nivel 2, se
muestran la venta de
armas
Inicia el nivel 3
25
Especificaciones técnicas
Las especificaciones técnicas en un videojuego permiten realizar tanto el análisis y
diseño del videojuego. En la figura 3.1 se ilustra el diagrama de casos de uso del
videojuego, con sus casos de uso y su actor. El actor que interactúa es el jugador,
es el que juega en el videojuego; los casos de usos son: Iniciar, permite iniciar el
juego Ataque Zombie; Créditos, permite saber quién hizo el videojuego; Comprar,
permite comprar armas para atacar a los Zombies.
Fig. 3. 1 Diagrama de casos de uso del videojuego
Posteriormente una vez identificado las acciones que realizaría el videojuego fue
necesario describir los escenarios, es decir como funcionara cada uno de las
acciones identificadas en el diagrama de caso de uso, es por ello que se utilizaron
los diagramas de secuencia ilustrados en las figuras 3.2, 3.3, 3.4; estos
corresponden a como jugar, como comprar armas y los créditos del videojuego.
Jugador
Comprar
armas
26
Fig. 3. 2 Diagrama de secuencia para Jugar
Fig. 3. 3 Diagrama de secuencia para Comprar armas
27
Fig. 3. 4 Diagrama de secuencia para Créditos
Contando con todos los diagramas de secuencia del videojuego, se procedió al
diseño del diagrama de clases del videojuego, esto se ilustra en la figura 3.5, en
ella se pueden ver las clases: zoombie, mapa, mira, arma, entre otras. En cada
una de las clases fue necesario definir cada uno de sus métodos y sus atributos,
con la finalidad de tener un mejor control y manejo de toda la información del
videojuego y de su jugador.
28
Fig. 3. 5 Diagramas de clases del Videojuego
29
A continuación se diseñaron las interfaces lo que se le conoce como “look and
fell”; estas fueron diseñadas a la medida siempre tomando en cuenta la tarea que
va a realizar, el contexto y el tipo de jugador; a su vez bajo los estándares que
marca la usabilidad: consistencia, facilidad de aprendizaje, tiempo de respuesta,
entre otras, las interfaces resultantes son figuras 3.6, 3.7, 3.8, 3.9. Así mismo se
esbozaron los zombies, objetos y armas necesarias para el videojuego. (Ver
figuras 3.10, 3.11,3.12)
Fig. 3. 6 Interfaz principal Fig. 3. 7 Interfaz créditos
Fig. 3. 8 Interfaz de venta de armas y cargadores
30
Fig. 3. 9 Interfaces del pueblo según el nivel
31
Zombies Lado A Lado B
Fig. 3. 10 Zombies para el videojuego
Objetos Bala Mira Bolsa de dinero
Cargador Flecha
Fig. 3. 11 Objetos del videojuego
Bar Colt
Kar 98 M1 Garand
Armas MP 40
STG 44
Thompson
Fig. 3. 12 Armas para derrotar a los zombies
32
Construcción
En esta fase del construcción del videojuego se muestra parte de la programación
que se realizó: creación del mapa, creación de un zombie, venta de armas, entre
otros códigos, para realizar cada uno de ellos se consideró el formato en el código,
el nombre de las variables, los comentarios y el encabezado como normas básicas
para la realización del código apegándose a las reglas de calidad.
Código del mapa
@author: ANGY //Programador: Bernardo Chaparro //Clase para realizar un mapa //Noviembre del 2014 // Versión 1.1 ''' import pygame class Mapa( pygame.sprite.Sprite ): def __init__( self ): pygame.sprite.Sprite.__init__( self ) self.mapas = [ "imagenes/fondos/fondo_desierto.png" , "imagenes/fondos/fondo_desierto_2.png" , "imagenes/fondos/fondo_cammino.png" ] self.nivel = pygame.image.load( self.mapas[ 0 ] ) self.rectangulo_mapa = self.nivel.get_rect(); self.indice = 0 def siguiente_mapa( self , avanzo ): if avanzo and self.indice < 2: self.indice += 1 self.cargar_imagen( self.indice ) def cargar_imagen( self , indice ): self.nivel = pygame.image.load( self.mapas[ self.indice ] ) def dibujar( self , pantalla ): pantalla.blit( self.nivel , self.rectangulo_mapa )
33
Código para crear un zombie
@author: SPARTAN-117 //Programador: Bernardo Chaparro //Clase para crear Zombies //Noviembre del 2014 // Versión 1.1 ''' import pygame , random from pygame.locals import * class Zombies( pygame.sprite.Sprite ): def __init__( self , vida , pts , dinero ): pygame.sprite.Sprite.__init__( self ) self.imagen_derecha_0 = pygame.image.load( "imagenes/zombies/zombies_0.png" ) self.imagen_derecha_1 = pygame.image.load( "imagenes/zombies/zombies_1.png" ) self.imagen_derecha_2 = pygame.image.load( "imagenes/zombies/zombies_2.png" ) self.imagen_izquierda_0 = pygame.image.load( "imagenes/zombies/zombies_0.png" ) self.imagen_izquierda_1 = pygame.image.load( "imagenes/zombies/zombies_1.png" ) self.imagen_izquierda_2 = pygame.image.load( "imagenes/zombies/zombies_2.png" ) self.lista_imagenes = [ [ self.imagen_derecha_0 , self.imagen_derecha_1 , self.imagen_derecha_2 ] , [ self.imagen_izquierda_0 , self.imagen_izquierda_1 , self.imagen_izquierda_2 ] ] self.imagen_actual = 0 self.siguiente_imagen = self.lista_imagenes[ self.imagen_actual ][ 0 ] self.rectangulo = self.siguiente_imagen.get_rect() self.rectangulo.left = random.randrange( 0 , 500 ) self.rectangulo.top = random.randrange( -100 , -10 ) self.lista_rectamgulos = [ pygame.rect.Rect( ( self.rectangulo.left + 8 , self.rectangulo.top + 3 ) , ( 10 , 10 ) ) , pygame.rect.Rect( ( self.rectangulo.left + 8 , self.rectangulo.top + 15 ) , ( 10 , 15 ) ) , pygame.rect.Rect( ( self.rectangulo.left + 8 , self.rectangulo.top + 33 ) , ( 10 , 13 ) ) , pygame.rect.Rect( ( self.rectangulo.left + 1 , self.rectangulo.top + 17 ) , ( 6 , 6 ) ) , pygame.rect.Rect( ( self.rectangulo.left +20 , self.rectangulo.top + 17 ) , ( 6 , 6 ) ) ] self.orientacion = 0 self.puntos = pts self.dinero = dinero self.vida = vida self.retardo = 0 def mover_zombies( self , velocidad): for rectangulo in self.lista_rectamgulos: rectangulo.move_ip( 0 , velocidad )
34
self.rectangulo.move_ip( 0 , velocidad ) def danos( self , dano ): self.vida -= dano def animacion( self ): if self.retardo <= 3: self.retardo += 1 else: self.siguiente_imagen = self.lista_imagenes[ self.orientacion ][ self.imagen_actual ] self.proxima_imagen() self.retardo = 0 def proxima_imagen( self ): self.imagen_actual += 1 if ( self.imagen_actual > ( len( self.lista_imagenes ) - 1 ) and ( self.orientacion == 0 ) ): self.imagen_actual = 0 self.orientacion = 1 elif ( self.imagen_actual > ( len( self.lista_imagenes ) - 1 ) and ( self.orientacion == 1 ) ): self.imagen_actual = 0 self.orientacion = 0 def sonido_zombie( self ): if random.randrange( 0 , 400 ) == 200: sonido = pygame.mixer.Sound( "sonidos/audio_zombie.wav" ) sonido.play() def dibujar( self , pantalla ): pantalla.blit( self.siguiente_imagen , self.rectangulo ) '''for rectangulo in self.lista_rectamgulos: pygame.draw.rect( pantalla , ( 150 , 100 , 80 ) , rectangulo )''' def getPuntos( self ): return self.puntos def getDinero( self ): return self.dinero def getVida( self ): return self.vida def getLista_rectangulos( self ): return self.lista_rectamgulos
35
Código principal @author: SPARTAN-117 //Programador: Bernardo Chaparro //Main //Noviembre del 2014 // Versión 1.1 ''' import sys , pygame , random from pygame.locals import * from Mapa import Mapa from Mira import Mira from Zombies import Zombies from Colt import Colt from Kar_98 import Kar_98 from M1_Garand import M1_Garand from MP_40 import MP_40 from Thompson import Thompson from STG_44 import STG_44 from Bar import Bar ANCHO = 800 ALTO = 650 COLOR = ( 255 , 255 , 255 ) kar_98 = { "arma" : False , "cargador" : 0 , "precio_arma" : 2000 , "precio_cargador" : 100 } m1_garand = { "arma" : False , "cargador" : 0 , "precio_arma" : 4000 , "precio_cargador" : 200 } mp40 = { "arma" : False , "cargador" : 0 , "precio_arma" : 6000 , "precio_cargador" : 300 } thompson = { "arma" : False , "cargador" : 0 , "precio_arma" : 8000 , "precio_cargador" : 400 } stg44 = { "arma" : False , "cargador" : 0 , "precio_arma" : 10000 , "precio_cargador" : 500 } bar_cal30 = { "arma" : False , "cargador" : 0 , "precio_arma" : 12000 , "precio_cargador" : 600 } MOCHILA = [ kar_98 , m1_garand , mp40 , thompson , stg44 , bar_cal30 ] dinero = 0 cargador = 0 PANTALLA = pygame.display.set_mode( ( ANCHO , ALTO ) ) pygame.display.set_caption( "Ataque Zombies" ) RELOJ = pygame.time.Clock() #Funcion para colocar texto def texto(texto, posx, posy, color=(255, 0, 0)): fuente = pygame.font.Font("Fuente/CHILLER.ttf", 20) salida = pygame.font.Font.render(fuente, texto, 0, color) salida_rect = salida.get_rect() salida_rect.centerx = posx salida_rect.centery = posy return salida, salida_rect
36
def menu(): salir = False OPCION = 0 fondo_menu = pygame.image.load( "imagenes/fondos/fondo_menu.png" ) cursor = pygame.image.load( "imagenes/cursor.png" ) sonido_cursor = pygame.mixer.Sound( "sonidos/blip6.wav" ) cursor_x = 150 cursor_y = 280 while salir == False: for evento in pygame.event.get(): if evento.type == pygame.QUIT: sys.exit( 1 ) elif evento.type == pygame.KEYDOWN: if evento.key == pygame.K_UP and cursor_y >= 400: OPCION = 1 cursor_y -= 120 sonido_cursor.play() elif evento.key == pygame.K_DOWN and cursor_y <= 280: OPCION = 2 cursor_y += 120 sonido_cursor.play() elif evento.key == pygame.K_RETURN: salir = True PANTALLA.blit( fondo_menu , ( 0 , 0 ) ) PANTALLA.blit( cursor , ( cursor_x , cursor_y ) ) RELOJ.tick( 20 ) pygame.display.update() return OPCION def creditos(): salir = False fondo_creditos = pygame.image.load( "imagenes/fondos/fondo_creditos.png" ) while salir == False: for evento in pygame.event.get(): if evento.type == pygame.QUIT: sys.exit( 1 ) elif evento.type == pygame.KEYDOWN: if evento.key == pygame.K_RETURN: salir = True PANTALLA.blit( fondo_creditos , ( 0 , 0 ) ) RELOJ.tick( 20 ) pygame.display.update()
37
def Venta_Armas( ): salir = False curso = pygame.image.load( "imagenes/cursor_armas.png" ) fondo_venta_armas = pygame.image.load( "imagenes/fondos/fondo_venta_armas.png" ) sonido_cursor = pygame.mixer.Sound( "sonidos/efectos/LTTP_Menu_Cursor.wav" ) sonido_error = pygame.mixer.Sound( "sonidos/efectos/LTTP_Error.wav" ) sonido_comprar = pygame.mixer.Sound( "sonidos/efectos/LTTP_Rupee2.wav" ) cursor_x = 15 cursor_y = 235 global dinero x = 255 y = 292 while salir == False: for evento in pygame.event.get(): if evento.type == pygame.QUIT: sys.exit( 1 ) elif evento.type == pygame.KEYDOWN: if evento.key == pygame.K_RIGHT: if cursor_x <= 500: cursor_x += 265 sonido_cursor.play() elif evento.key == pygame.K_LEFT: if cursor_x > 15: cursor_x -= 265 sonido_cursor.play() elif evento.key == pygame.K_DOWN: if cursor_y == 280: cursor_y += 180 sonido_cursor.play() elif cursor_y < 505: cursor_y += 45 sonido_cursor.play() elif evento.key == pygame.K_UP: if cursor_y == 460: cursor_y -= 180 sonido_cursor.play() elif cursor_y > 235: cursor_y -= 45 sonido_cursor.play() elif evento.key == pygame.K_c: if dinero > 0: if cursor_x == 15 and cursor_y == 235: if MOCHILA[ 0 ][ "arma" ] == False: if dinero >= MOCHILA[ 0 ][ "precio_arma" ]:#arma kar 98 MOCHILA[ 0 ][ "arma" ] = True precio = MOCHILA[ 0 ][ "precio_arma" ] dinero -= precio sonido_comprar.play() else:
38
sonido_error.play() elif cursor_x == 15 and cursor_y == 280:#cargador kar 98 if dinero >= MOCHILA[ 0 ][ "precio_cargador" ]: cargador = MOCHILA[ 0 ][ "cargador" ] cargador += 1 MOCHILA[ 0 ][ "cargador" ] = cargador precio = MOCHILA[ 0 ][ "precio_cargador" ] dinero -= precio sonido_comprar.play() else: sonido_error.play() elif cursor_x == 280 and cursor_y == 235: if MOCHILA[ 1 ][ "arma" ] == False:# arma m1 garand if dinero >= MOCHILA[ 1 ][ "precio_arma" ]: MOCHILA[ 1 ][ "arma" ] = True precio = MOCHILA[ 1 ][ "precio_arma" ] dinero -= precio sonido_comprar.play() else: sonido_error.play() elif cursor_x == 280 and cursor_y == 280:#cargador m1 garand if dinero >= MOCHILA[ 1 ][ "precio_cargador" ]: cargador = MOCHILA[ 1 ][ "cargador" ] cargador += 1 MOCHILA[ 1 ][ "cargador" ] = cargador precio = MOCHILA[ 1 ][ "precio_cargador" ] dinero -= precio sonido_comprar.play() else: sonido_error.play() elif cursor_x == 545 and cursor_y == 235:# arma mp40 if MOCHILA[ 2 ][ "arma" ] == False: if dinero >= MOCHILA[ 2 ][ "precio_arma" ]: MOCHILA[ 2 ][ "arma" ] = True precio = MOCHILA[ 2 ][ "precio_arma" ] dinero -= precio sonido_comprar.play() else: sonido_error.play() elif cursor_x == 545 and cursor_y == 280:#cargador mp40 if dinero >= MOCHILA[ 2 ][ "precio_cargador" ]: cargador = MOCHILA[ 2 ][ "cargador" ] cargador += 1 MOCHILA[ 2 ][ "cargador" ] = cargador precio = MOCHILA[ 2 ][ "precio_cargador" ] dinero -= precio sonido_comprar.play() else: sonido_error.play() elif cursor_x == 15 and cursor_y == 460:#arma thompson if MOCHILA[ 3 ][ "arma" ] == False: if dinero >= MOCHILA[ 3 ][ "precio_arma" ]: MOCHILA[ 3 ][ "arma" ] = True
39
precio = MOCHILA[ 3 ][ "precio_arma" ] dinero -= precio sonido_comprar.play() else: sonido_error.play() elif cursor_x == 15 and cursor_y == 505:#cargador thompson if dinero >= MOCHILA[ 3 ][ "precio_cargador" ]: cargador = MOCHILA[ 3 ][ "cargador" ] cargador += 1 MOCHILA[ 3 ][ "cargador" ] = cargador precio = MOCHILA[ 3 ][ "precio_cargador" ] dinero -= precio sonido_comprar.play() else: sonido_error.play() elif cursor_x == 280 and cursor_y == 460:# arma stg44 if MOCHILA[ 4 ][ "arma" ] == False: if dinero >= MOCHILA[ 4 ][ "precio_arma" ]: MOCHILA[ 4 ][ "arma" ] = True precio = MOCHILA[ 4 ][ "precio_arma" ] dinero -= precio sonido_comprar.play() else: sonido_error.play() elif cursor_x == 280 and cursor_y == 505:#cargador stg44 if dinero >= MOCHILA[ 4 ][ "precio_cargador" ]: cargador = MOCHILA[ 4 ][ "cargador" ] cargador += 1 MOCHILA[ 4 ][ "cargador" ] = cargador precio = MOCHILA[ 4 ][ "precio_cargador" ] dinero -= precio sonido_comprar.play() else: sonido_error.play() elif cursor_x == 545 and cursor_y == 460:# arma bar cal .30 if MOCHILA[ 5 ][ "arma" ] == False: if dinero >= MOCHILA[ 5 ][ "precio_arma" ]: MOCHILA[ 5 ][ "arma" ] = True precio = MOCHILA[ 5 ][ "precio_arma" ] dinero -= precio sonido_comprar.play() else: sonido_error.play() elif cursor_x == 545 and cursor_y == 505:#cargador bar cal .30 if dinero >= MOCHILA[ 5 ][ "precio_cargador" ]: cargador = MOCHILA[ 5 ][ "cargador" ] cargador += 1 MOCHILA[ 5 ][ "cargador" ] = cargador precio = MOCHILA[ 5 ][ "precio_cargador" ] dinero -= precio sonido_comprar.play() else: sonido_error.play() else:
40
sonido_error.play() elif evento.key == pygame.K_RETURN: salir = True texto_dinero , rectangulo_dinero = texto( str( dinero ) , 670 , 630 ) PANTALLA.blit( fondo_venta_armas , ( 0 , 0 ) ) PANTALLA.blit( curso , ( cursor_x , cursor_y ) ) PANTALLA.blit( texto_dinero , rectangulo_dinero ) '''Para obtener la cantidad de cargadores que tiene cada arma''' for total_cargador in range( 6 ): numero , rectangulo_numero = texto( str( MOCHILA[ total_cargador ][ "cargador" ] ) , x , y ) PANTALLA.blit( numero , rectangulo_numero ) x += 250 if total_cargador == 2: x = 255 y += 245 x = 255 y = 292 RELOJ.tick( 20 ) pygame.display.update() def main( ): global dinero nivel = Mapa() mira = Mira() colt = Colt( 250 , 550 , 100 , 8 ) kar98 = Kar_98( 250 , 530 , 150 , 5 ) m1_garand = M1_Garand( 250 , 530 , 150 , 8 ) mp40 = MP_40( 250 , 550 , 180 , 30 ) thompson = Thompson( 250 , 520 , 180 , 30 ) stg44 = STG_44( 250 , 550 , 70 , 32 ) bar = Bar( 250 , 530 , 80 , 20 ) panel = pygame.image.load( "imagenes/panel.png") imagen_dinero = pygame.image.load( "imagenes/bolsa_dinero.png" ) imagen_puntos = pygame.image.load( "imagenes/puntos.png" ) imagen_cargador = pygame.image.load( "imagenes/cargador.png" ) bala = pygame.image.load( "imagenes/bala.png" ) bala_rectangulo = bala.get_rect() bala_rectangulo.x = 450 bala_rectangulo.y = 520 pygame.mixer.music.load( "sonidos/7_Midnight Wandering.ogg" ) sonido_kar98_vacia = pygame.mixer.Sound( "sonidos/armas/kar_98/kar98_reload_loop.wav" ) sonido_impacto_bala_suelo = pygame.mixer.Sound( "sonidos/impactos/Impact_Dirt_20.wav" )
41
pygame.mouse.set_visible( True ) salir_a = False game_over = False lista_zombies = [] armas = [ colt , kar98 , m1_garand , mp40 , thompson , stg44 , bar ] tiempo = kar98.getTiempo_retardo() indice = 0 puntos = 0 tiempo_pasado_segundos = 0 siguiente_arma = 0 equipar = armas[ siguiente_arma ] '''Genera los primeros zombies''' for monstruo in range( 4 ): zombie = Zombies( 200 , 25 , 50 ) lista_zombies.append( zombie ) while game_over == False: genera_zombie_queden = random.randint( 1 , 2 ) numero_oleadas_zombies = random.randint( 2 , 2 ) print genera_zombie_queden , numero_oleadas_zombies pygame.mixer.music.set_volume( 0.4 ) pygame.mixer.music.play( -1 ) while salir_a == False: mira.posicionar_mouse_mitad_imagen() for evento in pygame.event.get(): ( clic_derecho , scroll , clic_izquierdo ) = pygame.mouse.get_pressed() if evento.type == pygame.QUIT: sys.exit( 1 ) if evento.type == pygame.KEYDOWN:#Para cambiar de arma presionando las teclas 1 , 2, 3 , 4 ,5 , 6 if evento.key == pygame.K_1: siguiente_arma = 0 if MOCHILA[ siguiente_arma ]["arma"]: equipar = armas[ 1 ] elif evento.key == pygame.K_2: siguiente_arma = 1 if MOCHILA[ siguiente_arma ]["arma"]: equipar = armas[ 2 ] elif evento.key == pygame.K_3: siguiente_arma = 2 if MOCHILA[ siguiente_arma ]["arma"]: equipar = armas[ 3 ]
42
elif evento.key == pygame.K_4: siguiente_arma = 3 if MOCHILA[ siguiente_arma ]["arma"]: equipar = armas[ 4 ] elif evento.key == pygame.K_5: siguiente_arma = 4 if MOCHILA[ siguiente_arma ]["arma"]: equipar = armas[ 5 ] elif evento.key == pygame.K_6: siguiente_arma = 5 if MOCHILA[ siguiente_arma ]["arma"]: equipar = armas[ 6 ] elif evento.key == pygame.K_r:#Recarga el arma if equipar.getNombre() == "Colt": equipar.setNumero_balas( 8 ) elif MOCHILA[ siguiente_arma ][ "cargador" ] > 0: equipar.efecto_sonido_recargar() total_cargador = MOCHILA[ siguiente_arma ][ "cargador" ] total_cargador -= 1 MOCHILA[ siguiente_arma ][ "cargador" ] = total_cargador equipar.setNumero_balas( equipar.getCantidad_balas() ) elif clic_derecho == 1 and tiempo >= equipar.getTiempo_retardo(): if equipar.getNumero_balas() > 0:#Si toda via tenemos balas equipar.efecto_sonido_disparar() '''Se recorre cada imagen del zombie y cada rectangulo que lo compone para determinar con que rectangulo choco el rectangulo de la mira''' for muerto in lista_zombies: for rectan in muerto.getLista_rectangulos(): if rectan.colliderect( mira.getRectangulo() ): numero1 = mira.getRectangulo().collidelist( muerto.getLista_rectangulos() ) if numero1 == 0: muerto.danos( equipar.getDano() ) elif numero1 == 1: muerto.danos( equipar.getDano() / 2 ) elif numero1 == 2: muerto.danos( equipar.getDano() / 3 ) elif numero1 == 3 or numero1 == 4: muerto.danos( equipar.getDano() / 5 ) if muerto.getVida() <= 0: lista_zombies.pop( indice ) puntos += muerto.getPuntos() dinero += muerto.getDinero() break indice += 1 indice = 0 tiempo = 0 equipar.disparar() else:
43
sonido_kar98_vacia.play() '''Es el tiempo de retardo que tiene el arma entre cada disparo''' tiempo += 1 '''Transforma el texto con el tipo de letra establecido''' texto_dinero , rectangulo_dinero = texto( str( dinero ) , 120 , 600 ) texto_puntos , rectangulo_puntos = texto( str( puntos ) , 120 , 560 ) if equipar.getNombre() == "Colt": texto_total_cargador , rectangulo_cargador = texto( "0" , 290 , 600 ) elif MOCHILA[ siguiente_arma ]["arma"]: texto_total_cargador , rectangulo_cargador = texto( str( MOCHILA[ siguiente_arma ][ "cargador" ] ) , 290 , 600 ) '''Desplaza a los zombies por la pantalla''' for monstruo in lista_zombies: monstruo.animacion() if monstruo.rectangulo.bottom < 520: monstruo.mover_zombies( tiempo_pasado_segundos * random.randrange( 20 , 50 ) ) monstruo.sonido_zombie() else: game_over = True salir_a = True if numero_oleadas_zombies > 0: '''Genera nuevos zombies cada vez que no haya mas en la pantalla''' if len( lista_zombies ) == genera_zombie_queden: numero_oleadas_zombies -= 1 for monstruo in range( 4 ): zombie = Zombies( 100 , 25 , 50 ) lista_zombies.append( zombie ) else: salir_a = True nivel.dibujar( PANTALLA ) PANTALLA.blit( panel , ( 0 , 520 ) ) PANTALLA.blit( imagen_dinero , ( 20 , 580 ) ) PANTALLA.blit( imagen_puntos , ( 20 , 550 ) ) PANTALLA.blit( texto_puntos , rectangulo_puntos ) PANTALLA.blit( texto_dinero , rectangulo_dinero ) PANTALLA.blit( imagen_cargador , ( 250 , 580 ) ) PANTALLA.blit( texto_total_cargador , rectangulo_cargador ) equipar.dibujar( PANTALLA ) for monstruo in lista_zombies: monstruo.dibujar( PANTALLA ) mira.dibujar( PANTALLA ) '''Dibuja las balas en pantalla si el total de balas es mayor a 5 se dibuja la mitad en una linea y la otra parte en otra linea''' for proyectil in range( equipar.getNumero_balas() ): PANTALLA.blit( bala , ( bala_rectangulo ) ) bala_rectangulo.x += 12
44
if proyectil == ( ( equipar.getNumero_balas() / 2 ) - 1 ): bala_rectangulo.y += 40 bala_rectangulo.x = 450 bala_rectangulo.x = 450 bala_rectangulo.y = 530 pygame.display.update() '''Tiempo que tarda en dibujarse la pantalla''' tiempo_pasado = RELOJ.tick( 20 ) tiempo_pasado_segundos = tiempo_pasado / 1000.0 pygame.mixer.music.stop() if game_over <> True: Venta_Armas()#Obtenemos todas las armas que podemos comprar salir_a = False nivel.siguiente_mapa( True ) else: fin_juego = pygame.image.load( "imagenes/game_over_1.png" ) terminar = False while not terminar: for evento in pygame.event.get(): if evento.type == pygame.QUIT: sys.exit(1) if evento.type == pygame.KEYDOWN: if evento.key == pygame.K_RETURN: terminar = True PANTALLA.blit( fin_juego , ( 250 , 200 ) ) RELOJ.tick( 20 ) pygame.display.update() if __name__ == '__main__': pygame.init() while True: OPCION = menu( ) if OPCION == 1: main() else: creditos()
45
Aseguramiento de calidad
Este videojuego se realizaron pruebas de caja blanca, las cuales consistieron en
realizar de acuerdo a la complejidad ciclomática un conjunto de casos de pruebas
y así ir perfeccionando el funcionamiento del videojuego; con la finalidad de
asegurarse que todas las sentencias y condiciones se ejecutaran al menos una
vez.
Pruebas de juego
El videojuego se sometió a procesos de prueba por parte del programador,
maestros y estudiantes antes de ser liberado, con la finalidad de que se realizara
una retroalimentación en caso de que existiera algo que mejorar del videojuego
con la finalidad de obtener un videojuego de calidad.
Pruebas alfa
El videojuego fue evaluador por un grupo de jóvenes con la finalidad de determinar
su calidad y/o encontrar errores y poder solucionarlos. Es importante hacer
mención que a los estudiantes le pareció un juego divertido, que no modificaron su
manera de jugar y que los comentarios vertidos por parte de ellos fueron
favorables, es por ello que se procedió a realizar las pruebas beta, las cuales
permitieron liberar el videojuego para la población en general.
Golden master
Es importante mencionar que el videojuego esta liberado para su juego.
46
Capitulo IV “Breve recorrido por el videojuego”
A continuación se dará un breve recorrido por las interfaces del videojuego
“Ataque Zombies”.
Iniciar el juego
Al ejecutar el icono del videojuego se inicia con una interfaz inicial, - ver figura 4.1
– la cual muestra las opciones principales de iniciar y créditos.
Fig. 4. 1 Interfaz inicial del videojuego
47
La opción Iniciar, permite al jugador iniciar el juego; mientras la opción créditos,
muestra el nombre de los desarrolladores del videojuego. El jugador puede elegir
cualquiera de las dos opciones solo desplazándose mediante el cursor hacia
arriba o hacia abajo, esto utilizando las flechas del teclado; para seleccionar
cualquier opción es necesario que el jugador presione la tecla Enter.
Head-Up Displays (HUD)
Se llama HUD (del inglés: "Heads-Up Display") a la información que en todo
momento se muestra en interfaz durante la partida, generalmente en forma de
iconos y números. (ver figura 4.2)
Fig. 4. 2 Interfaz del videojuego
48
En HUD se ilustra la interfaz representativa del pueblo en donde llegan los
Zombies, en la parte inferior de ella, específicamente en el recuadro gris se
encuentran las siguientes opciones: (ver figura 4.2)
Núm. Nombre Descripción
1 Puntos Indica el total de puntos acumulados por cada Zoombie que
el jugador elimine.
2 Acumulador
de Dinero
Indica el total del dinero que se va acumulando por cada
Zoombie que el jugador elimine y que es necesario para que
compre armas y municiones en el inventario de armas.
3 Cargador Muestra en el cargador del arma que el jugador está
utilizando para eliminar a los Zoombies.
4 Cantidad de
cargador
Muestra el total de cargadores que se lleva por cada arma
que utilice el jugador.
5 Tipo de
arma
Muestra el arma (imagen) que está usando el jugador para
eliminar a los Zoombies.
6 Municiones Muestra la cantidad de municiones que puede llevar el
cargador.
Conforme el jugador dispare se va disminuyendo hasta
cuando las balas lleguen a 0.
A la cantidad de cargadores se le resta 1, siempre y cuando
lleve más cargadores, en caso de ya no contar con más
cargadores estos ya no se muestran.
49
Inventario de armas
El inventario de armas muestra al jugador que armas puede comprar, cuál es su
costo y su cargador. En la figura 4.3 se ilustran las armas disponibles en el
videojuego.
Fig. 4. 3 Interfaz de armas del videojuego
En el inventario de armas se podrá comprar cada una de las armas disponibles
para eliminar Zoombies, a su vez el respectivo cargador. Este inventario aparecerá
cada vez que se termine un nivel del videojuego. Cada una de las armas tiene un
valor así como también su respectivo cargador.
50
Para poder comprar un arma o un cargador debe de contar con cierta cantidad de
dinero acumulado en cada uno de los juegos – ver fig. 4.3 – cada arma y/o
cargador tiene su costo debajo de él.
Para saber la cantidad de dinero acumulado durante la partida, se observara en la
parte inferior izquierda de la pantalla – ver fig. 4.3 – la imagen de una bolsa de
dinero con el cual se podrá saber la cantidad de dinero disponible.
El realizar una compra de un arma o un cargador es tan sencillo como solo tener
que desplazar la flecha de color rojo con gris mediante las “Flechas direccionales”
del teclado (ver figura 4.4 – controles de juego).
Una vez que seleccione el arma o cargador que se va a comprar, se presionara la
tecla C del teclado. Luego de haber terminado la compra o que el dinero ya no
alcance para comprar más, se presiona la tecla Enter del teclado para regresar al
siguiente nivel del juego.
Controles del Juego
Para tener un mejor manejo en el videojuego es necesario tener el conocimiento
del conjunto de teclas que permiten logar un dominio en el videojuego. El la figura
4.4 se ilustra un teclado de una computadora convencional en el cual están
resaltadas las teclas con color gris. A continuación se describen cuál es su
funcionamiento mediante una tabla.
51
Fig. 4. 4 Teclas de control del videojuego
Imagen Nombre Descripción
Flechas
direccionales
Permiten desplazarse por las diferentes opciones.
Enter
Selecciona una opción del Menú principal y
para salir de la venta de Inventarios de
Armas.
1 , 2 , 3 , 4 ,
5 , 6
Permiten desplazarse por las diferentes
armas.
(Estas tienen que estar compradas antes
para poder utilizarse )
C
Efectúa la compra dentro del inventario de
armas.
R
Recarga el arma.
52
Gameplay
Al inicio del juego nos encontramos en el Menú principal, el cual consta de 2
opciones a elegir: Jugar y Créditos. Para poder elegir algunas de las opciones, el
jugador deberá presionar las flechas del teclado para desplazarse hacia arriba o
hacia abajo y posteriormente presionar la tecla Enter para confirmar la opción
seleccionada.
Si se elige la opción de Créditos nos aparece una ventana con un poco de
información, por ejemplo: desarrollador, audio, imágenes y director. Para regresar
al Menú principal solo basta con presionar la tecla Enter de nuevo.
Ahora si el jugador elige Jugar, la pantalla cambia al primer nivel del juego en el
cual muestra un Panel el cual tiene la información de dinero acumulado, puntos
acumulados, arma elegida, total de cargadores, y la cantidad de balas que puede
llevar cada cargador.
También se ilustra una mira que será controlado por medio del ratón, el cual
también permitirá efectuar disparos presionando el botón izquierdo del ratón. Cada
vez que se haga un disparo en el panel, se observara como las balas se van
disminuyendo hasta que este quede vacío, una vez vació el cargador (que no
haya más balas dibujadas) si, se intenta disparar este reproducirá un sonido
indicando que el arma esta descargada. Por lo que el jugador tendrá que presionar
la tecla R para recargar el arma. Y cada vez que se recargue el arma, el contador
de cargadores disminuyera en 1 y las balas se volverán a dibujar. Si el usuario
utiliza todos los cargadores este ya no podrá recargar más.
Los enemigos saldrán desde la parte superior de la ventana y al azar obtendrán
sus posiciones en el eje X y Y. También saldrán en grupos de 10 y serán por
oleadas en cada nivel, en donde al azar se especificara el número de oleadas para
cambiar de ventana.
53
El cuerpo del zombie se divide en 4 partes: cabeza, pecho, piernas y manos. Que
dependiendo en donde sufran daño se le ira retirando puntos de sangre, si el
disparo es en la cabeza estos desaparecerán instantáneamente de la pantalla. Y
por cada zombie abatido obtendrás puntos y dinero. Si algunos de los zombies
tocan la parte del Panel el juego termina.
Para comprar armas primero el jugador deberá de derrotar a todas las oleadas de
zombies. Una vez hecho esto la pantalla cambiara a Venta de Armas en donde se
observaran las armas disponibles a comprar con su precio, los cargadores y su
precio así como el total de cargadores que lleva el usuario en ese momento y la
cantidad de dinero que acumulo en el nivel. Podrá elegir el arma a comprar por
medio de las flechas del teclado para poder mover el cursor. Para poder realizar la
compra se deberá de tener la cantidad de dinero especificado debajo de cada
dibujo de arma o de cargador y posteriormente presionar la tecla C. Si el jugador
no cuenta con el suficiente dinero se reproducirá un sonido de error indicándole
que no se puede comprar debido a falta de dinero. Cuando el jugador haga una
compra de Arma se reproducirá el sonido indicando que si se pudo comprar el
arma elegida y se verá como decremento su dinero. Cada vez que se compre un
arma este no se podrá volver a comprar, en caso de que el jugador decida volver a
comprar un arma que ya tiene se reproducirá el sonido de error. Para la compra de
cargador, cada vez que se compre uno, en la cantidad de cargadores aumentara
indicándole al jugador que se compró dicho cargador seleccionado (este se
sumara con los cargadores que ya tenía de esa arma), cada cargador es
independiente por lo que podrá tener cargadores para cada arma, en caso de que
no tenga ninguna arma comprada aun así podrá llevarse los cargadores que
pueda comprar, teniendo en cuenta que no podrá utilizarlos hasta que se compre
el arma.
Una vez hecha la compra no se podrá deshacer de esta. Después de terminar la
comprar, para regresar al juego solo es necesario presionar la tecla Enter.
54
Una vez pasado por la sección de Ventas de Armas, se verá el cambio de nivel
informando al jugador el paso de nivel. Para utilizar las armas compradas se
deberá de presionar las teclas del 1 al 6 (dependiendo de las armas que tenga son
las que podrá usar). Cada vez que se presione las teclas 1 – 6 en el panel se
mostrara el cambio de arma y de cargador, mostrando de igual manera el total de
cargadores que se tiene de esa arma. Y así es como se podrá cambiar de arma.
Una vez que se haga el cambio de arma, el arma principal que llevaba tipo Colt ya
no se podrá utilizar durante todo lo que dure el juego.
Si el jugador pierde, se regresara a la ventana de Menú principal y todo lo que
llevaba se perderá teniendo que volver a comenzar.
55
Capítulo V “Resultado y conclusiones”
Resultados
El principal resultado es el videojuego “Ataque Zombie”, este videojuego presenta
una interfaz amigable lo que lo hace muy fácil de jugar a cualquier persona. Este
videojuego es resultado de los conocimientos adquiridos durante mi carrera
profesional específicamente de la asignatura de Ingeniería de Software, a través
del ciclo de vida y UML para garantizar un producto de software de calidad; a su
vez es importante mencionar que la formación recibida permitió poder conocer
nuevas herramientas de programación que permitieron aprender nuevos lenguajes
de programación como Python y Pygame no visto en la carrera y así fijar la meta
de la realización del videojuego.
Conclusiones
A través del desarrollo de esta tesis, se mostró como es importante seguir una
metodología específica para el desarrollo de videojuego, esto por medio de cada
una de las fases que comprende el ciclo de vida y la importancia de la Ingeniería
de Software para garantizar la calidad del videojuego.
56
Bibliografía
[1] “Los videojuegos en el proceso de aprendizaje”, consultado el día 8 de
diciembre de 2014 en:
http://www.colombiadigital.net/opinion/columnistas/conexion/item/1914-los-
videojuegos-en-el-proceso-de-aprendizaje.html
[2] Rodríguez-Hoyos Carlos, Joao Gomes María, “Videojuegos y Educación:
una visión panorámica de las investigaciones desarrolladas a nivel
internacional”, Revista de currículum y formación del profesorado, Vol. 17,
No. 2, 2013, pp. 479-494.
[3] “Videojuegos”, consultado el 10 de diciembre del 2014 en:
http://es.wikipedia.org/wiki/Videojuego
[4] Gifford B.R. “The learning society: Serious play”. Chronicle of Higher
Education; 7. 1991.
[5] Roger S. Pressman. Ingeniería del Software. Un Enfoque Práctico.
Editorial .Graw Hill. 5ta. ed. México.2002
[6] IEEE. IEEE Standards Collection: Software Enginieering 610.12-19
1993
[7] Python, consultado el 15 de diciembre del 2014 en:
http://es.wikipedia.org/wiki/Python
[8] Pygame, consultado el 17 de diciembre del 2014 en :
http://sabia.tic.udc.es/gc/Contenidos%20adicionales/trabajos/Programacion
VideoJuegos/PyGame/pygame.html
57
[9] Craig Larman. UML y Patrones. Introducción al análisis y diseño
orientado a objetos. Ed. Prentice Hall. 1ra.ed. México.1999
[10] Ciclo de vida del software, consultado 14 de diciembre de 2014 en:
http://es.kioskea.net/contents/223-ciclo-de-vida-del-software
[11] Python, consultado 10 de diciembre del 2014 en: www.python.org
[12] Guía de aprendizaje de Python, consultado 10 de diciembre del 2014,
en: programación.net/articulo/guía_de_aprendizaje_de_python_65
[13] EcuRed, conocimiento para todos y con todos, portal web- articulo:
Eclipse, entorno de desarrollo integrado. Consultado 12 de diciembre del
2014, en: www.ecured.cu/index.php/Eclipse,_entorno_de
_desarrollo_integrado
[14] ¿Qué es Pygame?, articulo consultado 12 de diciembre del 2014 en:
www.linuxhispano.net/2010/introduccion-a-pygame-programacion-avanzada
[15] Pygame, consultado el 12 de diciembre del 2014, en:
sabia.tic.udc.es/gc/Contenidosadicionales/trabajos/ProgramacionVideoJueg
os/Pygame/Pygame.html
