Clase 1 El motor AndEngine

Clase 1
El motor AndEngine

Autor: Ernesto Gigliotti

Revisin: Mauricio Dvila

Este obra est bajo una Licencia Creative Commons Atribucin-CompartirIgual 4.0 Internacional.
UTN FRA Desarrollo de juegos en Android http://www.lslutnfra.com

Clase 1 El motor AndEngine

ndice

Qu es AndEngine.

Creando un proyecto Android con AndEngine.

Creando una Activity para trabajar con AndEngine.

Creacin de la escena.

Poblando la escena con objetos.

Lanzando el juego en el emulador.

Creacin de texturas y sprites.

UTN FRA Desarrollo de juegos en Android http://www.lslutnfra.com

Clase 1 El motor AndEngine

Qu es AndEngine
La biblioteca AndEngine, brinda un marco de trabajo para el desarrollo de videojuegos en
Android, el cual provee soluciones a requerimientos tpicos en una amplia variedad de juegos.
Esta biblioteca nos permitir manejar grficos en 2D, utilizando internamente OPENGL, la
biblioteca de grficos open source provista por Android para el manejo de bajo nivel de la
pantalla.
AndEngine provee soluciones para construir personajes (sprites) animados, escenas con
sensacin de profundidad (parallax), utilizacin de una cmara que siga a un personaje y
aplique factores de zoom y transiciones de movimiento, y posee la capacidad de asignarle a
cada objeto que se encuentra en la pantalla, propiedades fsicas como densidad, friccin, y
aplicarles fuerzas en diferentes direcciones en un entorno con gravedad como lo es el mundo
real, permitiendo la deteccin de colisiones con otros cuerpos.
Este motor es open source, de modo que podemos tanto utilizarlo, como bajar su cdigo
fuente, aprender de l, modificarlo y volver a distribuirlo.
Creando un proyecto Android con AndEngine
Primero bajaremos la biblioteca AndEngine de Github. La versin que utilizaremos es
AndEngine GLES2 AnchorCenter.
https://github.com/nicolasgramlich/AndEngine/tree/GLES2-AnchorCenter
Bajar esta versin y descomprimir el zip en cualquier lugar. Crear un nuevo proyecto Android e
ir al men File new module y seleccionar la opcin Android Library.

Cargar el nombre de la aplicacin como AndEngine y el package org.andengine:

Presionar Next y finalizar.

Ahora reemplazaremos los archivos del modulo generado por los descargados:
Reemplazar
Reemplazar

tu-proyecto/andengine/src/main/java/org

por

andengine-descargado/src/org

tu-proyecto/andengine/src/main/AndroidManifest.xml

por

andengine-descargado/AndroidManifest.xml

Ir al men File Project Structure. Hacer click en app e ir a la solapa Dependencies.

UTN FRA Desarrollo de juegos en Android http://www.lslutnfra.com

Clase 1 El motor AndEngine

Presionar el botn con el signo + y elegir Module Dependency. Aparecer una ventana con
los mdulos disponibles.

Seleccionamos andEngine y presionamos OK.

Ahora andEngine es una dependencia de nuestra app:

Presionamos OK nuevamente para cerrar la ventana, y ya estaremos en condiciones de utilizar

la biblioteca en nuestro proyecto.

UTN FRA Desarrollo de juegos en Android http://www.lslutnfra.com

Clase 1 El motor AndEngine

Creando una Activity para trabajar con AndEngine
Una vez que tenemos nuestro proyecto Android creado y las bibliotecas de AndEngine
asignadas al proyecto, deberemos comenzar por hacer unas modificaciones en nuestra Activity,
para comenzar, deberemos heredar de BaseGameActivity:
public class MainActivity extends BaseGameActivity {
Por otro lado, ya no usaremos el metodo onCreate, de modo que dejamos de reescribirlo:
/* @Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}*/
A continuacin, sobreescribimos el mtodo onCreateEngineOptions, el cual deber devolver un
objeto del tipo EngineOptions, objeto que creamos dentro, y en donde definimos algunas
caractersticas que se asignarn al motor AndEngine.
private Camera camera;
@Override
public EngineOptions onCreateEngineOptions() {
camera = new Camera(0, 0, 800, 480);
EngineOptions engineOptions = new EngineOptions(true,
ScreenOrientation.LANDSCAPE_FIXED,
new RatioResolutionPolicy(800, 480),
camera);
engineOptions.getAudioOptions().setNeedsMusic(true).setNeedsSound(true);
engineOptions.setWakeLockOptions(WakeLockOptions.SCREEN_ON);
return engineOptions;
}
Dentro del mtodo onCreateEngineOptions, creamos un objeto Camera, el cual guardamos
como atributo de nuestra Activity. Al construir este objeto pasamos como argumento las
coordenadas donde estar enfocando la cmara (0,0 es abajo a la izquierda) y el ancho y alto
de la pantalla, (en nuestro ejemplo 800x480).
Luego construimos el objeto EngineOptions que debemos retornar. En el constructor de este
objeto, pasamos como argumento si queremos que la pantalla sea full screen (en true), luego
la orientacin de la pantalla (en este caso landscape).
Poltica de adaptacin a mltiples tamaos de pantalla
Luego pasamos un objeto que tiene que ver con la poltica de resolucin que tomar
AndEngine, es decir, si la aplicacin corre en un dispositivo que no posee una pantalla de
800x480, cul ser la poltica a aplicar.
Al pasarle un objeto del tipo RatioResolutionPolicy, le estaremos indicando que mantenga la
relacin de aspecto y agrande o achique la pantalla de 800x480 para encajar en la del
dispositivo.
Como consecuencia, aparecern barras laterales o verticales para completar el espacio de
pantalla sobrante cuando la relacin de aspecto de la pantalla del dispositivo no es la misma
que 800/480.

UTN FRA Desarrollo de juegos en Android http://www.lslutnfra.com

Clase 1 El motor AndEngine

800x560

800x480

1600x900

En las tres figuras se observa este efecto, cuando la relacin de especto es mayor, aparecern
barras laterales, mientras que si la relacin de aspecto es menor, aparecern barras
horizontales. Este efecto es conocido como letterbox.
Por ltimo, el constructor de EngineOptions requiere el objeto Camera creado con anterioridad.
Creacin del engine.
Tambin deberemos reescribir el metodo onCreateEngine, en el cual crearemos un objeto
Engine y lo devolveremos. Existen muchos tipos de objetos Engine que podemos crear, cada
uno con sus caracteristicas:

Engine: No posee limitaciones con respecto a la cantidad de cuadros por segundo que
se dibujarn, de modo que puede variar de un dispositivo a otro.
FixedStepEngine: La pantalla se actualiza a velocidad constante. Deberemos pasarle
la cantidad de cuadros por segundo que deseamos (comnmente 60)
LimitedFPSEngine: Nos permite asignar un lmite a la cantidad de cuadros por
segundo.

Para nuestros ejemplos, crearemos un objeto del tipo LimitedFPSEngine, pasndole un mximo
de 60 cuadros por segundo.
@Override
public Engine onCreateEngine(EngineOptions pEngineOptions) {
return new LimitedFPSEngine(pEngineOptions, 60);
}
Como se observa, al constructor le pasamos un objeto del tipo EngineOptions, el cual viene
como argumento en onCreateEngine.
Ahora sobre escribiremos otro metodo en donde deberemos crear todos los recursos
(imgenes, fuentes,etc) que utiliza nuestro juego:
@Override
public void onCreateResources(OnCreateResourcesCallback
pOnCreateResourcesCallback) {
pOnCreateResourcesCallback.onCreateResourcesFinished();
}
Por ahora nuestro juego no tiene ningn recurso, pero aqu cargaremos en memoria fuentes,
imgenes y texturas que utilizar nuestro juego. Al finalizar la carga (que por ahora no existe)
ejecutamos el mtodo onCreateResourcesFinished para notificar al motor la finalizacin de la
carga.

UTN FRA Desarrollo de juegos en Android http://www.lslutnfra.com

Clase 1 El motor AndEngine

Creacin de la escena
Una vez que tenemos nuestra Activity con todos los parmetros de configuracin del Engine,
deberemos sobreescribir un mtodo que nos permite cargar la escena del juego, de modo que
en nuestra Activity, sobre escribimos onCreateScene:
@Override
public void onCreateScene(OnCreateSceneCallback pOnCreateSceneCallback) {

// Creacin de la escena
//...

Por ahora dejamos el mtodo vaco, y construiremos una clase que hereda de Scene, la cual
ser la escena de nuestro juego. La llamaremos GameScene.
public class GameScene extends Scene {
private Engine mEngine;
public GameScene(Engine mEngine)
{
this.mEngine = mEngine;
}
public void createGameScene()
{
setBackground(new Background(Color.BLUE));
}
En esta clase, recibimos en el constructor el objeto Engine y lo guardamos como un atributo,
ya que lo utilizaremos ms adelante. Por otro lado, escribimos el mtodo createGameScene en
donde crearemos la escena de nuestro juego, por el momento, solo seteamos el fondo de la
pantalla de color azul con el mtodo setBackground.
Ahora estamos en condiciones de volver a nuestra Activity, y escribir el cdigo faltante en el
mtodo onCreateScene:
private GameScene gameScene;
@Override
public void onCreateScene(OnCreateSceneCallback pOnCreateSceneCallback) {
gameScene = new GameScene(mEngine);
gameScene.createGameScene();
mEngine.setScene(gameScene);
pOnCreateSceneCallback.onCreateSceneFinished(gameScene);
}
Dentro del mtodo onCreateScene, creamos nuestro objeto GameScene, el cual guardamos
como un atributo de nuestra Activity, y luego llamamos al mtodo createScene de este objeto.
Cabe destacar la utilizacin del objeto mEngine el cual es un atributo de la clase de la que
heredamos y es el objeto Engine creado. A l deberemos indicarle la escena activa (en este
caso el objeto gameScene). Por ltimo, mediante la ejecucin de onCreateSceneFinished
notificamos al Engine que la escena fue creada.
UTN FRA Desarrollo de juegos en Android http://www.lslutnfra.com

Clase 1 El motor AndEngine

Poblando la escena con objetos
Ahora que tenemos nuestra pantalla de juego con su fondo azul, crearemos objetos sobre la
misma, la biblioteca AndEngine provee mtodos para la construccin de figuras geomtricas de
una forma simple, de modo que para nuestro ejemplo, construiremos un rectngulo en
pantalla.
Deberemos sobre escribir otro mtodo en nuestra Activity, el cual se ejecutar despus de
onCreateScene, y es llamado onPopulateScene. En l podemos agregar los objetos en nuestra
escena:
@Override
public void onPopulateScene(Scene pScene,OnPopulateSceneCallback
pOnPopulateSceneCallback) {
gameScene.populateScene();
pOnPopulateSceneCallback.onPopulateSceneFinished();
}
Como se observa, ejecutamos el mtodo populateScene de nuestro objeto gameScene, de
modo que deberemos escribir este mtodo en la clase GameScene:
public void populateScene() {
Rectangle myRectangle = new Rectangle(400, 240, 100, 50,
mEngine.getVertexBufferObjectManager());

myRectangle.setColor(Color.RED);
attachChild(myRectangle);

Dentro de populateScene, creamos un objeto del tipo Rectangle, pasndole en el constructor

las coordenadas en pantalla (recordar que 400;240 es el centro de la pantalla, ya que
definimos una pantalla de 800x480) y luego el tamao de la figura (ancho y alto). Luego
configuramos el color en rojo.
Por ltimo, agregamos el objeto a la escena mediante el metodo attachChild.
Sistema de coordenadas.
Cada figura se posiciona en pantalla sobre su centro, para nuestro rectngulo, el centro se
encuentra en el centro geomtrico del mismo:

UTN FRA Desarrollo de juegos en Android http://www.lslutnfra.com

Clase 1 El motor AndEngine

El sistema de coordenadas de la pantalla, coloca el centro de coordenadas en la esquina
inferior izquierda:

Lanzando el juego en el emulador

Para que funcione el emulador con AndEngine, deberemos habilitar el uso del Host GPU,
para ello en las opciones del emulador, tildamos el check correspondiente:
Ahora lanzamos el emulador y nuestro primer juego:

Bajar Ejemplo1Clase1: http://www.lslutnfra.com/androidJuegos

UTN FRA Desarrollo de juegos en Android http://www.lslutnfra.com

Clase 1 El motor AndEngine

Creacin de texturas y sprites
Seguiremos trabajando sobre el mtodo populateScene de nuestra clase GameScene. En esta
oportunidad, cambiaremos el rectngulo rojo por un Sprite. Los Sprites son utilizados en los
videojuegos para crear los protogonistas, obstculos y objetos que aparecen en las escenas.
No es ms que un mapa de bits el cual puede posicionarse en la pantalla y poseer forma y
propiedades fsicas.

Para poder construir un Sprite, necesitamos previamente construir una textura la cual
contendr la imagen que posea el Sprite.
Crearemos la carpeta assets haciendo click derecho en app->new->Folder->Assets Folder
Colocaremos la imagen logo.png dentro de assets, previamente creando la carpeta gfx solo
para mantener los archivos ordenados dentro de assets:

logo.png
Modificaremos el constructor de GameScene para que reciba nuestra Activity como argumento:
private Engine mEngine;
private BaseGameActivity activity;
public GameScene(Engine mEngine,BaseGameActivity activity){
this.mEngine = mEngine;
this.activity=activity;
}
Ahora dentro de populateScene, creamos un objeto del tipo BuildeableBitmapTextureAtlas.
Este objeto puede ser pensado como un mapa contenedor de una o muchas texturas.En l
cargaremos todas las texturas de los sprites de nuestro juego (objetos, obstculos,etc).
Debido a sto, es importante declarar un tamao para el mapa que sea capaz de contener
todas las texturas (imgenes) de los archivos que carguemos.
En nuestro caso, el mapa posee un tamao de 70x70 pxeles. Dentro de este rea cargaremos
el archivo logo.png el cual es de 64x64 pxeles.

UTN FRA Desarrollo de juegos en Android http://www.lslutnfra.com

10

Clase 1 El motor AndEngine

Creamos el objeto BuildeableBitmapTextureAtlas dentro de populateScene.
BuildableBitmapTextureAtlas logoTextureAtlas;
logoTextureAtlas = new BuildableBitmapTextureAtlas(activity.getTextureManager(),
70, 70,
TextureOptions.BILINEAR);
El ltimo parmetro nos indica el tipo de filtro al descomprimir el archivo png y generar el
bitmap.
Las texturas dentro de este mapa son llamadas regiones de textura o ItextureRegion. En
nuestro caso, crearemos una regin para el archivo logo.png.
ITextureRegion logoRegion;
BitmapTextureAtlasTextureRegionFactory.setAssetBasePath("gfx/");
logoRegion = BitmapTextureAtlasTextureRegionFactory.createFromAsset(
logoTextureAtlas,
activity,
"logo.png");
Antes de llamar al mtodo createFromAsset, llamamos al mtodo setAssetBasePath para
indicar que el archivo se encuentra dentro del directorio gfx.
Ahora que hemos definido la regin para el archivo, debemos construir el mapa contenedor de
todas las regiones (que en nuestro caso es solo una). Como la medida del mapa se coloca
manualmente, y puede ser que las imgenes no entren dentro del mapa, se coloca la creacin
dentro de un bloque try-catch.
try {
logoTextureAtlas.build(
new BlackPawnTextureAtlasBuilder<IBitmapTextureAtlasSource,
BitmapTextureAtlas>(0, 1,
0));
logoTextureAtlas.load();
}
catch (TextureAtlasBuilderException e){
Debug.e(e);
}
Los 3 parmetros recibidos por el constructor del objeto BlackPawnTextureAtlasBuiler tienen
que ver con el espaciado que se deja entre las diferentes regiones dentro del mapa.
Si suponemos un mapa de 100x100 y 3 regiones (suponemos que cargamos 3 archivos png
diferentes) este proceso se encargara de acomodar dentro del mapa las 3 texturas de modo
que entren respetando el espaciado declarado:

UTN FRA Desarrollo de juegos en Android http://www.lslutnfra.com

11

Clase 1 El motor AndEngine

En nuestro caso creamos un mapa de 70x70 y la imagen logo.png es de 64x64 y dejamos un
espaciado de 1px.
Por ltimo, creamos el objeto Sprite y lo adjuntamos a la escena al igual que hicimos con el
rectngulo:
Sprite logoSprite = new Sprite(100, 240,
attachChild(logoSprite);

logoRegion,
mEngine.getVertexBufferObjectManager());

Al crear el objeto Sprite, pasamos como argumento las coordenadas dentro de la pantalla, la
regin construida anteriormente y que contiene el bitmap tomado del archivo logo.png, y un
objeto VertexBufferObjectManager obtenido desde el objeto Engine.
Al ejecutar nuestro juego, veremos adems del rectngulo, nuestro Sprite:

Bajar Ejemplo2Clase1: http://www.lslutnfra.com/androidJuegos

UTN FRA Desarrollo de juegos en Android http://www.lslutnfra.com

12