documento final (flappy )
TRANSCRIPT
John Basantes (Investigador)
Héctor Cáceres (Digitador)
Víctor Gordillo(Coordinador-Programador)
Henry Maleza (Diseñador de Presentaciones)
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA, CIENCIAS FÍSICAS Y MATEMÁTICA
INGENIERÍA MATEMÁTICA
PROYECTO DE PROGRAMACIÓN II
TEMA: JUEGO FLAPPY BIRD
AUTORES:
ORTADA
TUTOR:
Ing. Wagner Vladimir Lucero
San Francisco de Quito, 01 de Marzo del 2015
DEDICATORIA
Este proyecto va dedicado a mis compañeros, que con la colaboración de cada uno de
ellos se ha logrado realizar este trabajo de manera que se ha culminado con éxito,
también a mi profesor el cual nos ha incentivado a seguir adelante depositando su
entera confianza en cada reto que se nos ha presentado, sin dudar ni un solo momento
de nuestras capacidades y habilidades.
I
AGRADECIMIENTO
Mi gratitud, principalmente está dirigida a Dios por haberme dado la existencia y
permitir seguir adelante cada momento de mi vida.
Agradezco, la confianza y el apoyo de mis compañeros en todo momento, porque han
contribuido positivamente para llevar a cabo esta meta exitosa.
Finalmente, agradezco al Ingeniero Wagner Vladimir Lucero por su asesoramiento
para el desarrollo de este proyecto llegando a finalizar con todo el éxito deseado.
II
ÍNDICE
ORTADA.............................................................................................................................................0
DEDICATORIA..................................................................................................................................... I
AGRADECIMIENTO............................................................................................................................ II
RESUMEN......................................................................................................................................... IV
ABSTRACT.........................................................................................................................................V
INTRODUCCIÓN.................................................................................................................................1
CAPITULO 01.....................................................................................................................................2
EL PROBLEMA....................................................................................................................................2
PLANTEAMIENTO DEL PROBLEMA.................................................................................................2
1.2 FORMULACIÓN DEL PROBLEMA..............................................................................................2
1.3 OBJETIVOS..............................................................................................................................2
1.3.1 Objetivo general..........................................................................................................2
1.3.2 Objetivo específico......................................................................................................3
1.4 VARIABLES...............................................................................................................................3
1.5 INTERROGANTES DE LA INVESTIGACIÓN.................................................................................3
1.6 JUSTIFICACIÓN.........................................................................................................................4
CAPÍTULO 02.....................................................................................................................................5
MARCO TEÓRICO...............................................................................................................................5
2.1 ANTECEDENTES.......................................................................................................................5
2.2 FUNDAMENTACIÓN TEÓRICA..................................................................................................6
2.3 MEJORAMIENTO DE LA APARIENCIA EN EL JUEGO..................................................................8
2.3.1 Apariencia original de interfaz gráfica del juego.........................................................8
2.3.2 Apariencia rediseñada interfaz gráfica del juego.........................................................9
2.3.3 Panel de inicio original...............................................................................................10
2.3.4 Panel de inicio mejorado...........................................................................................11
2.4 ANÁLISIS Y MEJORAMIENTO DEL CÓDIGO EN EL JUEGO.......................................................12
2.4.1 Mejoramiento de los sonidos....................................................................................12
2.4.2 Sonido para saltar......................................................................................................13
2.4.3 Sonido para caída......................................................................................................14
2.4.4 Sonido para choque...................................................................................................14
2.4.5 Sonido para puntos...................................................................................................15
2.5 MODIFICACIÓN DE LAS IMÁGENES DEL JUEGO.....................................................................15
III
2.5.1 Imagen del mapa.......................................................................................................16
2.5.2 Imagen del piso.........................................................................................................16
2.5.3 Imagen del flappy......................................................................................................17
2.5.4 Imagen de los tubos:.................................................................................................17
2.5.5 Insertar nuevas imágenes al videojuego...................................................................18
2.6 ANALISIS DE LA INTERFAZ LOGIN...........................................................................................20
2.6.1 Modificar interfaz login.............................................................................................21
2.6.2 Creación de botón “como jugar”...............................................................................21
2.7 AGRADECIMIENTO AL CÓDIGO ORIGINAL...........................................................................22
CAPÍTULO 03..................................................................................................................................23
METODOLOGÍA...............................................................................................................................23
3.1 DISEÑO DE LA INVESTIGACIÓN..............................................................................................23
3.2 TÉCNICAS...............................................................................................................................23
3.2.1 Observación...............................................................................................................23
3.2.2 Fotografías.................................................................................................................23
3.3 PROCEDIMIENTO PARA LA EJECUCIÓN DE LA INVESTIGACIÓN.............................................24
CAPÍTULO 4.....................................................................................................................................25
CONCLUSIONES Y RECOMENDACIONES..........................................................................................25
4.1 CONCLUSIONES.....................................................................................................................25
4.2 RECOMENDACIONES.............................................................................................................25
ANEXOS...........................................................................................................................................27
IV
TABLA DE ILUSTRACIONES
Ilustración 1.......................................................................................................................5
Ilustración 2 Apariencia actual Flappy..............................................................................8
Ilustración 3 Apariencia mejorada....................................................................................9
Ilustración 4 Apariencia actual menu inicio....................................................................10
Ilustración 5 Apariencia mejorada del menú inicio........................................................11
Ilustración 6 Sonidos del paquete sounds........................................................................12
Ilustración 7 Carpeta de sonidos.....................................................................................12
Ilustración 8 Paquete sounds mejorado..........................................................................13
Ilustración 9 Código del sonido para saltar....................................................................13
Ilustración 10 Código sonido de saltar mejorado...........................................................14
Ilustración 11 Código de sonidos para choques.............................................................14
Ilustración 12 Código de sonido para puntos.................................................................15
Ilustración 13 Clase juego.............................................................................................15
Ilustración 14 Mapa del juego imagen............................................................................16
Ilustración 15 Tubo del flappy.......................................................................................18
Ilustración 16 Interfaz login...........................................................................................20
V
RESUMEN
En el presente trabajo se trata sobre el diseño y mejoramiento de un código de
videojuego obtenido desde una página web, aplicando conceptos y definiciones de
programación orientada a objetos. El objetivo consiste en aplicar todos los conceptos
fundamentales en java para mejora el código.
Flappy bird es un videojuego que consiste en que el jugador controla un pájaro
intentando volar entre filas de tuberías verdes sin tocarse con éstas, la escena se va
desplazando lateralmente hasta que el juego termina si el pájaro choca contra los tubos.
Este juego fue desarrollado en Hanói por el vietnamita Nguyen Hà Đông (Dong
Nguyen) y publicado por GEARS Studios, y el código en netbeans se obtuvo de un blog
en el internet.
El concepto de herencias, polimorfismos, encapsulamientos, clases, entre otros
es muy importante, los cuales se hacen presente dentro de este proyecto, las mismas que
ayudan a un ordenamiento mejor del código.
.
Palabras claves
Mejoramiento
Videojuego
Código
VI
ABSTRACT
In the present paper deals with the design and improvement of game code obtained from
a website, applying concepts and definitions of OOP. The goal is to apply all the
fundamental concepts in java to improve the code.
Flappy bird is a game that involves the player controls one trying to fly between rows of
green piping touch with them, bird scene is moving laterally until the game ends if the
bird hits the tubes. This game was developed in Hanoi by Vietnamese Nguyen Hà Đông
(Dong Nguyen) and published by GEARS Studios, and code in net beans was obtained
from a blog on the internet.
The concept of inheritance, polymorphism, encapsulation, classes, etc. is very
important, which are made present in this project, to help them better ordering of code.
KEYWORDS
Improvement
Videogame
Code
VII
INTRODUCCIÓN
Java es un lenguaje de programación orientado a objetos que se popularizó a partir del
lanzamiento de su primera versión comercial de amplia difusión, la JDK 1.0 en 1996.
Actualmente es uno de los lenguajes más usados para la programación en todo el
mundo.
La Programación Orientada a Objetos nos permite crear juegos con interfaz, con
botones, campos de texto en otras palabras permite al usuario interactuar con la interfaz
gráfica. En nuestro juego realizaremos modificaciones como crear un botón para tener
la ayuda de nuestro juego y que el usuario tenga la opción de saber cómo se juega.
1
CAPITULO 01
EL PROBLEMA
PLANTEAMIENTO DEL PROBLEMA
Al verificar la necesidad de comprender en forma práctica los conocimientos de la
programación orientada a objetos de un grupo de estudiantes de la universidad central
del ecuador, se ha decidido analizar un código de un videojuego para luego mejorarlo y
rediseñarlo con todos los análisis respectivos aplicando los conceptos aprendidos en
clase en mención de lenguaje de programación en java.
1.2 FORMULACIÓN DEL PROBLEMA
¿Cómo mejorar un código de un videojuego para fortalecer el aprendizaje en la
programación orientada a objetos en javas en los estudiantes del segundo semestre de
ingeniería?
1.3 OBJETIVOS
1.3.1 Objetivo general
Dar a conocer a los estudiantes la programación orientada a objetos en java, mediante
la elaboración de un videojuego a partir de un código ya obtenido, para fortalecer el
conocimiento en la asignatura de programación, durante el periodo de octubre al enero
del 2015.
2
1.3.2 Objetivo específico
Obtener un código de un video juego desde una página web, para luego
analizarlo y mejorarlo.
Demostrar los conceptos de programación orientada a objetos en java, utilizando
el código del juego en net beans.
Contribuir a la sociedad estudiantil con la investigación y el estudio de la
programación en java para diseñar videojuegos o programas.
1.4 VARIABLES
Variables dependientes:
Aprendizaje y la comprensión de la programación orientada a objetos en netbeans.
Población:
Estudiantes del segundo semestre de ingeniería de la Universidad Central del Ecuador.
Lugar:
Universidad Central del Ecuador, Quito
Tiempo:
Octubre a Febrero del 2 015
1.5 INTERROGANTES DE LA INVESTIGACIÓN
¿En qué consístela programación orientada a objetos?
¿Cómo se puede mejorar un videojuego a partir de un código ya obtenido?
¿Cómo entenderlos conceptos del lenguaje de programación en java?
¿Cómo se realiza un video juego en netbeans?
3
1.6 JUSTIFICACIÓN
Una de las razones por las cuales se realizó este proceso de investigación, es aprender
los conceptos del lenguaje de programación orienta a objetos en un programa llamado
netbeans.
La realización del proyecto se justifica en el diseño y mejoramiento de un videojuego
que sus códigos muestran conceptos importantes a lo que se refiere la programación en
java. Por otra parte, se pretende crear otro juego similar que facilite el aprendizaje de la
programación hacia los estudiantes.
Este proyecto educativo, permitirá que los alumnos se interesen más por aprender a
programar, pues la mayor parte de temas tratados en esta investigación son importantes
para la ingeniería y diseño de programas donde es necesario analizar el comportamiento
del videojuego, y demostrar que en los códigos se puede observar la teoría a lo que es
la programación orientada a objetos. La teoría y la práctica están relacionadas en el
diseño y construcción de videojuegos cuyo uso sea práctico a través del análisis de
conceptos ya aprendidos. Los beneficios que se obtiene por el manejo con frecuencia de
la programación en los estudiantes permite el desenvolvimiento en lo que es la
informática.
4
CAPÍTULO 02
MARCO TEÓRICO
2.1 ANTECEDENTES
Java es un lenguaje de programación orientado a objetos que se popularizó a partir del
lanzamiento de su primera versión comercial de amplia difusión, la JDK 1.0 en 1996.
Actualmente es uno de los lenguajes más usados para la programación en todo el
mundo.
Ilustración 1
Los antecedentes de Java habría que buscarlos en los lenguajes de programación C y C+
+. El lenguaje C fue desarrollado en la década de los 70 y constituye un lenguaje muy
robusto usado como núcleo del sistema operativo Unix. C no admite la orientación a
objetos y está considerado un lenguaje poco amigable
2.2 FUNDAMENTACIÓN TEÓRICA
El objeto
5
El paradigma de programación estructurada está altamente orientado a datos, lo cual
significa las estructuras de datos por una parte y luego instrucciones del programa que
actúan sobre esos datos. Los lenguajes orientados a objetos, como el lenguaje Java,
combinan datos e instrucciones del programa en objetos. Un objeto es una entidad
independiente que contiene atributos y comportamientos y nada más
Atributos
Son las características que pueden ser definidas de tipo, entero, real, cadena.
Estado y cadena
El Estado es un concepto importante en OOP. El estado de un objeto se representa en
cualquier momento por medio del valor de sus atributos.
Principios de POO
Si usted viene de un ambiente de programación estructurada, la proposición de valores
de OOP puede que no sea clara todavía. Después de todo, los atributos de una persona y
cualquier lógica para recuperar (y convertir) sus valores pueden escribirse en C o
COBOL. Esta sección clarifica los beneficios del paradigma OOP al explicar sus
principios distintivos: encapsulamiento, herencia y polimorfismo.
Encapsulamiento
Recuerde que un objeto es, sobre todo, diferenciado o independiente. Este es el
principio de encapsulamiento en funcionamiento. Ocultación es otro término que a
veces se usa para expresar la naturaleza independiente y protegida de los objetos.Sin
tener en cuenta la terminología, lo que es importante es que el objeto mantiene un límite
entre su estado y comportamiento y el mundo exterior.
En la plataforma Java, puede usar especificadores de acceso (los que presentaré más
adelante en el tutorial) para variar la naturaleza de las relaciones de los objetos desde lo
público a lo privado. El acceso público tiene una gran apertura, mientras que el acceso
privado significa que los atributos del objeto son accesibles solo dentro del objeto
mismo.
6
Herencia
En la programación estructurada, es común copiar una estructura, darle un nombre
nuevo y agregar o modificar los atributos que hacen que la nueva identidad (por
ejemplo, un registro de Cuenta) sea diferente de su fuente original. Con el tiempo, este
abordaje genera una gran cantidad de códigos duplicados, que pueden crear problemas
de mantenimiento.
Polimorfismo
Significa que los objetos que pertenecen a la misma ramificación de una jerarquía,
cuando se envía el mismo pueden manifestar ese comportamiento de modo diferente.
Métodos
Los métodos de una clase definen su comportamiento. A veces, este comportamiento no
es nada más que devolver el valor actual de un atributo. Otras veces, el comportamiento
puede ser bastante complejo.
Métodos constructores
Los constructores le permiten especificar cómo crear una instancia de una clase. Si
usted no proporciona un constructor, el compilador proporcionará uno por usted,
denominado el constructor predeterminado o sin argumento. Si usted proporciona un
constructor que no sea un constructor sin argumento, el compilador no generará uno por
usted.
Applets java
Los applets son aplicaciones Java a las que se accede en un servidor Internet, se
transmiten a través de la red, se instalan automáticamente y se ejecutan como parte de
un documento de la red (página web). Su gran ventaja es la portabilidad.
2.3 MEJORAMIENTO DE LA APARIENCIA EN EL JUEGO
7
2.3.1 Apariencia original de interfaz gráfica del juego
Dentro de nuestro juego se observa que el juego presenta una apariencia actual como
se muestra en la figura de la parte inferior.
Ilustración 2 Apariencia actual Flappy
En el juego de flappy bird se puede visualizar que hace falta algunas opciones tales
como, una barra de vidas que me indique cuantas oportunidades tengo para avanzar el
juego, también ayudas ya sea presionando una tecla en donde pueda informarme más a
fondo las instrucciones del juego.
2.3.2 Apariencia rediseñada interfaz gráfica del juego
8
En el videojuego se pretende mejorar tanto el diseño del fondo con algunas aplicaciones
más, en donde se muestra la barra de vida lo cual indicará cuantas oportunidades le
quedan para poder avanzar el nivel del juego una vez que ya ha sido impactado tres
veces contra las flores malignas.
Se observa en la imagen de la parte superior que los puntajes tienen una apariencia
mejor, lo que da al usuario una mejor comodidad para que utilice esta aplicación.
El juego también contará con un fondo musical, lo cual permitirá que esta aplicación sea
más interactivo tanto el programa con el usuario.
Ilustración 3 Apariencia mejorada
2.3.3 Panel de inicio original
9
En la imagen de la parte superior se muestra el panel inicial en donde se muestra todas
las ayudas del juego actual.
En el panel de inicio del juego actual, no se puede tener acceso a las ayudas, o las
instrucciones del como consiste el juego, y además no se puede elegir ya sea jugar con
un pájaro u otro personaje lo cual permite que el usuario no se sienta tan cómodo con
esta aplicación actual.
En la parte superior podemos observar como es la interfaz del juego actual, del cual se
anhela mejorar añadiendo algunos batones, los cuales permiten al usuario tener ayudas
y dar el informe de cómo actúa el juego.
Ilustración 4 Apariencia actual menu inicio
2.3.4 Panel de inicio mejorado
10
En este diseño del juego se pretende rediseñar y mejorar la aplicación añadiendo unos
botones de ayuda que optimicen la estructura del juego.
Se insertará un botón de ayuda en donde se puede acceder a las instrucciones y ayudas
que ofrece el juego.
Ilustración 5 Apariencia mejorada del menú inicio
2.4 ANÁLISIS Y MEJORAMIENTO DEL CÓDIGO EN EL JUEGO
11
2.4.1 Mejoramiento de los sonidos
Para esto elegimos los sonidos que vamos a modificar dentro de nuestro juego y lo
importamos a los paquetes de la aplicación.
Nos ubicamos dentro nuestro paquete llamado sounds, dentro de este paquete
ubicaremos los nuevos sonidos.
Para colocar los sonidos dentro del paquete debemos arrastrar el sonido que hayamos
elegido y ubicarlo dentro de nuestro paquete sounds.
12
Ilustración 6 Sonidos del paquete sounds
Ilustración 7 Carpeta de sonidos
Luego nos ubicaremos dentro del código: Damos doble clic en nuestra clase llamada
Sonido.java y procedemos a cambiar de nombre al sonido dependiendo de su método:
2.4.2 Sonido para saltar
Dentro del paquete sonidos también se encuentra el audio para saltar en formato mp3, el
cual es utilizado para realizar una abstracción de que el pájaro de nuestro videojuego
intente volar, y desde nuestro código lo llamamos al audio como se indica en la figura
de la parte inferior.
13
Ilustración 8 Paquete sounds mejorado
Ilustración 9 Código del sonido para saltar
2.4.3 Sonido para caída
Este método como se muestra en la figura, llama al audio que se encuentra en ese
paquete para que al momento de que el flappy se impacte contra el suelo produzca un
sonido, el cual está guardado dentro del paquete sounds.
Ilustración 10 Código sonido de saltar mejorado
2.4.4 Sonido para choque
Ilustración 11 Código de sonidos para choques
14
Ilustración 13 Clase juego
2.4.5 Sonido para puntos
Ilustración 12 Código de sonido para puntos
Al analizar la codificación respectiva del juego se puede proceder a modificar los audios
respectivamente para cada método.Con esta modificación obtenemos un nuevo sonido
en todo nuestro juego.
2.5 MODIFICACIÓN DE LAS IMÁGENES DEL JUEGO
Para cambiar las imágenes del juego nos ubicamos en el Package Interfaz y damos
doble clic a la clase Juego y buscamos el código donde encontramos el nombre de la
imagen que está en nuestro juego:
15
2.5.1 Imagen del mapa
La imagen del mapa es el fondo del juego, el cual no presenta un método que de movimiento al mismo por lo cual está imagen permanece estática.
Ilustración 14 Mapa del juego imagen
2.5.2 Imagen del piso
Gráfico 2.14 (Piso del juego)
16
2.5.3 Imagen del flappy
Aquí se puede cambiar la imagen del Flappy, y reemplazarlo por otra imagen en
formato png.
Gráfico 2.15 (Imagen Flappy)
2.5.4 Imagen de los tubos:
Se puede verificar que en esta parte del código se encuentra lo que es los tubos y así
poder modificarlos respectivamente.
Gráfico 2.16 (Imagen tubos)
17
2.5.5 Insertar nuevas imágenes al videojuego.
Y a continuación ingresamos las nuevas imágenes para nuestro juego. Para efectuar
este paso damos clic derecho en el nombre de la imagen que queremos modificar dentro
del Paquete Imágenes.
Gráfico 2.17 (Paquete imágenes)
Y damos clic a la opción Open In External Editor, inmediatamente se nos abrirá la
imagen dentro de Paint ahí podremos copiar nuestra nueva imagen y modificarla.
18
Ilustración 15 Tubo del flappy
Otra opción para cambiar las imágenes es la siguiente:
Arrastramos la imagen de donde este guardada hasta el Paquete Imágenes
Gráfico 2.19 (Copiar imágenes)
Luego cambiamos el nombre de la imagen dentro del código:
Gráfico 2.20 (código para insertar imágenes)
19
Por ejemplo en la imagen del Flappy cambiamos el nombre de pezRojo1.png por
2582_animado .gif que será nuestra nueva imagen del Flappy
De esta manera realizamos los cambios en todas las imágenes de nuestro juego
2.6 ANALISIS DE LA INTERFAZ LOGIN
Es el panel de inicio que se muestra al momento de iniciar el juego, en donde se presenta el botón jugar y donde se escribe el nombre del usuario.
Ilustración 16 Interfaz login
Dentro de este método del TextField1 para ingresar el nombre del usuario observamos
una condición if que nos dice que solo nos permite ingresar hasta 10 caracteres. Esto lo
podemos modificar para que ingresen más caracteres para nombres extensos.
También podemos observar que en el Button1 podemos cambiar el tipo de letra
simplemente java.awt.Font por ejemplo(java.awt.Font(“ALGERIAN”, 1,14));
Se puede modificar el texto que va a ir dentro del Boton por ejemplo: Empezar Juego
20
Gráfico 2.22 (código botón 1)
Gráfico 2.23 (Botón 1
del juego actual)
2.6.1 Modificar interfaz login
Para crear un nuevo botón nos dirigimos al código en donde se creó el botón uno, y analizamos cuidadosamente y procedemos a crear el botón
2.6.2 Creación de botón “como jugar”
21
Dentro de nuestro método creamos un nuevo Botón llamado Button2 de esta
manera:
jButton2= new javax.swing.Jbutton();
Luego llamamos a nuestro objeto por medio del .set y le damos format como
color, tipo de letra y ubicación del texto.
Y nos queda de la siguiente manera:
Gráfico 2.24 (Botón 2 del juego modificado)
2.7 AGRADECIMIENTO AL CÓDIGO ORIGINAL
22
CAPÍTULO 03
METODOLOGÍA
3.1 DISEÑO DE LA INVESTIGACIÓN
Se seguirá el método científico, porque se orienta a los descubrimientos, y esto ayudará
a recolectar informaciones necesarias para resolver el proyecto.
La presente investigación se considera un proyecto especial, por cuanto determina la
necesidad de aprender a programar en un lenguaje de programación que es muy útil hoy
en día.
De acuerdo con esta definición, la investigación bibliográfica permite al investigador
utilizar conocimientos de libros y documentos relacionados con la investigación que se
esté realizando, la misma que es una ayuda para orientar el presente trabajo.
3.2 TÉCNICAS
3.2.1 Observación
Esta técnica permite observar atentamente el fenómeno, hecho, situación, tomar
información y registrarla para su posterior análisis. Se empleará la técnica de la
observación participante, así podremos realizar el juego.
3.2.2 Fotografías
Este instrumento se lo utilizara con el fin de recolectar la mayor parte de
imágenes para cumplir con nuestro proyecto, permitiendo la documentación gráfica del
estudio realizado.
23
3.3 PROCEDIMIENTO PARA LA EJECUCIÓN DE LA INVESTIGACIÓN
Identificación del juego y formulación del problema.
Consideración del tema.
Formulación de objetivos.
Recopilación de material y programas para el desarrollo.
Lectura y análisis de diversos libros de programación.
Sistematización del material consultado.
Selección y elaboración de técnicas a utilizar en la investigación.
Aplicación de los instrumentos de investigación.
Evaluación de losprogramas.
Elaboración de conclusiones y recomendaciones.
Diseño del videojuego.
Elaboración del informe final.
24
CAPÍTULO 4
CONCLUSIONES Y RECOMENDACIONES
4.1 CONCLUSIONES
La programación orientada a objetos nos permite visualizar un entorno agradable
como son los videojuegos u otra aplicación informática que se hace presente en
la actualidad.
Las herencias en java nos permiten ahorrar tiempo y llevar acabo más rápido la
elaboración del videojuego.
4.2 RECOMENDACIONES
Se recomienda que para realizar un algoritmo orientado a objetos es necesario
conocer los conceptos de programación en java.
Es necesario conocer cada una de las bibliotecas que tiene java para importarlos
y así no tener problemas al momento de ejecutar el juego.
25
BIBLIOGRAFÍA
Pedro Manuel Cuenca Jiménez. 1997. "El lenguaje de programación Java". Ed. Anaya
Multimedia.
Patrick Naughton, Herbert Schildt. 1997. "JAVA. Manual de Referencia". Ed.
Osborne / McGraw-Hill.
Bruce Eckel. 2000. "Thinking in Java" Second Edition. Prentice Hall.
26
ANEXOS
Este juego llamado Flappy Bird lo obtuvimos del siguiente link elaborado por
Kedinn 21 de Marzo de 2014:
www.comoprogramar.org/juego-flappy-bird-en -java-neatbeans/
El programa donde vamos a grabar el proceso de nuestro proyecto es el SMRecorder
version1.3.2.
Elegimos este programa ya que es uno de los mas sencillos para grabar.
Solo se da click al botón de New Recording Task e inmediatamente empezara la
grabación
Este programa nos permite elegir donde queremos guardar nuestro video y también
cuenta con un convertidor de formato para facilitar la reproducción de nuestro video.
Se lo puede descargar del siguiente enlace http://www.video2down.com/
27
28