Recomendaciones
Muy buenas a todos los lectores. Para seguir con la dinámica que
expliqué en la entrada anterior, antes que nada haré algunas recomendaciones.
De nuevo se trata de otro canal. En este caso del canal de Pumpkin! . Tiene vídeos de altísima calidad y
muy divertidos que os aconsejo que no os perdáis. Aquí os dejo su enlace:
Además, para finalizar el apartado de recomendaciones os recuerdo
el canal recomendado anteriormente. Suscribiros que merece la pena de verdad:
Tutorial
Pues ya es hora de empezar con la parte divertida. Hoy aprenderemos
a configurar la clase principal de nuestro proyecto y mostraremos la primera
escena de nuestro juego. Es decir, en este primer tutorial de programación ya
conseguiremos hacer correr nuestro juego.
Estad muy atentos a cada indicación y como ya hemos hecho
anteriormente, si queda alguna duda podéis dejarlas en los comentarios o
contestar la encuesta de la página principal del blog, en la que ustedes
decidís si profundizamos más en el tema o pasamos a la siguiente lección.
Bien, lo primero que debemos hacer en cualquier proyecto Android
es crear el propio proyecto. Para ello hacemos click en File -> New
-> Android Applications Projects. Nos aparecerá una ventana como esta:
Rellenamos el formulario tal y como aparece en la foto y
presionamos Next. En la nueva ventana que nos aparece deseleccionamos la opción
“Create custom luncher icon” y presionamos Next varias veces hasta que nos
dejen presionar Finish.
Una vez realizados estos pasos os debe aparecer un nuevo proyecto
en la parte izquierda de Eclipse (es posible que automáticamente se cree otro
adicional con el nombre “appcompat_v7”. Ignoradlo y seguid con el tutorial).
Solo nos queda un paso antes de ponernos con el código, que es decirle al
proyecto que use como librería el proyecto de Andengine. Para ello hacemos
click en el botón derecho del ratón sobre nuestro proyecto y presionamos
Properties. A la derecha de la ventana que nos aparece hacemos click en
Android, y luego añadimos el proyecto Andengine como librería presionando en
Add y eligiendo el proyecto correspondiente. Si todo sale bien os tiene que
salir algo parecido a esto:
Si de lo contrario en vez de los ticks verdes os aparecieran unas
aspas rojas, tendréis que volver a realizar este último paso.
Tras esto llegaría el momento que todos esperábamos. Empecemos a
picar código. Un juego para Android, a diferencia de una aplicación, suele
tener una única actividad. Echad un vistazo a vuestro proyecto y curiosead por
los paquetes y carpetas creados (Sin cambiar nada). Observaréis que hay una
clase llamada MainActivity que si la abrís tiene este aspecto:
De momento esta será la principal y única actividad que tendrá
nuestro proyecto. Ahora lo primero que debemos hacer es que esta actividad
extienda de una clase actividad especial que nos provee AndEngine en la cual
tendremos que implementar una serie de métodos propios del motor de videojuego.
En la siguiente entrada os explicaré como funcionan esos métodos y el ciclo de
vida de un juego para Android. Antes quiero que en este tutorial veáis lo fácil
que es hacer correr nuestra aplicación. Entonces, donde pone “extends
ActionBarActivity” lo cambiaremos por “extends BaseGameActivity”. Borramos todo
lo que existe desde la línea 12 a la 35 y hacemos clicks con el segundo botón
del ratón en la palabra MainActivity para señalar la opción “Add unimplemented
methods”. Como resultado nos quedará algo igual a esto:
Ahora vamos a ir explicando y rellenando cada uno de esos métodos.
Si algún detalle lo obviamos es bien porque se explicará en entradas
posteriores y no es necesario para esta o porque es un conocimiento que vais a
adquirir con la práctica y la observación del comportamiento de nuestro juego.
No obstante, podéis preguntar lo que os surja.
Empezamos por el método “onCreateEngineOptions”. En este método se
configuran una serie de parámetros del motor del juego tales como la cámara, la
resolución o la orientación del dispositivo. El método nos debe quedar así:
@Override
public EngineOptions onCreateEngineOptions()
{
camera = new Camera(0, 0, 800,
480);
EngineOptions
engineOptions = new EngineOptions(true, ScreenOrientation.LANDSCAPE_FIXED, new
FillResolutionPolicy(), this.camera);
engineOptions.setWakeLockOptions(WakeLockOptions.SCREEN_ON);
return engineOptions;
}
Podemos ver que hemos creado un objeto de tipo Camera que hemos
situado en las coordenadas 0,0 y con un tamaño de 800x480 píxeles. Además hemos
creado un objeto de tipo EngineOptions al que le hemos pasado una serie de
parámetros al constructor. Entre ellos, hoy vamos a destacar los siguientes.
ScreenOrientation.LANDSCAPE_FIXED: Indica una orientación horizontal del dispositivo.
New FillResolution(): Indica que sea cual sea la resolución del
dispositivo, nuestra aplicación se adaptará a ella ocupando toda la pantalla.
This.camera: Le estamos indicando que use como cámara
la que hemos creado en líneas anteriores.
Los métodos onCreateResources y onPopulateScene deben quedar de la
siguiente manera:
@Override
public void onCreateResources(
OnCreateResourcesCallback
pOnCreateResourcesCallback)
throws IOException {
pOnCreateResourcesCallback.onCreateResourcesFinished();
}
@Override
public void onPopulateScene(Scene pScene,
OnPopulateSceneCallback
pOnPopulateSceneCallback) throws IOException { pOnPopulateSceneCallback.onPopulateSceneFinished();
}
De momento no los usaremos, así que serán explicados en posteriores
tutoriales.
Por último, antes de hacer correr nuestro juego rellenaremos el
método “onCreateScene” de este modo:
@Override
public void
onCreateScene(OnCreateSceneCallback pOnCreateSceneCallback)
throws IOException {
Scene scene=new Scene();
Rectangle rectangle=new Rectangle(100, 400,
75, 75, this.getVertexBufferObjectManager());
scene.attachChild(rectangle);
MoveModifier moveModifier = new MoveModifier(3,
200,400 , 600, 400);
MoveModifier moveModifier2 =
new MoveModifier(3, 600, 400, 200, 400);
SequenceEntityModifier
sequenceEntityModifier = new SequenceEntityModifier(moveModifier,moveModifier2);
LoopEntityModifier
loopEntityModifier = new LoopEntityModifier(sequenceEntityModifier);
rectangle.registerEntityModifier(loopEntityModifier);
pOnCreateSceneCallback.onCreateSceneFinished(scene);
}
De este método solo explicaremos la primera parte. Como podéis ver
creamos un objeto de tipo Scene. Nosotros llamaremos Scene a cada una de las
pantallas que aparecerá en nuestro juego. Tras la designación
del Scene hemos creado un objeto del tipo Rectangle y lo hemos posicionado en
las coordenadas 100, 400. Además, le hemos dado un tamaño de 75x75. Por último
hemos adjuntado el Rectangle a la Scene con el método attachChild, de manera
que hemos pintado el rectángulo en nuestra escena del juego.
Ahora, si abrimos el bluestack y ejecutamos nuestra aplicación nos
debe aparecer algo similar a esto, en la que el rectángulo debe moverse de lado
a lado:
Viendo el resultado obtenido, se me ha ocurrido ya el juego que
vamos a trabajar para este tutorial. En la siguiente entrada daré más detalles
del mismo. Os dejo aquí una foto del código completo que he realizado por si
alguien se pierde durante el tutorial:
Bueno hasta aquí el tutorial de hoy. Espero que os hayáis
divertido y que hayáis aprendido mucho. Hasta luego.
