ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA INFORMÁTICA
←
→
Transcripción del contenido de la página
Si su navegador no muestra la página correctamente, lea el contenido de la página a continuación
ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA INFORMÁTICA
Androidy y Lost Aliens
Realizado por
Alberto Beiztegui Casado
Para la obtención del título de
INGENIERO TÉCNICO EN INFORMÁTICA DE SISTEMAS
Dirigido por
José Ramón Álvarez Portillo
Realizado en el departamento de
Matemática Aplicada I
Convocatoria de Septiembre, 2011
A todos los que me
aguantáis cada día.
Alberto Beiztegui Casado.
Licencia Este documento ha sido liberado bajo Licencia GFDL 1.3 (GNU Free Documentation License). Se incluyen los términos de la licencia en inglés al final del mismo. No obstante, las imágenes de videojuegos comerciales están sujetas a copyright y no se distribuyen bajo licencia libre. Copyright (c) 2011 Alberto Beiztegui Casado. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License".
Índice
Introducción..........................................................................................................11
Proyecto propuesto..........................................................................................11
Contexto...........................................................................................................11
Los Smartphones.........................................................................................11
El Sistema Operativo Android....................................................................12
Videojuegos y dispositivos Android...........................................................13
Motivación y objetivos.........................................................................................17
Motivación.......................................................................................................17
Objetivos..........................................................................................................18
Objetivos personales........................................................................................19
Análisis temporal y costes de desarrollo..............................................................21
Análisis temporal.............................................................................................21
Costes de desarrollo.........................................................................................23
Software Utilizado...........................................................................................25
Eclipse.........................................................................................................25
Subversion..................................................................................................25
Inkscape......................................................................................................26
GIMP..........................................................................................................26
Audacity......................................................................................................27
Análisis de antecedentes y aportación realizada..................................................29
Motores 2D para Android................................................................................29
AndEngine..................................................................................................29
Libgdx.........................................................................................................31
Comparación con otras alternativas.....................................................................33
Abduction........................................................................................................33
Doodle Jump....................................................................................................34
Desarrollo de Androidy........................................................................................37
Diseño del Motor.............................................................................................37
El bucle principal.............................................................................................37
El escenario: un árbol de Nodos......................................................................41
Sistema de comportamientos...........................................................................42
Sistema de actualización.............................................................................43
Sistema de pintado......................................................................................43
Sistema de colisiones..................................................................................43
Sistema de Entrada..........................................................................................44
Sistema de Sonido...........................................................................................44
Desarrollo de Lost Aliens.....................................................................................45
Diseño del juego..............................................................................................45
Presentación................................................................................................45
Características principales..........................................................................45
La pantalla de inicio....................................................................................46
Entidades.....................................................................................................47
Control........................................................................................................48
Colisiones....................................................................................................48
Fin de la Partida..........................................................................................49
Implementación...............................................................................................49
Crear un objeto............................................................................................50
Sonido.........................................................................................................51
Pruebas.................................................................................................................53
Androidy..........................................................................................................53
Lost Aliens.......................................................................................................54
Guía para desarrolladores.....................................................................................57
Instalación del entorno de desarrollo en Ubuntu.............................................57
Instalación del SDK de Android.................................................................57
Configurar Eclipse......................................................................................59
Descargando el proyecto desde la forja de REDIRIS.................................60
Conclusiones........................................................................................................61
Bibliografía...........................................................................................................63
GNU Free Documentation License......................................................................67
Introducción
Proyecto propuesto
Androidy es un motor para el desarrollo de videojuegos en dos
dimensiones para plataformas con sistema operativo Android de Google.
Se desarrollarán sistemas para el manejo de entidades, renderizado,
sonido, control y colisiones, así como ejemplos para cada uno de los
sistemas. El objetivo es simplificar la programación de videojuegos para
móviles Android ofreciendo una capa de abstracción por encima de la API
gráfica que nos ofrece Google.
Lost Aliens es un pequeño videojuego de habilidad cuyo objetivo es
comprobar que el motor desarrollado cumple las con las características
necesarias para programar un videojuego completo. En Lost Aliens
controlamos a un pequeño alienígena que deberá ir de planeta en planeta
buscando a otros pequeños aliens perdidos. El objetivo será rescatar al
máximo posible de aliens antes de salirnos de la pantalla.
Contexto
En esta sección analizaremos la situación actual de los videojuegos en
el sistema operativo Android.
Los Smartphones
La palabra Smartphone, teléfono inteligente, es un término comercial
para denominar a los teléfonos móviles que ofrecen funciones adicionales
a las de un teléfono móvil común.
El éxito de este tipo de dispositivos es ya una realidad, según un
estudio elaborado por la firma Gartner, durante el primer trimestre del año
2011 se vendieron 100,7 millones de teléfonos inteligentes, lo que supone
11un incremento del 85% con respecto al mismo periodo del año anterior.
El Sistema Operativo Android
Android es un sistema operativo basado en GNU/Linux diseñado
originalmente para dispositivos móviles, tales como teléfonos inteligentes,
pero que posteriormente ha expandido su desarrollo para soportar otros
dispositivos tales como tablets, reproductores MP3, netbooks, PCs,
televisores o lectores de e-books.
Las ventas de dispositivos Android no han parado de crecer en los
últimos años y, según la firma Gartner, ha pasado de una cuota de mercado
del 17% en 2010 a más de un 40% en 2011. Esto coloca a Android como el
sistema operativo predominante en la industria de los teléfonos inteligentes
Las previsiones además dicen que seguirá subiendo pues cada día se
12activan mas de 500.000 terminales Android en el mundo.
Videojuegos y dispositivos Android.
La llegada de los teléfonos inteligentes ha supuesto una revolución
para el mercado de videojuegos portátiles debido a que ya no es necesario
llevar una consola portátil contigo para jugar, puedes hacerlo en tu propio
móvil.
13En el año 2010 las ventas de videojuegos en teléfonos inteligentes,
sobre todo Iphone y dispositivos Android, supusieron un 34% del total de
ventas de videojuegos portatiles y las previsiones dicen que en muy poco
tiempo el juego en teléfonos superará al de consolas portátiles.
El éxito se debe a la facilidad de adquirir los juegos mediante las
tiendas de aplicaciones que tienen los teléfonos, el AppStore de Apple o el
Market de Android, y al menor precio de éstos respecto a videojuegos para
consolas. El precio de la mayoría de juegos para móviles es inferior a 3
euros, y un gran porcentaje de juegos pueden ser adquiridos gratuitamente.
14Juegos como Angry Birds o Robo Defense han sido descargados
millones de veces del Market de Android y cientos de juegos nuevos
aparecen diariamente en la tienda.
El mercado de videojuegos para Android se encuentra en un momento
inmejorable y todo parece indicar que esta tendencia solo acaba de
comenzar.
1516
Motivación y objetivos
Motivación
El desarrollo de videojuegos para dispositivos móviles siempre ha
despertado mi curiosidad. Los métodos de control como pantallas táctiles o
acelerómetros dan unas posibilidades que no tienen las consolas de
sobremesa. Además, son el medio perfecto para desarrolladores
independientes debido a que no es necesario un juego demasiado complejo
para tener éxito.
Sin embargo, programar aplicaciones para consolas portátiles es una
tarea complicada para un desarrollador independiente debido a que los kits
de desarrollo no están disponibles para todo el mundo. A esto hay que
añadir que las posibilidades de difusión de tu aplicación no son muchas.
Aunque poco a poco las descargas se van imponiendo, la distribución
física de cartuchos o discos sigue siendo predominante.
Google, sin embargo, ofrece gratuitamente el kit de desarrollo de
aplicaciones para dispositivos Android. Puede descargarse directamente
desde su web y toda la documentación está disponible para cualquier
desarrollador interesado. Además, cualquier desarrollador puede incluir
sus aplicaciones en el Market de Android por un precio muy bajo,
permitiendo que la aplicación pueda ser descargada por millones de
personas en cualquier parte del mundo.
Desarrollar el juego desde casi cero, utilizando la API de Google y no
un motor externo como los que veremos más adelante, se debe a mi interés
por aprender las mecánicas de bajo nivel del desarrollo de un videojuego.
Aunque en la carrera he estudiado asignaturas de programación y optativas
como Técnicas Matemáticas de la Informática Gráfica, en la escuela no
hay ninguna asignatura específica de diseño de videojuegos.
17Es posible resumir las motivaciones que me han llevado a desarrollar
este proyecto en el deseo personal de desarrollar videojuegos para
plataformas móviles unido a la posibilidad que da Google a todos los
desarrolladores de programar aplicaciones para su sistema operativo
móvil.
Objetivos
El objetivo principal de este proyecto es desarrollar un motor de juegos
para dispositivos Android y un pequeño juego para demostrar su
funcionalidad.
Los requisitos mínimos que debe cumplir Androidy son los siguientes:
• Control de las entidades del juego. El desarrollado debe tener el
control absoluto del desplazamiento de objetos por la pantalla.
• Renderizado de formas, texto, imágenes estáticas y animaciones.
• Reproducción de melodías y de efectos de sonido.
• Control de la pantalla táctil y del acelerómetro.
• Sistema de colisiones básico. Será suficiente con detectar colisiones
entre el jugador y otras entidades del juego. Se utilizará la
circunferencia como cuerpo para las colisiones.
• Desarrollar un conjunto de ejemplos sencillos para cada sistema.
Lost Aliens debe cumplir con los siguientes requisitos:
• Servir de ejemplo de desarrollo de un juego utilizando el motor
Androidy.
• Utilizar todos los sistemas implementados en el motor.
• Aunque sea un juego simple debe ser entretenido y totalmente
jugable.
18Objetivos personales
A nivel personal espero aprender todo lo que pueda sobre esta
tecnología hasta ahora totalmente desconocida para mi. Por supuesto
también quiero que este proyecto me permita obtener el título de Ingeniero
Técnico en Informática de Sistemas y que la experiencia obtenida me
ayude en un futuro laboral no muy lejano.
1920
Análisis temporal y costes de
desarrollo
Análisis temporal
En esta sección se exponen las diferentes etapas del desarrollo del
proyecto. En primer lugar se adjunta una tabla resumen con las horas
aproximadas dedicadas a cada etapa. A continuación se añade un breve
comentario sobre cada tarea.
Tarea Nº horas
Planificación 30
Formación 80
Desarrollo de Androidy 100
Desarrollo de Lost Aliens 30
Pruebas 2
Arte y sonido 10
Memoria 30
Total 300
Planificación
Dada la envergadura del proyecto, era necesaria una etapa de
planificación en la que se ha estudiado de forma cuidadosa el alcance del
mismo y las posibles dificultades a encontrar durante el desarrollo.
Formación
Al comienzo del proyecto desconocía por completo el uso de la API de
Android. Tampoco conocía con la necesaria profundidad los fundamentos
del desarrollo de videojuegos en dos dimensiones. Fue necesaria, por
21tanto, una larga etapa de formación personal utilizando varios recursos
bibliográficos y pequeñas pruebas prácticas.
Androidy
Tras el periodo de formación inicial, dio comienzo el desarrollo del
motor de videojuegos. Fue la etapa mas larga debido a que cada sistema
debía ser probado antes de continuar con el siguiente.
Lost Aliens
Una vez Androidy comenzó a ser funcional comenzó el desarrollo del
juego.
Pruebas
Durante la implementación se fueron realizando pruebas de los
sistemas individuales de Androidy pero al finalizar Lost Aliens se
realizaron pruebas para testear el control y la jugabilidad del juego..
Arte
El proceso de creación de todas las imágenes necesarias para Lost
Aliens comenzó nada más acabar la redacción del documento de diseño.
Desde ese momento se conocía el estilo visual del juego y los personajes
que aparecerían.
Memoria
Tras el desarrollo de Androidy y Lost Aliens se procedió a la redacción
del presente documento .
22Costes de desarrollo
El único gasto que ha ocasionado el proyecto es la adquisición de un
terminal Android, en concreto un Google Nexus One de HTC, adquirido
libre por un precio aproximado de 300 euros.
Aunque en el kit de desarrollo de Android se incluye un emulador muy
completo de la plataforma no es posible simular algunas características
como el acelerómetro. Por esto fue necesario adquirir este terminal.
Las especificaciones completas del terminal son las siguientes:
• Medidas: 119×59.8×11.5mm
• 130 gramos con batería y 100 gramos sin batería
• Batería de 1400 mAH carga a 480mA desde USB y a 980mA desde
el cargador. Brinda hasta 10 horas de conversación en 2G o 7 horas
23en 3G; hasta 290 horas de standby en 2G o 250 horas en 3G; unas 5
horas de uso de internet en 3G o 6.5 horas en WiFi; 7 horas de
reproducción de video; y 20 horas de reproducción musical
• Pantalla táctil de 3.7 pulgadas WVGA AMOLED con 800 x 480
pixels de resolución
• Procesador Qualcomm QSD 8250 1 GHz
• Cámara de 5 megapixels con Autofocus (“desde 6cm hasta el
infinito”), zoom digital de 2X, flash LED, geolocalización con
AGPS y captura de video a 720×480 pixels y 20fps o mayor
dependiendo de las condiciones de luz
• Android 2.2
• 512MB Flash
• 512MB RAM
• Tarjeta microSD de 4GB expandible hasta 32 GB
• UMTS Band 1/4/8 (2100/AWS/900)
• HSUPA 2Mbps
• GSM/EDGE (850, 900, 1800, 1900 MHz)
• Wi-Fi (802.11b/g/n)
• Bluetooth 2.1 + EDR
• A2DP stereo Bluetooth
• Receptor AGPS
• Posicionamiento por torre de celular y WiFi
• Brújula Digital
• Acelerómetro
24Es un terminal de gama alta y, aunque ya hay en el mercado móviles
con mayor potencia de procesado, tiene potencia de sobra para realizar este
proyecto.
El equipo de desarrollo ha sido mi ordenador personal, con un coste
aproximado de unos 500 euros, y el coste del software utilizado es nulo al
tratarse todo de herramientas gratuitas y en la mayoría de los casos libres.
Software Utilizado
En esta sección vemos de las herramientas utilizadas durante el
desarrollo de Androidy y Lost Aliens. Para cada herramienta se ofrece una
pequeña descripción de sus funcionalidades y se adjuntan las razones por
las cuales ha sido elegida para el desarrollo frente a sus competidoras.
Eclipse
Eclipse es un Entorno Integrado de Desarrollo, del inglés Integrated
Development Environment (IDE), para todo tipo de aplicaciones libres,
inicialmente desarrollado por IBM, y actualmente gestionado por la
Fundación Eclipse.
Herramienta para el programador desarrollada principalmente para el
desarrollo de aplicaciones Java, es posible añadirle nuevas funcionalidades
al editor, a través de nuevos módulos (plugins), para programar en otros
lenguajes de programación además de Java como C/C++, PHP, Python,
Ruby, Cobol, ...y más.
Es además el entorno mas utilizado por los desarrolladores de
aplicaciones Android, por esto ha sido elegido para la realización de este
proyecto.
Subversion
Subversion es un sistema de control de versiones libre cuya primera
versión fue lanzada en el año 2000 por CollabNet. Es compatible en mayor
25parte con su predecesor CVS. Subversion nos permite contar con una
copia de seguridad tanto de los ejemplos de IberOgre como del código de
Sion Tower en todo momento. Gracias a esta herramienta podemos
guardar un historial de todas las versiones de los ficheros fuente del
proyecto así como deshacer cambios en caso de que fuera necesario. Con
SVN conseguimos acceso al código del proyecto desde cualquier equipo.
Además, pone a disposición de cualquier interesado el código fuente de
forma sencilla.
Existen otros sistemas de control de versiones como Git o Mercurial.
Se ha elegido Subversion por su sencillez y por mostrarse suficientemente
potente para gestionar el código de un proyecto de un sólo programador.
Inkscape
Inkscape es una herramienta libre multiplataforma para trabajar con
gráficos vectoriales. Estos diseños no están basados en píxeles sino en
elementos geométricos como vectores o figuras sencillas. Esto permite un
escalado ilimitado sin pérdida de calidad. Inkscape trabaja con ficheros en
formato SVG.
Ha sido utilizado tanto en Androidy como en Sion Tower para trabajar
con gráficos bidimensionales tales como los personajes o los diagramas.
Es prácticamente la única alternativa libre a la altura del software
comercial existente.
GIMP
GIMP es el editor de imágenes libre del proyecto GNU, de hecho su
nombre es el acrónimo de GNU Image Manipulation Program. Es
multiplataforma y está disponible para Windows, GNU/Linux y Mac OS
X. No es comparable a soluciones privativas como Adobe Photoshop pero
es capaz de realizar operaciones bastante avanzadas de forma sencilla.
Ha sido utilizado en Lost Aliens para retocar los personajes. He elegido
26esta herramienta por contar con una licencia libre, ser lo suficientemente
potente para nuestras necesidades y estar disponible en varias plataformas
(incluida GNU/Linux).
Audacity
Audacity es un editor de audio libre y multiplataforma. Permite grabar
y modificar audio con un gran número de opciones y variantes. Fue
lanzado por primera vez en mayo del 2010 y actualmente cuenta con más
de 72 millones de descargas. Si bien es cierto que carece de herramientas
avanzadas de edición de sonido, para mis necesidades era la herramienta
ideal.
Audacity ha sido utilizado en Lost Aliens para convertir y retocar los
efectos de sonido y la pista de la banda sonora .
2728
Análisis de antecedentes y
aportación realizada
Motores 2D para Android
Un motor no es más que un framework con funciones que facilitan
acciones de todo tipo, desde la representación de sprites, hasta la colisión
entre entidades físicas, pasando por la carga de mapeados o la gestión de
efectos sonoros.
A continuación vamos a estudiar las características de dos de los
motores libres más utilizados para desarrollar aplicaciones Android,
contando ambos con varias aplicaciones disponibles en el Market.
AndEngine
AndEngine es un motor de videojuegos 2D para dispositivos Android
basado en OpenGL y desarrollado bajo una licencia libre.
Es un motor con muchos ejemplos de los que extraer información, con
soporte constante por su creador, actualizaciones frecuentes, y en general,
un motor serio diseñado específicamente para Android.
Sin embargo, a causa de la potencia de sus funciones, el motor está
bastante encapsulado, y que usa elementos de Box2D, que es a su vez otro
29motor, algunos problemas de rendimiento si se compara con otros motores
más “cercanos” al dispositivo.
Otro inconveniente es que carece de documentación, por lo que no
existe una fuente en la que detallen las funciones existentes y sus
comportamientos. Esto es un problema debido a la cantidad de clases y
funciones con las que cuenta el motor.
30Libgdx
Libgdx es un motor 2D/3D con mucha actividad, que está siendo
constantemente actualizado y revisado por sus creadores, y que dice
ofrecer un rendimiento muy superior a la mayoría de motores existentes
para Android debido a una gran optimización. Ha sido usado para juegos
comerciales en el market, y a diferencia del resto de motores, incluye una
rica API en la que se documenta el framework al completo, ofreciendo
explicaciones sobre las clases y funciones incluidas. Tiene una WIKI con
material y tutoriales para empezar a familiarizarse con él, y dispone de una
rica base de ejemplos y proyectos con el código completamente disponible
para aprender en base a ellos.
31Otra de las cosas interesantes de Libgdx es que te permite escribir, probar y depurar tu aplicación en tu PC y utilizar el mismo código para Android. Esto se debe a que uno de los objetivos principales de este framework es brindar una arquitectura unificada para trabajar, garantizando el mismo comportamiento en todas las plataformas para las cuáles hayas creado tu juego. 32
Comparación con otras
alternativas
Vamos a estudiar dos juegos con una mecánica parecida a la de Lost
Aliens para ver que requisitos serán necesarios a la hora de implementar el
juego.
Abduction
Abduction es uno de esos juegos que atrapan por su sencillez. Se trata
de unos ovnis que han secuestrado al resto de animales, y nosotros,
controlando a una vaca, tenemos que darles caza. Esto lo haremos saltando
de plataforma en plataforma y con cuidado de no caer. La jugabilidad es
muy simple, hay que inclinar el teléfono hacia la derecha para saltar a la
derecha y a la izquierda para saltar a la izquierda. Y así ir subiendo hasta
alcanzar a los ovnis. Por el camino también tendremos que ir rescatando
animales que se escapen de los ovnis o cogiendo cajas que contienen
ayudas para el jugador.
Cuenta en el market con una secuela y ha sido descargado mas de un
millón de veces.
33Doodle Jump
De la compañía Gamehouse. Doodle jump se basa en un personaje
extraterrestre capaz de dar saltos sin cesar.
En esta historia, nuestro objetivo es llegar lo más alto posible sin ser
atrapado por otras criaturas saltarinas, caer al vacío o ser absorbido por un
agujero negro.
La dificultad va aumentando a lo largo de los metros de ascensión, y
34los puntos de apoyo cada vez son más escasos, y los enemigos más
abundantes.
El juego aprovecha el acelerómetro para hacer los giros, y es muy
sencillo pero adictivo. A pesar de no ser un juego gratuito, Doodle Jump ha
sido descargado mas de 250.000 veces del Market de Android.
3536
Desarrollo de Androidy
Diseño del Motor
En esta sección se describen el funcionamiento interno del motor de
videojuegos.
El bucle principal
El componente central de un motor de juegos es su bucle principal.
Este bucle controla que la actualización y pintado de los objetos del juego
sea lo mas rápida y eficiente posible.
El bucle típico de un videojuego es un bucle while que se ejecuta sin
parar hasta que le indiquemos que finalice. El problema de este tipo de
bucle es que la velocidad de actualizado del juego dependerá de los rápido
que sea el dispositivo.
El bucle en Androidy tiene algunas características que permiten
optimizar su funcionamiento.
Primero vamos a definir las unidades con las que mediremos la
velocidad del juego:
• FPS - Frames por segundo - el número de veces que el juego se
pinta en la pantalla por segundo.
• UPS - Actualización por segundo – el número de veces que se
actualiza el estado de los objetos por segundo.
Lo ideal sería que la actualización y el pintado se ejecutaran el mismo
número de veces por segundo (preferiblemente no menos de 20 a 25 veces
por segundo). 25 FPS es suficiente en un teléfono para que los seres
humanos vieran el juego fluido.
37Por ejemplo, si queremos que el juego corra a 25 FPS, entonces
tendremos que pintar la pantalla cada 40 ms. Esto quiere decir que el juego
debe actualizarse y pintarse en 40 ms, si alguno de los dos pasos tarda más
del tiempo previsto, el juego irá mas lento de lo deseado.
Vamos a ver algunos ejemplos mas:
El siguiente diagrama muestra dos juegos que corren a 1 y 10 FPS
respectivamente, esto significa que la pantalla cambiará exactamente cada
segundo de juego en el primer caso, y cada 100 ms en el segundo.
38Sin embargo estos tiempos de actualización fijos son ideales, no
podemos controlar los tiempos reales de ejecución. ¿Qué pasa si tenemos
200 enemigos y cada enemigo dispara contra nosotros? Tenemos que
actualizar el estado de cada enemigo y los estados de sus balas y
comprobar las colisiones en una sola actualización. Es muy diferente a
tener únicamente 2 o 3 objetos . Los tiempos de actualización claramente
serán diferentes. Lo mismo sucede con el método de pintado. Pintar 200
enemigos disparando claramente llevará más tiempo que la representación
de sólo 2.
¿Cuáles son los posibles escenarios? Si seguimos con el ejemplo de un
juego que corre a 10 FPS, podríamos tener un ciclo de actualización-
pintado que termina en menos de 100 ms o tarde más de 100 ms. Esto va a
depender del hardware en el que se ejecute el juego.
Si el ciclo finaliza antes del plazo deseado tendremos una pequeña
cantidad de tiempo libre antes de ejecutar el siguiente ciclo.
39El siguiente diagrama muestra un ciclo que tarda más de lo debido. Si
se tardan 120 ms significa que tenemos un retraso de 20 ms en el pintado
del frame. Este retraso va a ir acumulándose haciendo que el juego se
ralentice considerablemente.
Obviamente la situación deseada es la primera, disponer de un tiempo
libre antes del siguiente ciclo. Durante este tiempo libre no se hará nada,
consiguiendo así que la velocidad de actualización sea constante.
Para conseguir una velocidad de actualización constante en el segundo
caso lo que haremos será prescindir del pintado en el ciclo siguiente a un
ciclo que no haya terminado a tiempo. Con esto conseguimos que aunque
los FPS caigan un poco, los UPS se mantengan constantes.
40Este bucle es el implementado en Androidy. Conseguimos así que los
juegos se mantengan a una velocidad constante en todos los dispositivos,
aunque la velocidad de pintado dependa de la potencia del dispositivo.
Mientras los FPS se mantengan por encima de 25 el juego sera totalmente
jugable en cualquier dispositivo.
El escenario: un árbol de Nodos
Muchos motores de videojuegos simples utilizan una lista de objetos
para actualizar y pintar en cada frame. Para que un objeto sea manejado
por el motor, debe ser introducido en la lista.
Androidy es un poco más sofisticado y en lugar de una lista de objetos
utiliza un árbol. Un objeto no será actualizado a menos que se introduzca
en el árbol.
El árbol está formado por objetos de tipo Nodo. Un Nodo es una
entidad del juego, que posee una posición en el espacio y puede ser
renderizado en la pantalla. Para que un Nodo entre a ser manejado por el
41motor debe ser introducido en el árbol como hijo de otro Nodo. El Nodo
raíz del árbol se encuentra en la clase Game Manager.
Las características más importantes del grafo de escena son las
siguientes:
• El programador tiene el control absoluto del árbol. Puede
especificar en que parte del árbol introducir un Nodo o mover,
añadir o eliminar ramas completas del árbol.
• No hay restricciones de tamaño, el árbol puede expandirse en
profundidad y anchura todo lo que sea necesario.
• El movimiento de los Nodos se propaga a los Nodos hijos. Si un
objeto se mueve por la pantalla cinco unidades a la derecha todos
sus hijos realizarán este movimiento, además del suyo propio.
Sistema de comportamientos
Muchos motores de juegos tienen una clase padre Nodo y después
crean subtipos como NodoImagen o NodoEnemigo. En Androidy se ha
optado por una clase única de tipo Nodo a la que se le pueden añadir
distintos comportamientos.
Cada Nodo que se añade al grafo de escena puede tener los siguientes
comportamientos:
• De actualización: permite al Nodo realizar acciones como moverse.
• De pintado: especifica la representación del Nodo en la pantalla.
• De colisión: es la reacción de un Nodo al colisionar con otro.
Con esta aproximación conseguimos que para desarrollar un juego solo
sea necesario añadir al árbol tantos Nodos como sean necesarios y
posteriormente indicar a cada Nodo cual debe ser su comportamiento,
pudiendo éste cambiar en cualquier momento de la partida.
42Vamos a describir cada tipo de comportamiento junto con el sistema
que lo controla.
Sistema de actualización
Los comportamientos de actualización, Update Behaviour, estan
controlados por el bucle principal. Cada vez que el bucle actualiza un
objeto, realizará las acciones que indique su Update Behaviour.
Como ejemplos de comportamientos de actualización se han
desarrollado los siguientes ejemplos:
• Movimiento lineal
• Movimiento orbital
• Controlado por el acelerómetro
• Órbita controlada por el acelerómetro.
Sistema de pintado
También controlado por el bucle principal. Cuando el Nodo sea pintado
en pantalla su representación dependerá de su comportamiento de pintado
o Render Behaviour.
Como ejemplos de comportamientos de pintado se han desarrollado los
siguientes ejemplos:
• Texto
• Formas
• Imagen
• Imagen animada.
Sistema de colisiones
Controlados por un sistema independiente, el Collision Manager. El
43sistema de colisiones implementado en Androidy es el más básico posible.
Solo detecta colisiones entre el Nodo player, que se encuentra en la clase
Game Manager, y una lista de Nodos almacenada en Collision Manager.
Una vez añadido un Nodo al sistema de colisiones, éste comprobará en
cada actualización si está colisionando con el jugador. El test de colisión
consiste en medir la distancia entre los dos Nodos y si ésta es menor a la
suma de sus radios se produce una colisión.
Cuando el sistema detecta una colisión ejecuta las acciones que
contiene el comportamiento de colisión, Collision Behaviour, del objeto de
la lista.
Es un sistema extremadamente simple pero no es el objetivo del
proyecto desarrollar un sistema de colisiones complejo.
Sistema de Entrada
Androidy controla dos de los dispositivos de entradas con los que
cuenta el dispositivo, la pantalla táctil y el acelerómetro.
Cuando se pulsa la pantalla Androidy detecta en que posición ha sido
pulsada y ejecuta un método definido por el programador.
El motor controla el acelerómetro guardando la aceleración en el eje X
e Y que proporciona. Se puede acceder en cualquier momento a estas
variables que están guardados en la clase Game Manager.
Sistema de Sonido
El sistema de sonido implementado es una clase estática que permite
reproducir, pausar y reanudar música. También permite reproducir efectos
de sonido.
44Desarrollo de Lost Aliens
Diseño del juego
En esta sección vamos a utilizar Androidy para crear un pequeño
videojuego en el que utilizamos todos los sistemas desarrollados. También
sirve como ejemplo para futuros desarrolladores por lo que entraremos de
lleno en la implementación del juego.
Presentación
Lost Aliens es un videojuego para terminales Android desarrollado con
el motor Androidy. En Lost Aliens controlamos a un alienígena cuya
misión es rescatar a un grupo de bebés aliens que se encuentran perdidos
por el universo. El alienigena debe saltar de planeta en planeta evitando los
obstáculos que se encuentre a su paso para alcanzar al máximo número de
bebés posible.
Características principales
• Planteamiento sencillo: la historia mencionada es muy simple, una
mera excusa para el desarrollo del juego pero lo suficientemente
explícita para que el jugador sienta que tiene un objetivo.
• Habilidad: el jugador debe controlar la dirección en la que el
alienígena se mueve para no chocar con ningún obstaculo ni quedar
45perdido en el espacio.
• Brevedad: al ser un juego destinado a plataformas móviles la
duración de una partida no debe ser excesiva.
• Aleatoriedad: el escenario se irá construyendo aleatoriamente a
medida que avanza la partida, consiguiendo que ninguna partida sea
igual.
La pantalla de inicio
El juego presenta una pantalla de presentación con un botón para
iniciar la partida.
46Entidades
Lost Aliens presenta las siguientes entidades:
• Jugador: es la entidad controlada por el jugador.
• Planeta: son las entidades que construyen el nivel de juego.
• Alien: se encuentran dispersos por la pantalla
• Roca: orbitan alrededor de los planetas.
47Todas las entidades del juego tienen forma de circunferencia para
facilitar las colisiones.
Control
El control del juego depende de la situación del jugador. Podemos
distinguir dos situaciones:
• Modo espacio: cuando el jugador este flotando por el espacio el
control se realiza únicamente con el acelerómetro del dispositivo.
Controlaremos la gravedad dirección del salto para alcanzar el
siguiente planeta.
• Modo superficie: si contactamos con un planeta quedaremos
pegados a su superficie y la inclinación del terminal será la que
controle en que parte del planeta nos situamos.
Colisiones
En Lost Aliens se detectan tres tipos de colisiones:
• Jugador-Planeta: cuando se detecte el jugador queda posado en la
superficie del planeta y el control pasa a modo superficie.
48• Jugador-Alien: al alcanzar un alien el contador de la partida se
incrementa y el alien desaparece y reaparece en otro lugar de la
pantalla.
• Jugador-Roca: esta colisión supone el fin de la partida
Fin de la Partida
La partida finaliza si el jugador colisiona con alguna roca, cae por el
límite inferior de la pantalla o pulsa el botón de regreso. En cualquier caso
se vuelve a la pantalla de inicio.
Implementación
Vamos a comprobar como Androidy permite implementar todas las
características especificadas en el diseño del juego. Esta sección sirve
también como tutorial para futuros desarrolladores.
Lo primero que haremos será crear una clase llamada LostAlienActivity
que será la clase principal del juego. Hacemos que esta clase herede de
SceneActivity para que todos los subsistemas se inicien automáticamente.
public class LostAliensActivity extends SceneActivity
Crear un objeto
Para crear un objeto, por ejemplo el nodo jugador, solo tenemos que
crear un objeto de tipo Nodo e indicarle mediante su renderBehaviour su
representación en pantalla.
playerNode = new Node(0,0);
playerNode.radius = 16;
playerNode.renderBehaviour = new
49RenderAnimatedSprite(this.playerSprite, 10, 15);
Una vez creado lo añadimos al grafo de escena.
GameManager.root.addChild(playerNode);
Ya tenemos en el centro de nuestra pantalla un alienígena. Ahora si
queremos que se mueva solo debemos añadirle a nuestro nodo un
comportamiento de actualización, en el que previamente hemos
programado como queremos que se comporte nuestro nodo.
playerNode.updateBehaviour = updatePlayerBehaviour;
Siguiendo este mismo procedimiento se han implementado, aparte del
jugador, los pequeños aliens, los planetas y los obstáculos.
Colisiones
Para activar las colisiones lo primero que debemos hacer es decirle al
motor cual es el Nodo que controla el jugador.
GameManager.playerNode = playerNode;
Ya solo tenemos que indicarle a los demás nodos cuál será su
comportamiento cuando el jugador colisione con ellos y añadirlo al
sistema de colisiones.
planet.collisionBehaviour = planetCollisionPusher;
GameManager.collisionSystem.intoNodes.add(obs);
Sonido
Para reproducir debemos utilizar el SoundManager.
SoundManager.playMusic(R.raw.sneakysnitch);
Y para los efectos de sonido primero añadimos el sonido al sistema y
después podremos reproducirlo cuantas veces queramos.
jumpSound = SoundManager.addSound(R.raw.boing);
SoundManager.playSound(jumpSound);
50Pruebas
Androidy
Las pruebas del motor se han realizado desarrollando una serie de
ejemplos que sirven además para demostrar las posibilidades del motor.
Todos los ejemplos están incluidos en la aplicación y pueden servir de
referencia para futuros desarrollos.
La lista completa de ejemplos es la siguiente:
Dibujo:
• Texto
• Círculos
51• Imagen
• Imagen Animada
Actualización:
• Movimiento Lineal
• Movimiento Orbital
• Movimiento Lineal Relativo
• Movimiento Orbital Relativo
• Control por Acelerómetro
• Control Orbital por Acelerómetro
Colisiones:
• Desaparecer al Contacto
• Cambio de Comportamiento
Sonido:
• Música
• Efectos de Sonido
Lost Aliens
La primera fase de testeo de Lost Aliens fue realizada por mi mismo,
jugando tanto durante el desarrollo del mismo como con el juego
finalizado. Esto permitió ajustar valores como la velocidad del juego,
numero de aliens y obstáculos en pantalla.
También pude solucionar algunos errores en el motor. Por ejemplo, la
música no paraba de sonar si se salía del juego incorrectamente (utilizando
la tecla de menú en lugar de la de retroceso) o algunos fallos en las
colisiones como que el jugador se quedaba atrapado dentro de un planeta.
52Posteriormente el juego fue probado por familiares y amigos para
comprobar si el manejo del control y la dificultad del juego eran
adecuadas. Se corrigieron algunos aspectos de la física del juego y se
redujo la velocidad de los planetas y obstáculos al ser el juego demasiado
rápido.
5354
Guía para desarrolladores
Para poder seguir las explicaciones de esta guía son necesarios unos
conocimientos básicos del sistema operativo Ubuntu, del entorno de
desarrollo Eclipse y del sistema de control de versiones Subversion, en
particular del paquete subversion de los repositorios de Ubuntu.
Instalación del entorno de desarrollo en Ubuntu
La versión de Ubuntu utilizada es la mas reciente hasta la fecha de este
documento, Ubuntu 11.04 Natty Narwhal.
Instalación del SDK de Android
Primero descargamos el SDK desde la página oficial de Android
Developers:
http://developer.android.com/sdk/index.html
Elegimos la versión para Linux, en este momento la r12, y la
descargamos a nuestro equipo.
Una vez descargado el archivo lo descomprimimos en una carpeta y
accedemos a ella. Entramos en la carpeta tools y ejecutamos el programa
android.
55Entramos en la sección Avaliable packages y pulsamos el botón
Refresh. Antes de instalar comprobamos que la casilla inferior Display
updates only NO está marcada ya que queremos instalar todos los
componentes, no solo actualizarlos.
Ahora marcamos las casillas Android repository y Third Party Add-ons
y pulsamos en el botón Install Selected. Aceptamos todas las licencias y
comenzará la descarga.
56Configurar Eclipse
Primero descargamos eclipse de su página oficial porque funciona
mejor y es más actual que la versión de los repositorios de Ubuntu. La
versión recomendada para trabajar con Android es Eclipse Classic, la
puedes descargar en la siguiente web:
http://www.eclipse.org/downloads/
Una vez descargado abrimos Eclipse, seleccionamos la carpeta en la
que queramos trabajar y procedemos a instalar el plugin para Android.
Entramos en Help > Install New Software, pulsamos el botón Add... e
introducimos los siguientes datos:
• Name: Android Plugin
• Location: https://dl-ssl.google.com/android/eclipse/
Seleccionamos el paquete Developer Tools y pulsamos el botón Next >
hasta que aparezcan las licencias. Las aceptamos y el plugin se instalará.
57Solo queda indicarle a Eclipse donde se encuentra el SDK de Android.
Entramos en Window > Preferences > Android y en la sección SDK
Location pulsamos el botón Browse e indicamos la carpeta donde
descargamos antes el SDK de Android.
Descargando el proyecto desde la forja de REDIRIS
Para conseguir una copia del proyecto abrimos una Terminal e
introducimos el siguiente comando:
svn checkout https://forja.rediris.es/svn/android-acel
Solo queda importar el proyecto en eclipse utilizando la función
Import>Existing Projets Into Workspace.
58Conclusiones
Las sensaciones que tengo tras acabar este Proyecto Fin de Carrera son
muy positivas.
Mi objetivo principal, aprender todo lo posible sobre el desarrollo de
videojuegos para móviles y crear un pequeño motor propio ha sido
cumplido. Demostrando además el uso del motor programando un juego
que podría competir perfectamente con otros que se encuentran en el
Market.
El desarrollo de Androidy me ha servido para tener una base de cara a
futuros desarrollos, que seguro serán mucho mas rápidos y ágiles.
También he podido comprobar que es posible desarrollar una
aplicación desde cero utilizando exclusivamente herramientas libres. Para
un estudiante esto supone unas posibilidades impensables hace escasos
años. Tener todas las herramientas disponibles en internet, y sin coste,
permite que cualquier desarrollador interesado pueda programar
aplicaciones sin tener que pertenecer a una empresa o universidad.
Edemas, la distribución digital, la simplificación de conceptos en el
sector, la expansión del público jugador, la proliferación de dispositivos
móviles con grandes capacidades hardware y las facilidades para el
desarrollo de los mismos, permiten que las aplicaciones lleguen a
cualquier parte del mundo en el momento en el que terminen su desarrollo,
casi sin costes de distribución.
Desarrollando este proyecto he disfrutado, he investigado y aprendido
mucho sobre un tema que me apasiona y que hasta ahora era desconocido
a nivel técnico para mi. Además, he encontrado un sector en el que no me
importaría que se desarrollase mi futuro laboral.
59Y, en definitiva, considero que este Proyecto sirve de prueba de mis conocimientos, y espero que el Tribunal lo considere de la misma forma, permitiéndome obtener el título de Ingeniero Técnico en Informática de Sistemas. 60
Bibliografía
• Against the grain. Blog sobre desasrrollo de videojuegos con
Android.
http://obviam.net/
• Jayway blog. Blog sobre desasrrollo de videojuegos con Android.
http://blog.jayway.com/2009/12/03/opengl-es-tutorial-for-android-
part-i/
• Página oficial para desarrolladores de Android.
http://developer.android.com/index.html
• Colección de famosos ejemplos de programacón gráfica para
Android.
http://insanitydesign.com/wp/projects/nehe-android-ports/
• Replica Island. Videojuego libre para Android.
http://www.replicaisland.net/
• Google I/O 2009 - Writing Real-Time Games for Android.
Conferencia sobre desarrollo de juegos para Android.
http://www.youtube.com/watch?v=U4Bk5rmIpic
• Wikipedia. Página sobre Android.
http://es.wikipedia.org/wiki/Android
• Extenso tutorial para instalar el Android SDK en sistemas Linux.
http://www.ajpdsoft.com/modules.php?
name=News&file=print&sid=536
61• Motor de juegos AndEngine.
http://www.andengine.org/
• Motor de juegos LibGDX.
http://code.google.com/p/libgdx/
• Página en el Market del videojuego Abduction!
https://market.android.com/details?id=au.com.phil
• Página en el Market del videojuego Doodle Jump.
https://market.android.com/details?id=com.realarcade.DOJ
• Informe de Gartnet sobre venta de teléfonos móviles en 2011.
https://market.android.com/details?id=au.com.phil
• Informe acerca del mercado de videojuegos portátiles.
http://tech.fortune.cnn.com/2011/04/15/flurry-ios-and-android-
capture-34-of-u-s-handheld-video-market-in-2010/
6263
64
GNU Free Documentation License
Version 1.3, 3 November 2008
Copyright © 2000, 2001, 2002, 2007, 2008
Free Software Foundation, Inc.
http://fsf.org/
Everyone is permitted to copy and distribute verbatim copies of this
license document, but changing it is not allowed.
0. PREAMBLE
The purpose of this License is to make a manual, textbook, or other
functional and useful document "free" in the sense of freedom: to assure
everyone the effective freedom to copy and redistribute it, with or without
modifying it, either commercially or noncommercially. Secondarily, this
License preserves for the author and publisher a way to get credit for their
work, while not being considered responsible for modifications made by
others.b
This License is a kind of "copyleft", which means that derivative works
of the document must themselves be free in the same sense. It
complements the GNU General Public License, which is a copyleft license
designed for free software.
We have designed this License in order to use it for manuals for free
software, because free software needs free documentation: a free program
should come with manuals providing the same freedoms that the software
does. But this License is not limited to software manuals; it can be used for
any textual work, regardless of subject matter or whether it is published as
a printed book. We recommend this License principally for works whose
purpose is instruction or reference.
651. APPLICABILITY AND DEFINITIONS
This License applies to any manual or other work, in any medium, that
contains a notice placed by the copyright holder saying it can be
distributed under the terms of this License. Such a notice grants a world-
wide, royalty-free license, unlimited in duration, to use that work under the
conditions stated herein. The "Document", below, refers to any such
manual or work. Any member of the public is a licensee, and is addressed
as "you". You accept the license if you copy, modify or distribute the work
in a way requiring permission under copyright law.
A "Modified Version" of the Document means any work containing the
Document or a portion of it, either copied verbatim, or with modifications
and/or translated into another language.
A "Secondary Section" is a named appendix or a front-matter section of
the Document that deals exclusively with the relationship of the publishers
or authors of the Document to the Document's overall subject (or to related
matters) and contains nothing that could fall directly within that overall
subject. (Thus, if the Document is in part a textbook of mathematics, a
Secondary Section may not explain any mathematics.) The relationship
could be a matter of historical connection with the subject or with related
matters, or of legal, commercial, philosophical, ethical or political position
regarding them.
The "Invariant Sections" are certain Secondary Sections whose titles
are designated, as being those of Invariant Sections, in the notice that says
that the Document is released under this License. If a section does not fit
the above definition of Secondary then it is not allowed to be designated as
Invariant. The Document may contain zero Invariant Sections. If the
Document does not identify any Invariant Sections then there are none.
The "Cover Texts" are certain short passages of text that are listed, as
Front-Cover Texts or Back-Cover Texts, in the notice that says that the
66Document is released under this License. A Front-Cover Text may be at
most 5 words, and a Back-Cover Text may be at most 25 words.
A "Transparent" copy of the Document means a machine-readable
copy, represented in a format whose specification is available to the
general public, that is suitable for revising the document straightforwardly
with generic text editors or (for images composed of pixels) generic paint
programs or (for drawings) some widely available drawing editor, and that
is suitable for input to text formatters or for automatic translation to a
variety of formats suitable for input to text formatters. A copy made in an
otherwise Transparent file format whose markup, or absence of markup,
has been arranged to thwart or discourage subsequent modification by
readers is not Transparent. An image format is not Transparent if used for
any substantial amount of text. A copy that is not "Transparent" is called
"Opaque".
Examples of suitable formats for Transparent copies include plain
ASCII without markup, Texinfo input format, LaTeX input format, SGML
or XML using a publicly available DTD, and standard-conforming simple
HTMbL, PostScript or PDF designed for human modification. Examples
of transparent image formats include PNG, XCF and JPG. Opaque formats
include proprietary formats that can be read and edited only by proprietary
word processors, SGML or XML for which the DTD and/or processing
tools are not generally available, and the machine-generated HTML,
PostScript or PDF produced by some word processors for output purposes
only.
The "Title Page" means, for a printed book, the title page itself, plus
such following pages as are needed to hold, legibly, the material this
License requires to appear in the title page. For works in formats which do
not have any title page as such, "Title Page" means the text near the most
prominent appearance of the work's title, preceding the beginning of the
body of the text.
67También puede leer
