Tutorial Juego completo - Parte 1 - Introducción.

Hola a todos, como prometí, he finalmente comenzó a publicar una serie de tutoriales del
juego completo, tratando de cubrir todos los temas de la creación de un juego completo
utilizando AndEngine. En el último artículo, usted será capaz de descargar el código fuente
del proyecto juego completo.

Parte de la información acerca de este tutorial:

 Al usar la versión del motor: última rama GLES2 Anchor Center.

 Tipo de juego: juego de saltos de plataforma.

 Extensiones utilizadas: Física Box2D.

En este artículo, voy a demostrar cómo crear un juego fresco estilo de salto de plataformas
en 2D. En este juego el jugador tendrá que saltar entre los azulejos para recoger las
monedas, evita los obstáculos y tratar de no morir

Voy a cubrir los temas siguientes:

 Gestión de escena avanzado.

 Creación de un menú.

 El uso de la música y los sonidos.

 La creación de la escena del juego, HUD, controlador, reproductor.

 Datos de nivel de carga de archivos XML.

 Jugador saltando Manipulación, recoger monedas, juegos sobre eventos (die etc)

 Viendo ventana completa el nivel.

 Salvando las puntuaciones.

En los siguientes tutoriales, voy a suponer que usted ya conoce los conceptos básicos de
AndEngine (Si no por favor diríjase a mis artículos anteriores, que abarca los conceptos
más importantes) También supongo que usted ya ha descargado e instalado AndEngine y
Física Box2D extensión, si no comprobar este tutorial sobre cómo motor de instalación !

. 1 Primer paso:
Crear un nuevo proyecto android en su explorador de proyectos eclipse, y crear una nueva
clase en blanco para nuestra actividad de juego, al igual que en la imagen de abajo:

Ahora tendremos que vincular la AndEngine previamente descargado y proyecto

AndEngine física Box2D Extensión, para ello, haga clic en su proyecto de juego, seleccione
Propiedades -> Android, ahora en la ventana de "biblioteca", agregar esos dos proyectos.

Al hacer todos los pasos mencionados, estamos listos para empezar a programar nuestro
juego, si usted está listo, por favor vaya a segundo artículo:

Juego completo Tutorial - parte 2 - la creación de la actividad:

En el artículo anterior, hemos descargado con éxito el motor, y la extensión física, también
hemos creado nuestro proyecto de juego, vinculamos las fuentes del motor, y creamos una
nueva clase en blanco para nuestra actividad, en este artículo vamos a la configuración de
esta actividad.

Vamos a utilizar una sola actividad, y varias escenas, aquí `s pequeño diagrama que
muestra las escenas:
Después de abrir nuestro juego, el siguiente orden se utilizará:

1. splash carga textura, crear la pantalla de bienvenida, escena de la exhibición del

chapoteo.
2. salpicaduras mientras se muestra, los recursos del menú de carga, y crear la escena
(s) del menú.
3. menú ha sido cargado, descargue la pantalla de bienvenida, mostrar escena del
menú principal.
4. usuario puede cambiar entre escena menú principal y sub-escena (ej. opciones)
5. mientras que el cambio a la escena del juego, una escena de carga se mostrará en
primer lugar, la descarga de las texturas de menú, la carga de recursos del juego y la
creación de la escena del juego.
6. usuario puede cambiar de nuevo en el juego a la escena del menú, la escena de
carga se mostrará durante la descarga recursos del juego, la destrucción de la escena
del juego y cargar de nuevo las texturas del menú.

Así como usted puede ver, es bastante fácil, nada demasiado complicado. Tenga en cuenta
que es mi manera de manejarlo. Es hasta usted para modificarlo para adaptarlo a sus
necesidades, dependiendo de su complejidad juego para la mayoría de juegos que debería
ser lo suficientemente bueno.
. 1 Configuración de Actividad del juego:

Abra la clase creada anteriormente, en mi caso se llama GameActivity, al principio le

permite extender nuestra clase, mediante el uso de la clase BaseGameActivity. Usted se
verá obligado por el eclipse, para agregar métodos no implementados de nuestros
superclase prolongados.

paquete com matimdev.;

.. import java io IOException;

... org importación andengine motor opciones EngineOptions.;

... org importación andengine entidad escena Escena.;
.... org importación andengine ui actividad BaseGameActivity;

/ **
* @ Author Mateusz Mysliwiec
* @ Author www.matim-dev.com
* @ Version 1.0
* /
public class GameActivity extiende BaseGameActivity
{
EngineOptions públicas onCreateEngineOptions ()
{
devolver null;
}

onCreateResources public void (OnCreateResourcesCallback

pOnCreateResourcesCallback) throws IOException
{

public void onCreateScene (OnCreateSceneCallback

pOnCreateSceneCallback) throws IOException
{

public void onPopulateScene (escena pScene, OnPopulateSceneCallback

pOnPopulateSceneCallback) throws IOException
{

}
}

El siguiente paso es crear nuestro motor, ya que queremos hacer nuestro juego funcione a
velocidades similares en diversos dispositivos, utilizaremos el LimitedFPSEngine clase
para hacerlo. Esto es subclase del motor predeterminado, intentará alcanzar un determinado
número de actualizaciones por segundo. Para hacerlo, hemos anular onCreateEngine y
devolver nuestro motor:
 @ Override
onCreateEngine Motor pública (EngineOptions pEngineOptions)
{
return new LimitedFPSEngine (pEngineOptions, 60);
}

Como se puede ver, se utilizó un valor de 60 en el segundo parámetro de constructor, esta

es la cantidad específica de cambios por segundo que tratará de lograr. Ahora vamos a crear
nuestra cámara y opciones de motor, en las opciones de motor que le dicen al motor cómo
debe comportarse, hay ajustes básicos como la orientación, mover la pantalla completa, la
política de resolución, cámara, etc

cámara de la cámara privada;

EngineOptions públicas onCreateEngineOptions ()

{
cámara = nueva cámara (0, 0, 800, 480);
EngineOptions engineOptions = nuevos EngineOptions (true,
ScreenOrientation LANDSCAPE_FIXED, nuevo RatioResolutionPolicy (800,
480), esta cámara..);
. engineOptions getAudioOptions () setNeedsMusic (true)
setNeedsSound (true)..;
engineOptions setWakeLockOptions (WakeLockOptions SCREEN_ON.).;
volver engineOptions;
}

Hemos creado una nueva cámara, de tamaño 800 x 480 píxeles (que depende de usted para
decidir qué resolución de pantalla que se va a hacer frente, es actualmente más utilizado
uno) al lado creamos nuestras opciones de motor, estableciendo el parámetro de pantalla
completa en true, usando orientación fija del paisaje, y la política de resolución de la
relación (si el juego va a ser utilizado en una resolución de pantalla diferente del motor
cambiará el tamaño de nuestro juego, mientras se mantiene la proporción adecuada)
también fijamos las necesidades de la música y el sonido de verdad, así lo haremos ser
capaz de utilizar algo de audio para nuestro juego.

. 2 Editando el fichero de manifiesto de Android:

Tenemos que abrir y editar archivos de manifiesto de Android, para definir algunos
permisos y nuestra actividad, así es como se ve mi manifiesto:
<Xmlns manifiestos: android = "http: / / schemas.android.com / apk / res
/ android"
paquete = "com.matimdev"
android: versionCode = "1"
android: VersionName = "1.0">

<Utiliza-Android SDK: minSdkVersion = "8" android: targetSdkVersion

= "15" />

<Android usos permiso: name = "android.permission.WAKE_LOCK" />

<Android usos permiso: name = "android.permission.VIBRATE" />
<Android usos permiso: name = "android.permission.INTERNET" />
 <Android usos permiso: name =
"android.permission.ACCESS_NETWORK_STATE" />
<Android usos permiso: name =
"android.permission.READ_PHONE_STATE" />

<Aplicación

android: label = "@ string / nombre_apl"

android: icon = "@ estirable / ic_launcher"
android: theme = "@ style / AppTheme">

<Actividad
android: name = ". GameActivity"
android: label = "@ string / nombre_apl"
android:configChanges = " keyboard|keyboardHidden|
orientation|screenLayout|uiMode|screenSize|smallestScreenSize|mcc|mnc "
android: screenOrientation = "paisaje">
<Intención de filtro>
<Acción android: name = "android.intent.action.MAIN" />
<Categoría android: name =
"android.intent.category.LAUNCHER" />
</ Intención de filtro>
</ Actividad>

</ Application>

</ Manifest>
Estamos permitiendo que los permisos más importantes, como el acceso a Internet. (Se
utiliza si desea incluir publicidad en su aplicación, etc) también proporcionaron
información sobre nuestra actividad. También incluimos configChanges propiedad.

Echa un vistazo a el siguiente artículo, donde voy a introducir el director de escena y el

sistema de manejo de la escena.

Completo tutorial juego - parte 3 Recursos Manager:.

Esta clase será responsable de la carga / descarga de los recursos del juego (de arte, fuentes,
archivos de audio) también proporcionará las referencias a los objetos necesarios más
comúnmente (cámara, marco, motor, VertexBufferObjectManager) esta clase utilizará
titular singleton, lo que significa que le podrán acceder a esta clase de nivel mundial.

. paquete com matimdev gerente.;

... org importación andengine motor Engine;

... org importación andengine motor de cámara Cámara.;
... org importación andengine opengl textura TextureOptions.;
..... org importación andengine opengl textura atlas de mapa de bits
BitmapTextureAtlas.;
..... org importación andengine opengl textura atlas de mapa de bits
BitmapTextureAtlasTextureRegionFactory.;
 ..... org importación andengine opengl textura atlas de mapa de bits
BuildableBitmapTextureAtlas.;
....... org importación andengine opengl textura atlas de mapa de bits
fuente IBitmapTextureAtlasSource;
..... org importación andengine opengl textura atlas edificable
constructor BlackPawnTextureAtlasBuilder..;
importación org . andengine . opengl . texture . atlas . buildable .
builder . ITextureAtlasBuilder . TextureAtlasBuilderException ;
.... org importación andengine opengl textura región ITextureRegion.;
.... org importación andengine opengl vbo VertexBufferObjectManager;
... org importación andengine util depuración Depuración.;

importar com matimdev GameActivity..;

/ **
* @ Author Mateusz Mysliwiec
* @ Author www.matim-dev.com
* @ Version 1.0
* /
public class ResourcesManager
{
/ / ---------------------------------------------
/ / variables
/ / ---------------------------------------------

static final ResourcesManager INSTANCIA = new ResourcesManager

privado ();

pública del motor Engine;

actividad GameActivity público;
cámara cámara público;
vbom VertexBufferObjectManager público;

/ / ---------------------------------------------
/ / TEXTURAS Y Regiones TEXTURA
/ / ---------------------------------------------

/ / ---------------------------------------------
/ / Clase de lógica
/ / ---------------------------------------------

loadMenuResources public void ()

{
loadMenuGraphics ();
loadMenuAudio ();
}

loadGameResources public void ()

{
loadGameGraphics ();
loadGameFonts ();
loadGameAudio ();
}

loadMenuGraphics private void ()

{
 }

void loadMenuAudio privado ()

{

loadGameGraphics private void ()

{

loadGameFonts private void ()

{

void loadGameAudio privado ()

{

loadSplashScreen public void ()

{

unloadSplashScreen public void ()

{

/ **
* @ Param motor
* @ Param actividad
* @ Param cámara
* @ Param vbom
* <br>
* Utilizamos este método al inicio del juego de la carga, para
preparar Gerente de Recursos correctamente,
* Ajuste de todos los parámetros necesarios, por lo que podemos
último acceso desde diferentes clases (por ejemplo, escenas)
* /
public static void prepareManager (motor Engine, la actividad
GameActivity, cámara de la cámara, VertexBufferObjectManager vbom)
{
getInstance () = motor motor.;
. getInstance () Actividad = actividad;
getInstance () = cámara cámara.;
getInstance () vbom = vbom.;
}

/ / ---------------------------------------------
 / / getters y setters
/ / ---------------------------------------------

static ResourcesManager getInstance ()

{
volver INSTANCIA;
}
}

Hay métodos separat responsables de gráficos de carga, fuentes y sonidos, también métodos
responsables para la descarga de texturas y cargarlos de nuevo (necesario para fines de
ahorro de memoria, mientras que el cambio entre menú y escenas de caza) También existe
un método prepareManager, que asigna los parámetros necesarios para nuestra gerente,
tenemos que usar este método al inicializar nuestro juego.
. 1 Inicializando nuestra ResourcesManager:

Abra su clase de actividad, crear un nuevo campo para ResourcesManager:

privado resourcesManager ResourcesManager;

Inicializar el gestor de recursos y pasar los parámetros necesarios dentro

onCreateResources, debería tener este aspecto:

onCreateResources public void (OnCreateResourcesCallback

pOnCreateResourcesCallback) throws IOException
{
. ResourcesManager prepareManager (mEngine, este, cámara,
getVertexBufferObjectManager ());
. resourcesManager = ResourcesManager getInstance ();
. pOnCreateResourcesCallback onCreateResourcesFinished ();
}

Hecho, nuestro gerente de recursos está listo para ser utilizado, ahora se refieren al artículo
siguiente. La introducción de la gestión de la escena, utilizando la clase SceneManager.

Completo tutorial juego - parte 4 Gestión Escena:

Uno de los temas más importantes en este tutorial es la gestión de escena. Por esta razón,
vamos a crear dos nuevas clases, breve descripción aquí `sa de ellos:

 BaseScene - esta clase será una representación básica de cada escena creada en
nuestro juego, que es una clase abstracta, que se encargará de la lógica escena
básica.
 SceneManager - como se puede concluir, esta clase proporcionará formas de
gestionar nuestras escenas, cambiar entre ellos, hacer el seguimiento de la escena
actual, el tipo de escena, etc
. 1 clase BaseScene:

. paquete com matimdev base.;

... org importación andengine motor Engine;

... org importación andengine motor de cámara Cámara.;
... org importación andengine entidad escena Escena.;
.... org importación andengine opengl vbo VertexBufferObjectManager;

.. android importación aplicación de la actividad;

.. import com matimdev gerente ResourcesManager.;

... import com matimdev gerente SceneManager SceneType.;

/ **
* @ Author Mateusz Mysliwiec
* @ Author www.matim-dev.com
* @ Version 1.0
* /
public abstract class BaseScene extiende Escena
{
/ / ---------------------------------------------
/ / variables
/ / ---------------------------------------------

Motor El motor protegido;

protegido actividad Actividad;
protegida ResourcesManager resourcesManager;
protegida VertexBufferObjectManager vbom;
protegida cámara Cámara;

/ / ---------------------------------------------
/ / CONSTRUCTOR
/ / ---------------------------------------------

BaseScene pública ()
{
este resourcesManager = ResourcesManager getInstance ()..;
. este motor = resourcesManager motor.;
esta actividad = resourcesManager actividad..;
. este vbom = resourcesManager vbom.;
. esta cámara = resourcesManager cámara.;
createScene ();
}

/ / ---------------------------------------------
/ / ABSTRACCIÓN
/ / ---------------------------------------------

public abstract void createScene ();

abstract void público onBackKeyPressed ();

SceneType getSceneType public abstract ();

 public abstract void disposeScene ();
}

Como se mencionó anteriormente, esta será nuestra clase "núcleo" de cada escena creada.
Se puede utilizar como una extensión, proporcionando la lógica escena básica, usando
métodos abstractos. También contará con los objetos más utilizados tomados de creado
anteriormente ResourcesManager . Hay getSceneType, volviendo SceneType - será una
enumeración dentro de la clase SceneManager, ignore el error y pasar al siguiente paso
siguiente para crear el gestor de escena.

. 2 clase SceneManager:

Será una clase muy importante en nuestro juego, responsable de cambiar de una escena y
hacer el seguimiento de la escena que se muestra actualmente. Usaremos SINGLETON
TITULAR, lo que significa que será capaz de utilizar este pesebre desde el nivel global.
También contará con una enumeración, que contiene nuestros tipos de escenas. También
vamos a crear 4 objetos BaseScene, para las escenas (contra salpicaduras, de carga, de
menú y de escenas de caza)

. paquete com matimdev gerente.;

... org importación andengine motor Engine;

... import com matimdev base de BaseScene;

/ **
* @ Author Mateusz Mysliwiec
* @ Author www.matim-dev.com
* @ Version 1.0
* /
public class SceneManager
{
/ / ---------------------------------------------
/ / ESCENAS
/ / ---------------------------------------------

privado splashScene BaseScene;

privado menuScene BaseScene;
privado gameScene BaseScene;
privado loadingScene BaseScene;

/ / ---------------------------------------------
/ / variables
/ / ---------------------------------------------

static final SceneManager INSTANCIA = new SceneManager privado ();

. SceneType currentSceneType = SceneType SCENE_SPLASH privado;

privado currentScene BaseScene;

. motor Engine privado = ResourcesManager getInstance () del motor.;

SceneType public enum
{
SCENE_SPLASH,
SCENE_MENU,
SCENE_GAME,
SCENE_LOADING,
}

/ / ---------------------------------------------
/ / Clase de lógica
/ / ---------------------------------------------

public void setScene (escena BaseScene)

{
. motor setScene (escena);
currentScene = escena;
. currentSceneType = escena getSceneType ();
}

public void setScene (sceneType SceneType)

{
switch (sceneType)
{
caso SCENE_MENU:
setScene (menuScene);
romper;
caso SCENE_GAME:
setScene (gameScene);
romper;
caso SCENE_SPLASH:
setScene (splashScene);
romper;
caso SCENE_LOADING:
setScene (loadingScene);
romper;
por defecto:
romper;
}
}

/ / ---------------------------------------------
/ / getters y setters
/ / ---------------------------------------------

static SceneManager getInstance ()

{
volver INSTANCIA;
}

pública SceneType getCurrentSceneType ()

{
volver currentSceneType;
}
 pública BaseScene getCurrentScene ()
{
volver currentScene;
}
}

También hay métodos get a mano para recibir el tipo de escena actual y referencias de la
escena actual, lo que podría ser útil en sus etapas posteriores de desarrollo de juegos. No es
el método más importante setScene (sceneType SceneType), que cuida sobre la
visualización de otra escena y hacer el seguimiento de la misma, mediante el
almacenamiento de las referencias de la escena que se muestra y su tipo.

That `s todo - nuestro sistema de manejo de la escena está lista para ser utilizada, bastante
simple ¿no? Ahora pasamos a la siguiente etapa, la creación de nuestra primera escena, que
es una pantalla de bienvenida. Ir al siguiente artículo!

Completo tutorial juego - parte 5 Creación escena pantalla de bienvenida:.

De acuerdo, hemos cubierto todas las clases de "gestión", por lo que finalmente podemos
pasar a la siguiente etapa, que está creando nuestro propio juego, mediante la creación de
escenas, obviamente, de lo que se podría ver en nuestro diagrama de clases publicado en las
partes anteriores de este artículo, la primera escena será nuestra pantalla de inicio, vamos a
mostrar un poco de placa durante la carga de los recursos del menú. Significa, jugador no se
verá obligado a ver la pantalla en negro mientras que los recursos de carga, primero cargar
sólo los recursos de la pantalla de bienvenida y luego mostrar la escena splash y finalmente
cargar diferentes recursos, bastante simple.
. 1 Cargando recursos salpicaduras:
Vamos a tomar el cuidado de los recursos de carga para nuestra pantalla de inicio en primer
lugar. En este ejemplo, vamos a utilizar una simple insignia para nuestra pantalla de
bienvenida (en este caso mi propia insignia, jeje)
  poner su archivo gráfico splash dentro activos / gfx / carpeta.
 llamar a este archivo splash.png
 abrir el ResourcesManager clase, y permite cargar este gráfico. En primer lugar
crear campos para la región de textura y salpicaduras textura.

splash_region ITextureRegion público;

BitmapTextureAtlas privadas splashTextureAtlas;

 Cargue el archivo de salpicadura, dentro del método creado anteriormente

loadSplashScreen ().

. BitmapTextureAtlasTextureRegionFactory setAssetBasePath ("gfx /");

splashTextureAtlas = new BitmapTextureAtlas (actividad getTextureManager
(), 256, 256, TextureOptions bilineal..);
splash_region = BitmapTextureAtlasTextureRegionFactory createFromAsset
(splashTextureAtlas, la actividad, "splash.png", 0, 0).;
. splashTextureAtlas load ();

 También vamos a preparar el método responsable de descargar nuestra textura

splash (que se ejecutará después de completar el proceso de recursos del juego de
carga y la conmutación de la escena de bienvenida para la escena de menú) Hágalo
dentro de la unloadSplashScreen creado anteriormente ()

. splashTextureAtlas descargar ();

splash_region = null;

Hecho, hemos preparado el código responsable de los recursos contra salpicaduras de carga
/ descarga, ahora vamos a pasar a la creación de la escena infantil, más abajo.

. 2 Creación de la escena de salpicaduras:

 crear una nueva clase llamada SplashScene

 como una extensión, utilice la creada anteriormente clase abstracta BaseScene .
 usted se verá obligado por el eclipse de añadir métodos no implementados (de
nuestra superclase)

. paquete com matimdev escena.;

... org importación andengine motor de cámara Cámara.;

.... org importación andengine entidad Sprite Sprite;
... org importación andengine opengl util GLState.;

... import com matimdev base de BaseScene;

... import com matimdev gerente SceneManager SceneType.;
 / **
* @ Author Mateusz Mysliwiec
* @ Author www.matim-dev.com
* @ Version 1.0
* /
public class SplashScene extiende BaseScene
{
@ Override
public void createScene ()
{

@ Override
onBackKeyPressed public void ()
{

@ Override
pública SceneType getSceneType ()
{

@ Override
public void disposeScene ()
{

}
}

Bueno, que tenemos al alcance y fácil de entender los métodos, vamos a empezar con el
llenado getSceneType (), devuelva el tipo de escena (del SceneManager enum `s)

@ Override
pública SceneType getSceneType ()
{
volver SceneType SCENE_SPLASH.;
}

Ahora vamos a manejar la creación de escena, sólo necesitaremos un Sprite para nuestra
presentación.

 crear un nuevo campo para nuestro sprite de salpicaduras:

splash Sprite privado;

 permite inicializar este elemento sprite, dentro createScene (método):

 splash = new Sprite (0, 0,. resourcesManager splash_region, vbom)
{
@ Override
protected void preDraw (GLState pGLState, pCamera Cámara)
{
. súper preDraw (pGLState, pCamera);
. pGLState enableDither ();
}
};

. splash setScale (1.5 f);

. splash setPosition (400, 240);
attachChild (splash);

Lo que acabamos de hacer es inicializar nuestro sprite de splash, y la ató en el centro de la

pantalla. También capacitamos tramado - para mejorar la calidad, ya que su arte basado en
gradiente (ver enlace incluido, para más información sobre el tramado)

 siguiente paso, manejar la eliminación de la escena, lo hacen dentro de la

disposeScene () Método:

@ Override
public void disposeScene ()
{
. salpicar detachSelf ();
salpicar dispose ().;
. este detachSelf ();
. este dispose ();
}

Este dispondrá del sprite splash, y separarla de la escena. Bien, nuestra escena splash se
hace, ahora solo tenemos que inicializarlo dentro de nuestra actividad, más abajo.

. 3 Inicialización nuestra escena salpicaduras:

 abrir nuestra clase SceneManager, vamos a crear el método responsable de

inicializar escena. En el parámetro usaremos OnCreateSceneCallback, porque lo
necesitaremos en la actividad.

public void createSplashScene (OnCreateSceneCallback

pOnCreateSceneCallback)
{
. ResourcesManager getInstance () loadSplashScreen ().;
splashScene = new SplashScene ();
currentScene = splashScene;
pOnCreateSceneCallback onCreateSceneFinished (splashScene).;
}
  También vamos a crear el método responsable de deshacerse escena splash (de
deshacerse de él cuando no se necesita más tiempo, lo que significa que después de
que nos cargamos con éxito los recursos de menú)

void disposeSplashScene privado ()

{
. ResourcesManager getInstance () unloadSplashScreen ().;
. splashScene disposeScene ();
splashScene = null;
}

 ejecutar el método createSplashScene () dentro onCreateScene en su actividad.

public void onCreateScene (OnCreateSceneCallback

pOnCreateSceneCallback) throws IOException
{
. SceneManager getInstance () createSplashScene
(pOnCreateSceneCallback).;
}

 realizar ciertas tareas mientras se muestra splash (dentro onPopulateScene en su

actividad)

public void onPopulateScene (escena pScene, OnPopulateSceneCallback

pOnPopulateSceneCallback) throws IOException
{
mEngine. registerUpdateHandler (nueva timerHandler (2f, nuevo
ITimerCallback ()
{
public void onTimePassed (finales timerHandler
pTimerHandler)
{
. mEngine unregisterUpdateHandler (pTimerHandler);
Recursos del menú / / cargar, crear escena menú
Escena menú / / conjunto mediante el administrador de
escena
/ / DisposeSplashScene ();
/ / LEA SIGUIENTE ARTÍCULO DE ESTA PARTE.
}
}));
. pOnPopulateSceneCallback onPopulateSceneFinished ();
}

Lo que hace:
Se mostrará la pantalla de bienvenida hasta las diferentes tareas se han ejecutado (Carga de
los recursos del menú, el menú de escena y la puesta en escena a la escena del menú.)
En este paso, después de ejecutar nuestro juego, usted debería ser capaz de ver la escena
splash que se muestra (todo el tiempo, por ahora) En el próximo artículo, cubriremos la
creación de la escena del menú y cambiar a él después de cargarlo. Consulte la siguiente
parte para continuar.

 Blog
 Tutoriales
 Dispositivos Biblioteca
 Hoja informativa
 Descargar
 Contacto
 Mi trabajo
 Acerca de mí

Parte 6 escena Menú principal y sus sub-escenas.:

En los artículos anteriores, hemos implementado con éxito el gerente de recursos, el

sistema de manejo de la escena, y creamos la escena pantalla de bienvenida. Ahora nosotros
nos encargamos de crear la escena de menú y su escena (s) sub - (consulte el diagrama de
clases incluido en el número de artículo 2)

. 1 Cargando recursos de escena Menú:

 En primer lugar, vamos a necesitar un fondo, vamos a utilizar la siguiente:

Llámalo menu_background.png y lugar dentro de la carpeta assets / gfx / menú.

 también necesitaremos 2 botones, de juego y opciones, permite utilizar los

siguientes:

Llamarlos play.png y options.png - y como ya se los ponen en la carpeta de activos. Ahora

vamos a abrir nuestra clase ResourcesManager y cargar esos activos.

 crear campos para el menú de la textura, y las regiones de la textura:

menu_background_region ITextureRegion público;

play_region ITextureRegion público;
options_region ITextureRegion público;

BuildableBitmapTextureAtlas privadas menuTextureAtlas;

  activos de carga dentro de las loadMenuGraphics creados anteriormente (método):

. BitmapTextureAtlasTextureRegionFactory setAssetBasePath ("gfx / menu

/");
menuTextureAtlas = new BuildableBitmapTextureAtlas (actividad
getTextureManager (), 1024, 1024, TextureOptions bilineal..);
menu_background_region = BitmapTextureAtlasTextureRegionFactory
createFromAsset (menuTextureAtlas, la actividad, "menu_background.png").;
play_region = BitmapTextureAtlasTextureRegionFactory createFromAsset
(menuTextureAtlas, la actividad, "play.png").;
options_region = BitmapTextureAtlasTextureRegionFactory createFromAsset
(menuTextureAtlas, la actividad, "options.png").;

intentar
{
.. este menuTextureAtlas construir (nueva
BlackPawnTextureAtlasBuilder <IBitmapTextureAtlasSource,
BitmapTextureAtlas> (0, 1, 0));
.. este menuTextureAtlas load ();
}
catch (e TextureAtlasBuilderException final)
{
. De depuración e (e);
}

Estamos creando un mapa de bits edificables atlas textura así que no tenemos que
especificar posiciones de gráficos específicas del interior de la textura. De acuerdo, se hace
nuestro código activos menú de carga.
. 2 Creación de escena del menú:

Crear una nueva clase Java llamada MainMenuScene como una extensión utilizar la clase
creada anteriormente llamado BaseScene. Al igual que antes, usted se verá obligado por
eclipsar a añadir los métodos no implementados.

 dentro getSceneType () devuelven el tipo de escena apropiado:

@ Override
pública SceneType getSceneType ()
{
volver SceneType SCENE_MENU.;
}

 dentro onBackPressed () poner el código encargado de clausurar nuestra aplicación.

 @ Override
onBackKeyPressed public void ()
{
. Sistema exit (0);
}

De esta manera, nos aseguramos de que, la actividad estará completamente muerto,

activity.finish () a veces no ayuda.

 vamos a crear un fondo para nuestra escena menú, cree el nuevo método
createBackground ()

void createBackground privado ()

{
attachChild (new Sprite (400, 240,. resourcesManager
menu_background_region, vbom)
{
@ Override
protected void preDraw (GLState pGLState, pCamera Cámara)
{
. súper preDraw (pGLState, pCamera);
. pGLState enableDither ();
}
});
}

Lo que hace: Crea un nuevo elemento sprite en el centro de la pantalla, para nuestro fondo,
con textura de fondo de la región, también capacitamos tramado para mejorar la calidad del
degradado.

 ejecutar este método, dentro del método createScene ().

@ Override
public void createScene ()
{
createBackground ();
}

Ahora vamos a crear nuestros botones del menú, para este fin se hará uso de la clase
incorporada AndEngine MenuScene, aquí `s el código:

privado menuChildScene MenuScene;

última int MENU_PLAY privado = 0;
int MENU_OPTIONS final privado = 1;

void createMenuChildScene privado ()

{
menuChildScene = MenuScene nueva (cámara);
. menuChildScene setPosition (400, 240);
 última IMenuItem playMenuItem = new ScaleMenuItemDecorator (nueva
SpriteMenuItem (MENU_PLAY, resourcesManager play_region, vbom), 1.2 f,
1.);
última IMenuItem optionsMenuItem = new ScaleMenuItemDecorator (nueva
SpriteMenuItem (MENU_OPTIONS, resourcesManager options_region, vbom), 1.2
f, 1.);

. menuChildScene addMenuItem (playMenuItem);

. menuChildScene addMenuItem (optionsMenuItem);

. menuChildScene buildAnimations ();

. menuChildScene setBackgroundEnabled (false);

. playMenuItem setPosition (. playMenuItem getX (), playMenuItem

getY () + 10.);
. optionsMenuItem setPosition (. optionsMenuItem getX (),
optionsMenuItem getY () - 110.);

. menuChildScene setOnMenuItemClickListener (this);

setChildScene (menuChildScene);
}

Estamos creando dos elementos de menú de sprites, para nuestros dos botones (Play &
opciones) también utilizamos decorador elemento de menú escala, lo que hace que nuestros
elementos de menú animados (que se están ampliando, mientras tocaba) es un efecto muy
fácil, usted puede crear fácilmente su propio, es más que suficiente para los fines de este
tutorial sin embargo. También estamos añadiendo los elementos de menú a la escena del
menú, y el posicionamiento de los elementos del menú, a ve bien con nuestro fondo.
Ahora basta con ejecutar este método dentro de () método createScene.

@ Override
public void createScene ()
{
createBackground ();
createMenuChildScene ();
}

Eclipse dará un error sobre la configuración de menú del botón oyente, lo vamos a utilizar,
para ejecutar ciertas acciones después de pulsar los botones del menú. Para hacerlo, en
primer lugar implementar la clase IOnMenuItemClickListener. Eclipse le pedirá que
agregue método sin aplicarse.

public boolean onMenuItemClicked (MenuScene pMenuScene, IMenuItem

pMenuItem, flotar pMenuItemLocalX, flotar pMenuItemLocalY)
{
switch (pMenuItem. getID ())
{
caso MENU_PLAY:
return true;
MENU_OPTIONS caso:
return true;
por defecto:
 return false;
}
}

Déjalo así por ahora, vamos a crear acciones de los botones de menú más adelante.

3 Inicializando, manejo escena menú mostrar.:

Nuestra escena menú ha sido creado, ahora hay que inicializarlo dentro de nuestro
SceneManager y crear código responsable de la carga de sus recursos, la inicialización de la
escena del menú y cambiar a la escena del menú después de cargar con éxito los recursos
de menú.

 abrir nuestra SceneManager y crear método responsable de crear la escena del

menú.

public void createMenuScene ()

{
.. ResourcesManager getInstance () loadMenuResources ();
menuScene = new MainMenuScene ();
setScene (menuScene);
disposeSplashScene ();
}

Se carga los recursos de menú, inicializar escena del menú, cambiar a la escena del menú, y
al final, a disponer escena pantalla de bienvenida, porque ya no es necesario.

 Abra su actividad, para ejecutar este método dentro de la escena populate

public void onPopulateScene (escena pScene, OnPopulateSceneCallback

pOnPopulateSceneCallback) throws IOException
{
mEngine. registerUpdateHandler (nueva timerHandler (2f, nuevo
ITimerCallback ()
{
public void onTimePassed (finales timerHandler pTimerHandler)
{
. mEngine unregisterUpdateHandler (pTimerHandler);
. SceneManager getInstance () createMenuScene ().;
}
}));
. pOnPopulateSceneCallback onPopulateSceneFinished ();
}

De esta manera la escena pantalla de bienvenida creada previamente, se debe mostrar hasta
que los recursos de menú se cargan, se inicializa escena menú y luego se muestran.
Después de ejecutar su proyecto, usted debería ser capaz de ver la pantalla pantalla de
inicio mientras se carga el menú, y después de eso, la escena del menú se debe mostrar:
Ese `s de todo, ahora podemos decir que nuestra escena menú está hecho, más tarde sólo
tenemos que vincular las acciones de nuestros botones de menú para ejecutar acciones tales
como la visualización de la escena del juego o las opciones de sub escena menú.

Parte 7 Anulación de métodos nativos, manejo de vuelta tecla pulsada:

Advertencia: Si usted está leyendo este artículo, y que estaba leyendo y el uso de artículos
anteriores antes de la fecha de hoy (21/01/2012) Tenga en cuenta el hecho de que los artículos 4,
5 y 6 se han actualizado y RE-factorizada (por favor, lea de nuevo y actualizar su código, de lo
contrario tendrá muchos problemas / errores) Esos cambios eran necesarios!

1 Sustitución de métodos nativos.:

Tenemos que reemplazar el método OnDestroy, para asegurarse de que nuestra actividad se mató
después de abandonar el juego, ya que algunos dispositivos tienden a mantener viva su actividad
incluso después de salir de ella, lo que lleva a un comportamiento extraño. Para asegurarse de que
van a matar, anular OnDestroy dentro de su actividad y ponerse System.exit (0);

@ Override
protected void OnDestroy ()
{
. súper OnDestroy ();
. Sistema exit (0);
 }

. 2 Manejo de vuelta tecla pulsada:

Como podrá darse cuenta, mientras que la creación de escenas, tuvimos que añadir un método sin
aplicarse llamado onBackKeyPressed () - ahora nosotros nos encargaremos de ejecutarlo. Dentro
de su actividad, reemplace el método onKeyDown.

@ Override
onKeyDown public boolean (int keyCode, evento KeyEvent)
{
if (KEYCODE_BACK keyCode == KeyEvent.)
{
.. SceneManager getInstance () getCurrentScene ()
onBackKeyPressed ().;
}
return false;
}

Al hacer esto, el código responsable de la manipulación de las acciones realizadas después de

pulsar el teléfono `s back botón finalmente trabajar.

Parte 8 Creación de escena carga.:

Advertencia: Si usted está leyendo este artículo, y que estaba leyendo y el uso de artículos
anteriores antes de la fecha de hoy (21/01/2012) Tenga en cuenta el hecho de que los
artículos 4, 5 y 6 se han actualizado y RE-factorizada (por favor, lea de nuevo y actualizar
su código, de lo contrario usted animará muchos problemas / errores) Esos cambios eran
necesarios!

. 1 Cargando escena:

Va a ser una escena simple blanco, con sólo un objeto - el texto que dice "cargando ..." -
vamos a mostrar este escena mientras pre-cargar la escena del juego y de sus recursos. Por
favor, consulte el diagrama de clases del artículo número 2 (al tiempo que muestra la
escena de carga, texturas menú serán descargados, se cargan los recursos del juego, y se
inicializará la escena del juego) Esta escena también se utilizará para volver a la escena
desde el menú escena del juego (a la inversa, la escena del juego de descarga y sus texturas
y texturas del menú de carga) Al usar este enfoque simple, vamos a minimizar el uso de
memoria.

 vamos primero a crear una clase de escena carga, llamémosle LoadingScene. Como
anteriormente, utilice nuestra clase BaseScene como una extensión y agregar
 métodos no implementados. Permite también crear un fondo blanco para nuestra
escena.

. paquete com matimdev escena.;

.... org importación andengine entidad escena de fondo Background.;

..... org importación andengine util adt Color color;

... import com matimdev base de BaseScene;

... import com matimdev gerente SceneManager SceneType.;

public class LoadingScene extiende BaseScene

{
@ Override
public void createScene ()
{
setBackground (nuevo fondo (color blanco).);
}

@ Override
public void onBackKeyPressed ()
{
volver;
}

@ Override
pública SceneType getSceneType ()
{
volver SceneType SCENE_LOADING.;
}

@ Override
public void disposeScene ()
{

}
}

Como podrá darse cuenta, en el interior onBackKeyPressed () simplemente devolvemos, lo

que significa que no realiza ninguna acción (porque no queremos hacer nada mientras se
muestra la escena de la carga y el jugador toca el teléfono `s de nuevo el botón)
. 3 Creación de "loading ..." Texto:

Como dije al principio, vamos a necesitar el texto que dice "cargando ..." para hacer esto,
primero tiene que cargar algunos de fuente para crear el texto. Su hasta usted qué tipo de
fuente que se utilice.

 Abrir nuestra clase ResourcesManager, vamos a crear un nuevo método responsable

de cargar nuestro Font, también creamos nuestra fuente en un campo público.

Font fuente pública;

 loadMenuFonts private void ()
{
. FontFactory setAssetBasePath ("font /");
última ITexture mainFontTexture = new BitmapTextureAtlas (actividad
getTextureManager (), 256, 256, TextureOptions
BILINEAR_PREMULTIPLYALPHA..);

. font = FontFactory createStrokeFromAsset (.. actividad

getFontManager (), mainFontTexture, actividad getAssets (), "font.ttf",
de 50 años, fiel, color BLANCO, 2, color NEGRO..);
. fuente load ();
}

Estoy cargando un tipo de letra llamado font.ttf Del activos / font / carpeta.

 Ahora vamos a ejecutar nuestro método responsable de las fuentes de carga dentro
de las loadMenuResources (método), por lo que ahora debería tener este aspecto:

loadMenuResources public void ()

{
loadMenuGraphics ();
loadMenuAudio ();
loadMenuFonts ();
}

El código responsable de la fuente de carga está listo, vamos a volver a nuestra clase de
escena cargar, y crear un objeto de texto y colocarlo en el centro de la pantalla.

@ Override
public void createScene ()
{
setBackground (nuevo fondo (color blanco).);
attachChild (. nuevo texto (400, 240, resourcesManager fuente,
"Cargando ...", vbom));
}

 Iniciar la escena de carga dentro de nuestro SceneManager, dentro

createMenuScene ()

public void createMenuScene ()

{
.. ResourcesManager getInstance () loadMenuResources ();
menuScene = new MainMenuScene ();
loadingScene = new LoadingScene ();
. SceneManager getInstance () setScene (menuScene).;
disposeSplashScene ();
}
Eso es todo por ahora, no vamos a usarlo sin embargo, como vamos a tener que crear una
escena del juego primero, y más tarde el código responsable de mostrar la escena de carga
cuando sea necesario (ver el diagrama de código para entender cuando se visualiza la
escena de carga)

Parte 9 Creación escena del juego.:

Y finalmente aquí estamos, en este artículo, vamos a crear parte más importante de nuestra
aplicación, que es la escena del juego-juego.

 crear una nueva clase, llamada GameScene y use nuestro BaseScene como una
extensión.

. paquete com matimdev escena.;

... import com matimdev base de BaseScene;

... import com matimdev gerente SceneManager SceneType.;

public class GameScene extiende BaseScene

{
@ Override
public void createScene ()
{

@ Override
public void onBackKeyPressed ()
{

@ Override
pública SceneType getSceneType ()
{
volver SceneType SCENE_GAME.;
}

@ Override
public void disposeScene ()
{

}
}

. 1 Creación de fondo:

En este ejemplo, vamos a usar algo simple como un fondo, vamos a utilizar el color simple,
también puede utilizar su propia imagen o crear fondos más avanzadas, como la paralaje etc
 void createBackground privado ()
{
setBackground (nuevo Fondo (Color azul).);
}

. 2 Creación de HUD:

Necesitaremos HUD - que será utilizado para la visualización de dispositivo de juego y el

texto puntuación.

 crear nuevo campo privado de HUD, y el método para inicializarlo.

privado gameHUD HUD;

private void createHUD ()

{
gameHUD = new HUD ();
. cámara setHUD (gameHUD);
}

 crear nuevo campo para el texto puntuación, e inicializar dentro método createHUD:

scoreText Texto privado;

private void createHUD ()

{
gameHUD = new HUD ();

/ / CREAR TEXTO SCORE

scoreText = new Texto (20, 420, resourcesManager fuente,
"Puntuación: 0123456789."., nuevos TextOptions (HorizontalAlign
izquierda), vbom);
. scoreText setAnchorCenter (0, 0);
. scoreText setText ("Score: 0");
. gameHUD attachChild (scoreText);

. cámara setHUD (gameHUD);

}

Creamos y apegados nuestro texto puntuación al HUD, lo que es importante, hemos

inicializado texto con todos los personajes que vamos a utilizar, mientras que el cambio de
la puntuación (en especial todos los números) ¿cuál es el propósito de la misma? "Memoria
preparación" - sin él, cada vez que iba a cambiar el texto usando nuevo personaje con no se
especificó al inicializar causaría notable desaceleración / glitch.
  crear nuevo campo entero para mantener nuestra cuenta la puntuación, y el nuevo
método responsable de manipular con la puntuación:

int score privado = 0;

void addToScore privado (int i)

{
anotar + = i;
. scoreText setText ("Score:" + score);
}

En el capítulo separado, nosotros nos encargamos de crear el controlador apropiado.

. 3 Creación de la física:
Vamos a necesitar la física en nuestro juego, así que vamos a crearlo.

 crear nuevo campo para nuestra PhysicsWorld y crear método para inicializarlo.

privado PhysicsWorld PhysicsWorld;

createPhysics private void ()

{
PhysicsWorld = new FixedStepPhysicsWorld (60, nuevo Vector2 (0, -
17), false);
registerUpdateHandler (PhysicsWorld);
}

Utilizamos clase FixedStepPhysicsWorld, esta clase trata de alcanzar una determinada

cantidad de pasos por segundo (en nuestro caso 60) segundo parámetro es el parámetro de
la gravedad, su hasta usted para modificarla depende de sus necesidades, en el extremo,
registramos nuestra física mundo como un controlador de actualización de nuestra escena.

 ejecutar todos los métodos de creación dentro createScene método ():

@ Override
public void createScene ()
{
createBackground ();
createHUD ();
createPhysics ();
}

Ese `s todo en este artículo, por ahora, es básico escena del juego puesta en marcha, en los
próximos artículos vamos a añadir las piezas más grandes, como controlador, jugador,
cargador de nivel y el constructor, la lógica de nivel. Compruebe próximo artículo, de
configurar la escena del juego de carga y el proceso de visualización.
Parte 10 Viendo escena carga mientras escena del juego de carga.:

En el artículo anterior, hemos preparado básico juego escena del juego de preparación.
Ahora vamos a manejar la visualización de la escena de carga después de pulsar el botón de
reproducción s menú `. Como usted debe recordar de la descripción diagrama de clases,
vamos a mostrar la escena de carga mientras que los recursos de juego de pre-carga,
descarga texturas del menú y la inicialización de la escena del juego (y también mientras se
mueve hacia atrás de juego a escena menú)

. 1 La carga y descarga de menú textura (s):

Como se ha mencionado, necesitaremos métodos responsables de la descarga y

manipulación de carga menú textura (s), crearlos dentro de nuestra clase
ResorucesManager:

unloadMenuTextures public void ()

{
. menuTextureAtlas Unload ();
}

loadMenuTextures public void ()

{
. menuTextureAtlas load ();
}

Su auto-explicativo bastante lo que nos acaba de ayudar a liberar algo de memoria,

mientras que en la actualidad no es necesaria la textura, más tarde, puede cargar de nuevo
con una línea (que no tiene que volver a crear regiones textura etc, simplemente
descargamos textura de la memoria, podemos cargar de nuevo)

 crear método dentro SceneManager responsable de mostrar la escena de carga,

mientras se iniciaba la escena del juego y de la carga de sus recursos, y la descarga
de menú textura.

public void loadGameScene (Motor definitiva mEngine)

{
setScene (loadingScene);
.. ResourcesManager getInstance () unloadMenuTextures ();
mEngine. registerUpdateHandler (nueva timerHandler (0.1 f, nuevo
ITimerCallback ()
{
public void onTimePassed (finales timerHandler pTimerHandler)
{
. mEngine unregisterUpdateHandler (pTimerHandler);
.. ResourcesManager getInstance () loadGameResources ();
gameScene = new GameScene ();
setScene (gameScene);
}
}));
 }

 Abrir nuestra clase MenuScene para ejecutar este método después de pulsar el botón
de reproducción.

public boolean onMenuItemClicked (MenuScene pMenuScene, IMenuItem

pMenuItem, flotar pMenuItemLocalX, flotar pMenuItemLocalY)
{
switch (pMenuItem. getID ())
{
caso MENU_PLAY:
/ / Cargar la escena del juego!
. SceneManager getInstance () loadGameScene (motor).;
return true;
MENU_OPTIONS caso:
return true;
por defecto:
return false;
}
}

Si has seguido mis tutoriales y códigos con cuidado, usted debería ser capaz de cargar
escena del juego después de pulsar el botón de reproducción, y mientras escena del juego
de carga, escena de carga se debe mostrar.

Cargando escena. Escena del juego.

. 2 Volviendo de juego a la escena del menú:

Bien, supongamos que estamos en escena del juego, estamos presionando de nuevo el
botón, por lo que se supone que ser trasladado a la escena del menú, ya que descargamos
menú textura que tenemos ahora para realizar algunas tareas. Descargue la textura de juego,
el menú de carga de textura, eventualmente destruir / eliminar la escena del juego mediante
la destrucción / desconectar todos los elementos de la escena del juego (para asegurarse de
que no habrá fugas de memoria) y la escena de menú de la pantalla hacia atrás, en el
desempeño de todas las tareas, nuestra escena de carga se se mostrará.

 dentro de nuestro ResourcesManager, crear nuevo método responsable de textura (s)

juego de la descarga ya que no hemos creado ningún texturas para la escena del
juego, vamos a dejarlo en blanco por ahora, y llenar después con las texturas del
juego de código de descarga.

unloadGameTextures public void ()

{
/ / TODO (Ya que no hemos creado ningún texturas para la escena del
juego aún)
}

 crear método dentro SceneManager responsable de escena menú de carga y

visualización de la escena de carga en el desempeño de todas las tareas
mencionadas:

public void loadMenuScene (Motor definitiva mEngine)

{
setScene (loadingScene);
. gameScene disposeScene ();
.. ResourcesManager getInstance () unloadGameTextures ();
mEngine. registerUpdateHandler (nueva timerHandler (0.1 f, nuevo
ITimerCallback ()
{
public void onTimePassed (finales timerHandler pTimerHandler)
{
. mEngine unregisterUpdateHandler (pTimerHandler);
.. ResourcesManager getInstance () loadMenuTextures ();
setScene (menuScene);
}
}));
}

Maneja mostrando escena de carga durante la ejecución de código de las texturas del juego
descarga, carga de nuevo el menú textura y también ejecutamos disposeScene (); Método
de nuestra escena del juego, vamos a poner ahí el código responsable de la limpieza de la
escena del juego, por ahora poner esto dentro disposeScene () en nuestra clase GameScene.

@ Override
public void disposeScene ()
{
. cámara setHUD (null);
. setCenter cámara (400, 240);
 / / Código TODO responsable de deshacerse escena
/ / Eliminación de todos los objetos de la escena del juego.
}

Por ahora sólo cámara clara del `s del HUD y la cámara definido` s posición central en su
valor predeterminado, más adelante vamos a añadir código responsable de desmontar /
desechar todas las entidades y la destrucción de los objetos físicos.

 Ejecutar método responsable de cambiar de nuevo a la escena dentro de su menú

GameScene, mediante la ejecución de este método dentro onBackKeyPressed
(método).

@ Override
public void onBackKeyPressed ()
{
. SceneManager getInstance () loadMenuScene (motor).;
}

Ese `s todo en este artículo, haciendo todo incluido en todos los artículos hasta ahora, usted
debería ser capaz de cambiar entre menú y escenas de juego libre. Cargando escena se
muestra sólo para muy corto período de tiempo, ya que de momento no usamos muchos
recursos (gráficos, etc), pero más tarde él rudo lleva poco más de tiempo.

Parte 11. Nivel de carga de XML, plataformas y monedas.

Ahora nos centraremos en algunos aspectos del juego-juego, el nombre de nuestro juego es
"el juego del puente" - tendremos que controlar personaje 2d, saltando entre plataformas y
recoger monedas. En primer lugar, en este juego no voy a crear bellos gráficos debido a
que:

 esto es tutorial acerca de la codificación.

 Yo no soy artista.
 usted no debe recibir todo en una placa de oro, un poco de esfuerzo es necesario.

. 1 tipos de plataformas:

En nuestro juego, vamos a tener 3 tipos de plataformas:

Plataforma 1 - plataforma Plataforma 2 - plataforma Plataforma 3 - cayendo

estática normal, sin trampa, caer después de 2 sólo si existe un contacto
características especiales. seg. después del contacto con el jugador.
 con el jugador.

. 2 objeto de la moneda:

Jugador será capaz de recoger las monedas, ganando puntuación. Usaremos gráfico
utilizado anteriormente.
. 3 Cargando gráficos para plataformas y moneda:

 Abrir nuestra clase ResourcesManager, y crear campos para las regiones de textura
para nuestros gráficos, y de nueva textura:

/ / Textura Juego
BuildableBitmapTextureAtlas públicas gameTextureAtlas;

/ / Juego Textura Regiones

platform1_region ITextureRegion público;
platform2_region ITextureRegion público;
platform3_region ITextureRegion público;
coin_region ITextureRegion público;

 permite inicializar nuestras nuevas texturas y juegos de carga recursos del juego
(plataformas y monedas) en el interior loadGameGraphics creados anteriormente
(método).

loadGameGraphics private void ()

{
. BitmapTextureAtlasTextureRegionFactory setAssetBasePath ("gfx /
game /");
gameTextureAtlas = new BuildableBitmapTextureAtlas (actividad
getTextureManager (), 1024, 1024, TextureOptions bilineal..);

platform1_region = BitmapTextureAtlasTextureRegionFactory
createFromAsset (gameTextureAtlas, la actividad, "platform1.png").;
platform2_region = BitmapTextureAtlasTextureRegionFactory
createFromAsset (gameTextureAtlas, la actividad, "platform2.png").;
platform3_region = BitmapTextureAtlasTextureRegionFactory
createFromAsset (gameTextureAtlas, la actividad, "platform3.png").;
coin_region = BitmapTextureAtlasTextureRegionFactory createFromAsset
(gameTextureAtlas, la actividad, "coin.png").;

intentar
{
.. este gameTextureAtlas construcción (nueva
BlackPawnTextureAtlasBuilder <IBitmapTextureAtlasSource,
BitmapTextureAtlas> (0, 1, 0));
.. este gameTextureAtlas load ();
}
catch (e TextureAtlasBuilderException final)
 {
. De depuración e (e);
}
}

Como puede ver hemos creado nueva textura y cargamos 4 regiones de textura para
nuestras plataformas y monedas, los activos de carga de gfx / juego / carpeta. Bien, nuestro
Código de Recursos de carga está hecho, ahora vamos a tener cuidado acerca de diferentes
aspectos.

. 4 nivel Loading desde un archivo xml:

Clase GameScene Ahora abre de nuevo, que hay que cuidarla sobre el nivel de carga!

 en primer lugar, vamos a crear algunas variables necesarias para nuestro cargador
nivel:

static final Cadena TAG_ENTITY = "entidad" privada;

privado static final Cadena TAG_ENTITY_ATTRIBUTE_X = "x";
static final String TAG_ENTITY_ATTRIBUTE_Y privado = "y";
static final String TAG_ENTITY_ATTRIBUTE_TYPE privado = "tipo";

estática TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_PLATFORM1 objeto final privado

= "Platform1";
estática TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_PLATFORM2 objeto final privado
= "platform2";
estática TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_PLATFORM3 objeto final privado
= "platform3";
estática TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_COIN objeto final privado =
"moneda";

 Ahora vamos a crear el método responsable de la carga y el nivel de análisis de un

archivo xml, utilizaremos construido en andengine clase llamada
SimpleLevelLoader.

private void loadLevel (int levelID)

{
última SimpleLevelLoader levelLoader = new SimpleLevelLoader (vbom);

. definitiva FixtureDef FIXTURE_DEF = PhysicsFactory

createFixtureDef (0, 0,01 f 0,5 af);

levelLoader. registerEntityLoader (nueva EntityLoader

<SimpleLevelEntityLoaderData> (LevelConstants. TAG_LEVEL)
{
pública IEntity onLoadEntity (finales de Cuerdas pEntityName,
última IEntity pParent, Atributos pAttributes finales, finales
SimpleLevelEntityLoaderData pSimpleLevelEntityLoaderData) throws
IOException
{
 . definitiva int width = SAXUtils getIntAttributeOrThrow (.
pAttributes, LevelConstants TAG_LEVEL_ATTRIBUTE_WIDTH);
altura final int = SAXUtils getIntAttributeOrThrow
(pAttributes, LevelConstants TAG_LEVEL_ATTRIBUTE_HEIGHT.).;

/ / TODO adelante especificaremos LÍMITES cámara y crear

muros invisibles
/ / En el principio y en el final del nivel.

volver GameScene esto.;

}
});

levelLoader. registerEntityLoader (nueva EntityLoader

<SimpleLevelEntityLoaderData> (TAG_ENTITY)
{
pública IEntity onLoadEntity (finales de Cuerdas pEntityName,
última IEntity pParent, Atributos pAttributes finales, finales
SimpleLevelEntityLoaderData pSimpleLevelEntityLoaderData) throws
IOException
{
final int x = SAXUtils getIntAttributeOrThrow (pAttributes,
TAG_ENTITY_ATTRIBUTE_X).;
. finales int y = SAXUtils getIntAttributeOrThrow
(pAttributes, TAG_ENTITY_ATTRIBUTE_Y);
Tipo final String = SAXUtils getAttributeOrThrow
(pAttributes, TAG_ENTITY_ATTRIBUTE_TYPE).;

última levelObject Sprite;

if (tipo. iguales
(TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_PLATFORM1))
{
levelObject = new Sprite (. x, y, resourcesManager
platform1_region, vbom);
. PhysicsFactory createBoxBody (PhysicsWorld,
levelObject, Tipo de cuerpo StaticBody, FIXTURE_DEF.) SetUserData
("Platform1").;
}
else if (tipo. iguales
(TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_PLATFORM2))
{
levelObject = new Sprite (. x, y, resourcesManager
platform2_region, vbom);
cuerpo Body final = PhysicsFactory createBoxBody
(PhysicsWorld, levelObject, Tipo de cuerpo StaticBody, FIXTURE_DEF.).;
. setUserData cuerpo ("platform2");
. PhysicsWorld registerPhysicsConnector (nueva
PhysicsConnector (levelObject, cuerpo, true, false));
}
else if (tipo. iguales
(TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_PLATFORM3))
{
levelObject = new Sprite (. x, y, resourcesManager
platform3_region, vbom);
 cuerpo Body final = PhysicsFactory createBoxBody
(PhysicsWorld, levelObject, Tipo de cuerpo StaticBody, FIXTURE_DEF.).;
. setUserData cuerpo ("platform3");
. PhysicsWorld registerPhysicsConnector (nueva
PhysicsConnector (levelObject, cuerpo, true, false));
}
else if (tipo. equals
(TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_COIN))
{
levelObject = new Sprite (x, y,. resourcesManager
coin_region, vbom)
{
@ Override
protected void onManagedUpdate (flotar
pSecondsElapsed)
{
. súper onManagedUpdate (pSecondsElapsed);

/ **
* TODO
* Vamos a posterior comprobar si el jugador
choca con esto (con monedas)
* Y si lo hace, vamos a aumentar la puntuación
y se esconden de la moneda
* Que se completará en los próximos artículos
(después de crear código de jugador)
* /
}
};
levelObject registerEntityModifier (nueva
LoopEntityModifier (nueva ScaleModifier (1, 1, 1.3 f))).;
}
más
{
throw new IllegalArgumentException ();
}

levelObject setCullingEnabled (true).;

volver levelObject;
}
});

. levelLoader loadLevelFromAsset (".. lvl" actividad getAssets (),

"Nivel /" + levelID +);
}

Ahora voy a tratar de explicar lo que hace este código, en registerEntityLoader,

1) volvemos "entidad madre" de todas las entidades cargadas desde un archivo xml. En
otras palabras, entidad en la que todas las entidades cargadas se van a adjuntar. Como se
puede concluir, debemos volver nuestra escena del juego (como lo hacemos en el código
anterior)

2) en el segundo registerEntityLoader realmente Parse nuestro archivo xml, comprobamos

qué tipo es igual a la variable, si es igual a "Platform1" creamos y devolvemos nueva
sprites para nuestro primer tipo de plataforma, que también crean cuerpo y los datos del
usuario seleccionado "Platform1" ( después nos necesitaremos los datos del usuario para
reconocer objetos físicos en el interior de contactos oyente) Usted puede preguntar por qué
nosotros también registramos conector física en la plataforma 2 y la plataforma 3, lo
hacemos, porque, como usted debe deducir de la descripción plataformas en el principio de
este artículo, esas dos plataformas van a colapsar en ciertas circunstancias, que `s por eso
que registrarlo (tan sprites actualizará sus posiciones, cuerpo después) También tenemos el
código responsable de la creación de nuestra moneda, como se puede ver, hemos redefinido
método onManageUpdate, nos posteriormente utilizarlo para comprobar si el jugador choca
con la misma moneda, para ejecutar cierto código, como la creación de la moneda invisible
y añadiendo puntuación. También registramos modificador entidad escala bucle de la
moneda para hacer que se ve mejor (bit animados)

 ejecutar nuestro método de nueva creación dentro de un método createScene:

@ Override
public void createScene ()
{
createBackground ();
createHUD ();
createPhysics ();
loadLevel (1);
}

En este ejemplo, cargaremos archivo llamado 1.lvl desde / directorio / nivel de activos.

 crear archivo siguiente en el directorio de dar, y aquí `s ejemplo:

<? Xml version = "1.0" encoding = "UTF-8">

<Anchura level = altura "1000" = "780">
<Entidad x = "100" y = tipo "100" = "Platform1" />
<Entidad x = "200" y = tipo "200" = "Platform1" />
<Entidad x = "400" y = tipo "200" = "platform3" />
<Entidad x = "550" y = tipo "300" = "platform2" />
<Entidad x = "720" y = tipo "240" = "platform3" />
<Entidad x = "400" y = tipo "270" = "moneda" />
<Entidad x = "500" y = tipo "400" = "moneda" />
<Entidad x = "600" y = tipo "400" = "moneda" />
</ Nivel>
Después de ejecutar código de juego, usted debería ser capaz de ver el siguiente resultado
después de entrar en escena del juego, por ahora no hay a

Parte 12. Creación jugador.

En esta parte de mi serie de tutoriales, nos encargamos de la creación de nuestro código de

jugador. Como ya he mencionado en el artículo anterior, no me molestaré para crear arte
apariencia agradable, porque se crea este tutorial sólo con fines de aprendizaje de código.
Este es el arte de jugador usaré:

Tiene sólo tres baldosas, pero debería ser suficiente para la animación de ejecución de la
muestra, en nuestro reproductor de juego se ejecutará automáticamente en la dirección
correcta, el jugador controlará la función de salto.

. 1 Cargando recursos jugador:

Abrir nuestra clase ResourcesManager, crear nueva variable para la textura de azulejos
reproductor región:
player_region ITiledTextureRegion público;

 lets mostrarse la región, dentro de nuestras loadGameGraphics (método):

player_region =
BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset
(gameTextureAtlas, la actividad, "player.png", 3, 1);
No te olvides de poner a los jugadores dentro del directorio assets / gfx / juego gráfico.
Como puede ver, hemos cargado jugadores gráfico, tiene 3 columnas y 1 fila.

2 Código Creaing Player.:

Creamos código responsable de la carga del `s del jugador gráfico, ahora vamos a
tener cuidado acerca de jugador` s de clase. Crear una nueva clase llamada
jugador extendida por AnimatedSprite. Usted se verá obligado por eclipsar añadir
constructor. Modificaremos constructor poco.
. paquete com matimdev objeto.;

... org importación andengine motor de cámara Cámara.;

... org importación andengine entidad sprites AnimatedSprite.;
.... org importación andengine extensión física box2d PhysicsWorld.;
.... org importación andengine opengl vbo VertexBufferObjectManager;

.. import com matimdev gerente ResourcesManager.;

/ **
* @ Author Mateusz Mysliwiec
* @ Author www.matim-dev.com
* @ Version 1.0
* /
Jugador public abstract class extiende AnimatedSprite
{
/ / ---------------------------------------------
/ / CONSTRUCTOR
/ / ---------------------------------------------

Jugador público (pX, flotador pY, VertexBufferObjectManager vbo,

cámara de la cámara, PhysicsWorld PhysicsWorld)
{
super (pX, Py, ResourcesManager getInstance () player_region,
vbo..);
}
}

Hicimos esta clase abstracta, porque vamos a crear algunos métodos abstractos.
Como mencionamos modificamos constructor poco, como una región de textura, se utilizó
crear previamente región de textura de nuestro gestor de recursos. Necesitaremos también
algunos parámetros nuevos, tales como la cámara y el mundo de la física.

 crear nuevo campo para nuestro organismo jugador:

/ / ---------------------------------------------
/ / variables
/ / ---------------------------------------------
 cuerpo Body privado;

 crear nuevo método onDie abstracto () vamos a ejecutarlo cuando se produzcan

ciertos eventos.

public abstract void onDie ();

 crear nueva boolean marcar si el jugador puede saltar (como ya he dicho, si el

jugador va en primer lugar, la pantalla táctil, que hará que el jugador de ejecución, y
después de que cada lado táctil hará que el jugador salto) aquí `método responsable
de la creación del cuerpo de la física para el jugador es:

canRun private boolean = false;

createPhysics private void (cámara de la cámara final, PhysicsWorld

PhysicsWorld)
{
. cuerpo = PhysicsFactory createBoxBody (PhysicsWorld, este, Tipo de
cuerpo DynamicBody, PhysicsFactory createFixtureDef (0, 0, 0)..);

. setUserData cuerpo ("player");

. setFixedRotation cuerpo (true);

PhysicsWorld. registerPhysicsConnector (nueva PhysicsConnector

(esto, el cuerpo, verdadero, falso)
{
@ Override
public void onUpdate (flotar pSecondsElapsed)
{
. súper onUpdate (pSecondsElapsed);
cámara onUpdate (0.1 f).;

if (getY () <= 0)
{
onDie ();
}

si (canRun)
{
. setLinearVelocity cuerpo (nuevo Vector2 (5, el cuerpo
getLinearVelocity () y)..);
}
}
});
}
Lo que acabamos de hacer allí? Inicializamos jugadores cuerpo, ajuste los datos de usuario
para que podamos reconocer este último cuerpo en ciertos eventos (como el contacto entre
la detección de cuerpos), también fijamos la rotación del cuerpo fijo, por lo que el cuerpo
no rotará. Últimos registramos conector física (lo que el jugador `s sprite, se actualizará
automáticamente su posición, a raíz de cambios corporales) en el interior que reemplazar el
método onUpdate (), y utilizamos el método onUpdate cámara, ayuda a reducir el efecto de
cámara" jitering "mientras se mueve. En el extremo, creamos código comprobando jugador
`s Coordenada Y, si el jugador el` s Y es menor que 0, onDie será ejecutado. También
comprobamos si canRun booleano devuelve true, y si es así nos pusimos velocidad lineal
en el eje X para estimular plazo.

 ejecutar este método dentro de constructor. Permite también agregar código ajustes
de la cámara `s entidad persecución, por lo que la cámara seguirá la posición del
jugador` s.

Jugador público (pX, flotador pY, VertexBufferObjectManager vbo, cámara

de la cámara, PhysicsWorld PhysicsWorld)
{
super (pX, Py, ResourcesManager getInstance () player_region,
vbo..);
createPhysics (cámara, PhysicsWorld);
. cámara setChaseEntity (este);
}

 crear método responsable de establecer reproductor carrera y animar, ejecutaremos

este método, después del `s del primer contacto de la escena. Este último, la
próxima pantalla táctil hará que el jugador para saltar.

public void setRunning ()

{
canRun = true;

final larga [] PLAYER_ANIMATE = new long [] {100, 100, 100};

animar (PLAYER_ANIMATE, 0, 2, true);

}

Hemos definido la duración de cada jugador `s baldosa / marco (en milisegundos) que se
utiliza para la animación, también fijamos player para animar (continua estableciendo
último parámetro en true) animación de jugador` s región de azulejos de primera a última
baldosa (significa de 0 a 2, ya que primero el valor comienza desde 0 No 1) Por fin, hemos
establecido velocidad lineal al cuerpo en el eje X para establecer reproductor en
funcionamiento.

 crear método responsable de salto:

 public void salto ()
{
. setLinearVelocity cuerpo (. Vector2 nueva (cuerpo
getLinearVelocity () x, 12).);
}

Simplemente pusimos un poco de velocidad lineal en el eje Y, para estimular jugador salto.

player.java
Descargar archivo

. 3 Inicialización jugador en la escena:

Estamos plenamente implementado jugador lógica de clase, ahora le permite inicializar en

la escena, en primer lugar vamos a tener cuidado acerca de la implementación de la
posibilidad de capturar los eventos táctiles escena (para poder ejecutar la funcionalidad
salto jugador)

 abrir nuestra clase GameScene, y poner en práctica la clase

IOnSceneTouchListener. Usted se verá obligado por el eclipse de añadir método sin
aplicarse.

onSceneTouchEvent public boolean (escena pScene, TouchEvent

pSceneTouchEvent)
{
if (pSceneTouchEvent. isActionDown ())
{

}
return false;
}

 dentro de nuestro método createScene, añada esta línea para registrar esta escena
touch oyente:

setOnSceneTouchListener (este);

 vamos a tener cuidado acerca de la inicialización de jugador y colocándolo en la

escena, crear nuevo campo para el jugador, y el código que se utiliza para el
cargador nivel.
 estática TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_PLAYER objeto final privado =
"player";

jugador Estadisticas privado;

 agregar el código responsable de inicializar jugador dentro del código loader nivel,
tal como lo hicimos en el artículo anterior para las plataformas de carga y la moneda
de un archivo xml:

else if (type.equals (TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_PLAYER))

{
jugador = new Player (x, y, vbom, cámara, PhysicsWorld)
{
@ Override
public void onDie ()
{
/ / TODO Últimos vamos a manejarlo.
}
};
levelObject = jugador;
}

 Ahora sólo tiene que abrir nuestro archivo de datos de nivel, y poner la línea de
nuestro jugador:

<Entidad x = "60" y = "140" type = "player" />

Después de ejecutar el juego, debemos ser capaces de ver el jugador en nuestra primera
plataforma.
. 4 Ajuste jugador de ejecución y permitir saltar:

Bueno, ahora, cuando por fin tenemos a nuestro jugador en la escena, vamos a tener
cuidado acerca de las funciones de saltar y correr, como se ha mencionado, nuestro jugador
conterminously ejecutar (automáticamente) en la dirección correcta, después primer toque
de la pantalla, después de eso, cada toque siguiente hará que el jugador salta, bastante
simple, supongo. Para que crear nueva boolean, bandera saber si era el primer toque.

FirstTouch private boolean = false;

 ahora dentro onSceneTouchEvent permite ejecutar nuestra lógica:

onSceneTouchEvent public boolean (escena pScene, TouchEvent

pSceneTouchEvent)
{
if (pSceneTouchEvent. isActionDown ())
{
if (! FirstTouch)
{
. reproductor setRunning ();
FirstTouch = true;
}
más
{
. reproductor de salto ();
}
}
return false;
 }

Verificamos si la bandera FirstTouch es falsa, si es así nos pusimos jugador correr y cambio
de pabellón en true. Si la bandera es cierto, cada toque de pantalla hacen player salto.

 dentro disposeScene () método permite agregar código responsable de la

eliminación de entidad persecución.

camera.setChaseEntity (null);

Sin eso, después de regresar a la escena del menú, nos volveríamos a ver pantallas en
negro, ya que la cámara todavía siga nuestra posición del jugador.

That `s todo en este artículo, después de ejecutar nuestro código de juego, usted debería ser
capaz de ver el jugador, después de reproductor táctil primera pantalla debe empezar a
correr, después de cada otro debe saltar.

Notas: en la actualidad, el jugador puede saltar veces infinito, después de tocar tierra en
primer lugar, que será fijado en el artículo siguiente, donde se introducirá el contacto
oyente. En el próximo artículo también vamos a poner en práctica la moneda del `s de la
cosecha, reproductor de morir, y los límites grada cámara.
cciones, sólo cargamos objetos del juego de xml. En próximos artículos, voy a describir
cómo crear jugador, regulador del juego jugador que controla el movimiento `s y el código
responsable de las plataformas descritas funcionalidades. Haciendo capaz play-nuestro
juego.

Sale de la parte 13 de la cámara, reproductor de morir, el contacto de

escucha, misc.:

En este artículo vamos a poner en práctica algunas cosas de instalaciones como:

 sale de la cámara (límites)

 evento jugador die
 contacto oyente (posibilidad de fijar a saltar varias veces)
 permitir la moneda recogiendo posibilidad

. 1 Ajuste de los límites de la cámara:

Vamos a establecer cámara obligado a establecer ciertos límites en el movimiento de la

cámara, así que por ejemplo cámara no seguiremos jugador después de seguir hacia abajo y
morir. Se hará una parada en la cota 0 en el eje X. Lo primero que tenemos que hacer, es
cambiar nuestro tipo de cámara para
BoundCamera en lugar de la cámara.

 editar nuestra clase de actividad, cambiar el tipo de cámara para BoundCamera.

cámara = nueva BoundCamera (0, 0, 800, 480);

 editar BaseScene y clase ResourcesManager, en sustitución de la cámara con el tipo

BoundCamera.
 después de corregir todos los errores reportados por Eclipse (simplemente
cambiando el tipo de cámara) Clase GameScene abierta, permite establecer los
límites de la cámara, con base en los datos recibidos de los datos de nivel
presentadas.
 dentro de un método loadLevel, se puede ver de dos líneas (anchura y altura)
comentó que descomentar, y se deja poner límites cámara usarlos:

levelLoader.registerEntityLoader (nueva EntityLoader

<SimpleLevelEntityLoaderData> (LevelConstants.TAG_LEVEL)
{
pública IEntity onLoadEntity (finales de Cuerdas pEntityName, última
IEntity pParent, Atributos pAttributes finales, finales
SimpleLevelEntityLoaderData pSimpleLevelEntityLoaderData) throws
IOException
{
. definitiva int width = SAXUtils getIntAttributeOrThrow (.
pAttributes, LevelConstants TAG_LEVEL_ATTRIBUTE_WIDTH);
altura final int = SAXUtils getIntAttributeOrThrow (pAttributes,
LevelConstants TAG_LEVEL_ATTRIBUTE_HEIGHT.).;

cámara setBounds (0, 0, ancho, alto);. / / Aquí establecemos

límites de cámara
. setBoundsEnabled cámara (true);

volver GameScene esto.;

}
});

Fijamos cámara min. límites a (0x, 0y) y el máximo de los valores analizados desde un
archivo de nivel (en nuestro fichero previamente el nivel será (2000x, 700Y) a causa de esta
línea:

<level width="1000" height="780">

. 2 Recogiendo monedas:

Vamos a tener cuidado acerca de la posibilidad de recoger las monedas, añadir puntos a la
puntuación, y puso las monedas invisibles después de su recogida. Ir al código loadLevel, a
la línea en la que creamos la moneda, salimos onManageUpdate método comentado y
dejado de hacer, ahora vamos a insertar allí el código responsable de comprobar si el
jugador choca con la misma moneda. Ese `s la forma en que debe ser similar:

levelObject = new Sprite (x, y, resourcesManager.coin_region, vbom)

{
@ Override
protected void onManagedUpdate (flotar pSecondsElapsed)
{
. súper onManagedUpdate (pSecondsElapsed);

si (jugador. collidesWith (este))

{
addToScore (10);
. este setVisible (false);
. este setIgnoreUpdate (true);
}
}
};

Esta comprobación de código en cada actualización, si el jugador choca con la misma

moneda, y si lo hace, estamos agregando 10 puntos a la puntuación, el uso de este método
creado anteriormente, el establecimiento de la moneda a lo invisible, y el establecimiento
de la moneda de ignorar la actualización (por lo que no necesita actualizar la más, ya que su
ya cobrados)

. 3 del manejo del reproductor caso dado:

Ahora vamos a implementar jugador evento dado, cada vez que el jugador se va a caer
(jugador `valor Y menos de 0 segundo) vamos a mostrar" game over ". Últimos usted puede
implementar la función de reinicio del juego después de hacer clic en este mensaje o algo
similar, depende de sus necesidades, por ahora sólo permite visualizar el mensaje cada vez
que el jugador die (caer).

 crear dos nuevos campos de texto para más de juego del mensaje y de la bandera
boolean si este mensaje se haya mostrado ya (para evitar que se muestre)

gameOverText Texto privado;

private boolean gameOverDisplayed = false;

 crear el método de inicialización juego sobre el texto y el método de mostrarla:

void createGameOverText privado ()

{
gameOverText = new Texto (0, 0, resourcesManager fuente, el "Game
Over", vbom.);
 }

displayGameOverText private void ()

{
. cámara setChaseEntity (null);
gameOverText setPosition (cámara getCenterX (), cámara getCenterY
()..).;
attachChild (gameOverText);
gameOverDisplayed = true;
}

Método de visualización de juego sobre el texto, desactive en primer lugar, la cámara

entidad persecución, de juego de conjunto sobre el texto para la cámara actual `s posición
central, adjuntar el mensaje y la bandera se establece en true.

 método execute createGameOverText () en el método createScene ().

@ Override
public void createScene ()
{
createBackground ();
createHUD ();
createPhysics ();
loadLevel (1);
createGameOverText ();
setOnSceneTouchListener (este);
}

 ir a la función loadLevel, a la línea donde inicializamos nuestro jugador, dentro

onDie ejecutar código responsable de mostrar el juego sobre el texto, en primer
lugar, comprobar si no se visualiza:

@ Override
public void onDie ()
{
if (! gameOverDisplayed)
{
displayGameOverText ();
}
}

. 4 Desactivación posibilidad de múltiples salto, oyente de contacto:

Actualmente, por favor, que es capaz de saltar infinito multiplicado sin tierra en primer
lugar tocando, vamos a arreglarlo ahora, mediante el uso de truco sencillo combinado con
el contacto oyente.

 clase Player abierto, crear nuevo campo int para almacenar contacto `s de visitas:
 footContacts private int = 0;

 crear métodos para aumentar (+ +) y decremento (-) este valor

increaseFootContacts public void ()

{
footContacts + +;
}

decreaseFootContacts public void ()

{
footContacts -;
}

 modificar la función de salto para comprobar si este valor es mayor que 0. Si es así,
le dejaremos jugador para saltar. Vamos a aumentar este valor cada vez que el
jugador va a tocar la plataforma, y disminuir cada vez que va a terminar el contacto
con la plataforma.

public void salto ()

{
si (footContacts <1)
{
volver;
}
. setLinearVelocity cuerpo (. Vector2 nueva (cuerpo
getLinearVelocity () x, 12).);
}

 clase GameScene abierta, vamos a crear el contacto oyente. ¿Qué es? Nos permite
ejecutar código mientras que los eventos tales como el contacto comienzan /
extremo entre los accesorios que ocurre. Podemos reconocer Partidos / órganos,
estableciendo sus datos de usuario como lo hicimos, por ejemplo, para los jugadores
cuerpo por la configuración de sus datos de usuario a "jugador".

privado ContactListener contactListener ()

{
ContactListener contactListener = new ContactListener ()
{
public void beginContact (Contacto de contacto)
{
x1 Fixture final = contacto getFixtureA ().;
x2 Fixture final = contacto getFixtureB ().;
 if (x1. getBody (). getUserData ()! = x2 nula. && getBody
(). getUserData ()! = null)
{
if (x2. getBody (). getUserData (). equals ("player"))
{
. reproductor increaseFootContacts ();
}
}
}

public void endContact (Contacto de contacto)

{
x1 Fixture final = contacto getFixtureA ().;
x2 Fixture final = contacto getFixtureB ().;

if (x1. getBody (). getUserData ()! = x2 nula. && getBody

(). getUserData ()! = null)
{
if (x2. getBody (). getUserData (). equals ("player"))
{
. reproductor decreaseFootContacts ();
}
}
}

public void preSolve (Contacto de contacto, Colector

oldManifold)
{

public void postSolve (Contacto de contacto, ContactImpulse

impulso)
{

}
};
volver contactListener;
}

Aquí está, nuestro oyente contacto, en cada beginContact y endContact que en primer lugar,
comprobar si fixture A y B fixture tiene los datos del usuario (los accesorios de A y B son
accesorios entre determinado evento, como comenzar el contacto ocurre) Últimos
comprobamos si el usuario cuerpo x2 de datos es igual a "jugador" y en caso afirmativo que
aumentamos (en comenzar contacto) nuestro valor de contacto del pie o disminuirlo (en el
contacto final) Tenga en cuenta que el jugador podría también Fixture A (x1), de modo que
podría ser útil para comprobar también si x1 datos de usuario cuerpo es igual a jugador (E
n la práctica, se puede hacer una conjetura sobre qué dispositivo es que,
basada principalmente en el orden que creó las cosas en el mundo) En
este caso, por nuestro código debería funcionar bien.
  Regístrese Aqui oyente para nuestro mundo de la física, dentro de un
método responsable de la creación de nuestro mundo de la
física, como este:

createPhysics private void ()

{
PhysicsWorld = new FixedStepPhysicsWorld (60, nuevo Vector2 (0, -
17), false);
. PhysicsWorld setContactListener (contactListener ());
registerUpdateHandler (PhysicsWorld);
}

Listo, nos acabamos de arreglar nuestro problema "infinito salto", ahora debemos estar
bien, este último utilizaremos contacto oyente para agregar funciones para nuestras
plataformas (como la caída de las plataformas después del contacto con el jugador y así
sucesivamente) que `es todo por este artículo .

Parte 14. Aplicación de las trampas, los diferentes tipos de plataforma.

En número de artículo 11, le expliqué cuál es la función especial que vamos a aplicar para
las plataformas, como se ha mencionado no debe haber 3 tipos de plataformas:

 Plataforma 1 - plataforma estática normal, sin características especiales.

 Plataforma 2 - plataforma trampa, después de caer 0,2 seg. después del contacto con
el jugador.
 Plataforma 3 - cayendo de inmediato si hay contacto con el jugador.

Hacerlo va a ser muy fácil, puesto que ya creamos código responsable de los niveles de
carga, analizar el archivo de nivel y la creación de la escena del juego. Si usted recuerda,
establecemos diferentes `s de datos de usuario para las masas de cada tipo de plataforma ("
Platform1 "," platform2 "y" platform3 ") a los usuarios de datos` s nos ayudará a reconocer
los eventos que debemos ejecutar, cada vez que se estar en contacto entre ciertos
organismos / accesorios. Vamos a comprobar en nuestra Contacto Oyente dentro
GameScene.

. 1 de la plataforma - que cae inmediatamente.

Pensemos cómo podemos lograr fácilmente. Al principio, por defecto estamos creando
nuestros cuerpos plataformas como un tipo de cuerpo estático, lo que significa que no
reacciona con ninguna fuerza, como la gravedad, para hacer de nuestro cuerpo caer,
simplemente tenemos que cambiar el tipo de dinámica.

 ir a nuestra GameScene, nuestro código oyente contacto.

 dentro beginContact insertar nuevo cheque (el contacto entre "jugador" y
"platform3")
 if (x1.getBody (). getUserData (). igual ("platform3") && x2.getBody
(). getUserData (). iguales ("player"))
{
.. x1 getBody () setType (Tipo de cuerpo DynamicBody.);
}

¿Qué hace? Simplemente cambia nuestra platform3 tipo de cuerpo para dinámica, lo que
significa que también será afectada por la gravedad, lo que significa que se va a caer.

. 1 Plataforma - cayendo con retraso.

Vamos a hacer una función similar para nuestra próxima plataforma (platform2) esta vez,
vamos a utilizar un pequeño retraso antes de comenzar cayendo. Para hacerlo, utilizaremos
manejador temporizador simple.

 poner este código dentro beginContact, tal como lo hicimos con la plataforma
anterior.

if (x1.getBody (). getUserData (). igual ("platform2") && x2.getBody

(). getUserData (). iguales ("player"))
{
motor. registerUpdateHandler (nueva timerHandler (0.2 f, nuevo
ITimerCallback ()
{
public void onTimePassed (finales timerHandler pTimerHandler)
{
. pTimerHandler reset ();
. motor unregisterUpdateHandler (pTimerHandler);
.. x1 getBody () setType (Tipo de cuerpo DynamicBody.);
}
}));
}

¿Qué hace? En caso de contacto entre el jugador y platform2, registramos nuevo

controlador de temporizador, y después de 0,2 segundos estamos estableciendo plataformas
cuerpo dinámico. Logramos simple retraso.

Notas especiales:
Por favor, tenga en cuenta que en este artículo, le expliqué enfoque sólo muy básico.
Probablemente, depende del tipo de juego, usted debe tener cuidado acerca de la
destrucción de sprites plataforma y el cuerpo, después de que ya no se necesita (ejemplo
después de caerse, digamos por debajo de 0 en el eje Y)

 Blog
  Tutoriales
 Dispositivos Biblioteca
 Hoja informativa
 Descargar
 Contacto
 Mi trabajo
 Acerca de mí

Parte 15. Nivel ventana completa.

Creamos juego básico, que le da algunas ideas para crear su propio juego, Ahora vamos a
tener cuidado acerca de la ventana completa de nivel simple, mostrándonos rating / score
después de completar el nivel, vamos a utilizar el enfoque utilizado en muchos juegos,
delatar jugador por 1-3 estrellas.

 Vamos a utilizar este arte como una ventana completa de nivel (yeap, sé que mis
habilidades artísticas son hermosos!)

 además de este elemento sprite, azulejos para mostrar la cantidad de arranques

como marinero (1-3 estrellas) siguiente imagen es un sprite de baldosas, con 2
piezas.
Vamos a unir 3 sprites de baldosas a la ventana completa de nivel, y cambiaremos índice de
mosaico, con base en la cantidad de estrellas capa recibidos como una clasificación (1-3)

. 1 Cargando los recursos necesarios:

 Abrir nuestra clase ResourcesManager, crear dos nuevos campos para nuestras
regiones textura (una región es de baldosas de textura, se utilizará para las estrellas)

/ / Completa el nivel Window

complete_window_region ITextureRegion público;
complete_stars_region ITiledTextureRegion público;

 Dentro loadGameGraphics () cargar esas regiones:

complete_window_region =
BitmapTextureAtlasTextureRegionFactory.createFromAsset (gameTextureAtlas,
la actividad, "levelCompleteWindow.png");
complete_stars_region =
BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset
(gameTextureAtlas, la actividad, "star.png", 2, 1);

Estamos cargando archivos llamados levelCompleteWindow.png y Star.png de activos /

gfx / juego

. 2 Creación de ventana completa Nivel:

Para efectos de este artículo, rapidez creado esta clase sencilla, responsable de la creación y
la visualización de la ventana de nuestra completa Nivel personalizado. Compruebe el
código, y por debajo de usted encontrará información.

. paquete com matimdev extras.;

... org importación andengine motor de cámara Cámara.;

... org importación andengine entidad escena Escena.;
.... org importación andengine entidad Sprite Sprite;
... org importación andengine entidad sprites TiledSprite.;
.... org importación andengine opengl vbo VertexBufferObjectManager;

.. import com matimdev gerente ResourcesManager.;

 public class LevelCompleteWindow extiende Sprite
{
star1 TiledSprite privado;
star2 TiledSprite privado;
star3 TiledSprite privado;

StarsCount public enum

{
ONE,
DOS,
TRES
}

LevelCompleteWindow pública (VertexBufferObjectManager

pSpriteVertexBufferObject)
{
super (.. 0, 0, 650, 400, ResourcesManager getInstance ()
complete_window_region, pSpriteVertexBufferObject);
attachStars (pSpriteVertexBufferObject);
}

attachStars private void (VertexBufferObjectManager

pSpriteVertexBufferObject)
{
star1 = new TiledSprite (.. 150, 150, ResourcesManager
getInstance () complete_stars_region, pSpriteVertexBufferObject);
star2 = new TiledSprite (.. 325, 150, ResourcesManager
getInstance () complete_stars_region, pSpriteVertexBufferObject);
star3 = new TiledSprite (.. 500, 150, ResourcesManager
getInstance () complete_stars_region, pSpriteVertexBufferObject);

attachChild (star1);
attachChild (star2);
attachChild (star3);
}

/ **
* El índice de baldosas Cambio `s estrella, depende estrellas
cuentan.
* @ Param starsCount
* /
pantalla public void (StarsCount starsCount, escena escena, cámara
Cámara)
{
/ / Cambiar estrellas índice de mosaico, basado en estrellas
cuenta (1-3)
switch (starsCount)
{
Caso Uno:
. star1 setCurrentTileIndex (0);
. star2 setCurrentTileIndex (1);
. star3 setCurrentTileIndex (1);
romper;
Caso Dos:
. star1 setCurrentTileIndex (0);
. star2 setCurrentTileIndex (0);
 . star3 setCurrentTileIndex (1);
romper;
caso TRES:
. star1 setCurrentTileIndex (0);
. star2 setCurrentTileIndex (0);
. star3 setCurrentTileIndex (0);
romper;
}

/ / Ocultar el HUD
cámara getHUD () setVisible (false)..;

/ / Desactivar entidad cámara persecución

. cámara setChaseEntity (null);

/ / Adjuntar nuestro panel completo nivel en medio de la cámara

setPosition (. cámara getCenterX (), cámara getCenterY ().);
. escena attachChild (this);
}
}

 Utilizamos Sprite como una extensión, cambiamos constructor (simplificado)

utilizando región de textura cargado previamente para nuestra ventana completa el
nivel.
 método responsable de la creación de 3 baldosas sprites (estrellas) y adjuntarlos a
nuestra ventana completa nivel creado.
 método responsable de mostrar nuestra ventana creada, también creamos
enumeración para especificar cuántas estrellas deberíamos mostrar (una, dos o tres)
Depende de la cantidad de estrellas especificados como parámetro al llamar a
nuestra pantalla (método), estamos cambiando nuestra estrellas baldosas índice (así
que si usted va a poner las dos de constructores, dos estrellas serán de color
amarillo, y un gris) muy simple que creo. También tomamos la cámara y la escena
como parámetros, necesitamos objeto cámara para configurar HUD a la cámara
invisible y desactivar `s persiguiendo entidad mientras se muestra la ventana.

. 3 nivel Inicializando ventana completa:

De acuerdo, hemos creado el código para nuestra ventana, ahora deja inicializarla, abrir
nuestra clase GameScene, crear nuevo campo para la ventana.

levelCompleteWindow LevelCompleteWindow privado;

 inicializar dentro createScene método ():

levelCompleteWindow = new LevelCompleteWindow (vbom);

. 4 Viendo ventana completa Nivel:

Ahora tenemos que crear algo que se encargará de mostrar nuestra ventana, en nuestro
ejemplo, vamos a crear sprite, después de tocar con nuestro reproductor, aparecerá la
ventana completa el nivel.

 Vamos a cargarlo desde xml, como lo hacemos para las plataformas y monedas, en
primer lugar, crear una nueva etiqueta:

estática TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_LEVEL_COMPLETE objeto final

privado = "levelComplete";

 poner nuevo cheque dentro de código responsable de nivel de análisis (las mismas
plataformas como, moneda, etc)

else if (type.equals (TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_LEVEL_COMPLETE))

{
levelObject = new Sprite (x, y,. resourcesManager
complete_stars_region, vbom)
{
@ Override
protected void onManagedUpdate (flotar pSecondsElapsed)
{
. súper onManagedUpdate (pSecondsElapsed);

si (jugador. collidesWith (este))

{
. levelCompleteWindow pantalla (StarsCount DOS,
GameScene esto, la cámara..);
. este setVisible (false);
. este setIgnoreUpdate (true);
}
}
};
levelObject registerEntityModifier (nueva LoopEntityModifier (nueva
ScaleModifier (1, 1, 1.3 f))).;
}

Lo que hace, es la creación de nuevos sprites (con región de textura estrellas) en cada
actualización comprueba si chocan con el jugador, y si lo hace, nos mostrará la ventana
completa de nivel, en este caso con 2 estrellas como calificación (puedes cambiarlo,
cambiando el parámetro)

Para demostrar cómo funciona, modificar su archivo 1.lvl (archivo de datos de nivel) y
sustituirlo por:
 <? Xml version = "1.0" encoding = "UTF-8">
<Anchura level = altura "1400" = "780">
<Entidad x = "100" y = tipo "100" = "Platform1" />
<Entidad x = "200" y = tipo "200" = "Platform1" />
<Entidad x = "400" y = tipo "200" = "platform2" />
<Entidad x = "530" y = tipo "200" = "platform2" />
<Entidad x = "660" y = tipo "200" = "platform2" />
<Entidad x = "880" y = tipo "240" = "platform3" />
<Entidad x = "1100" y = "330" type = "platform3" />
<Entidad x = "400" y = tipo "270" = "moneda" />
<Entidad x = "500" y = tipo "400" = "moneda" />
<Entidad x = "600" y = tipo "400" = "moneda" />
<Entidad x = "1280" y = "550" type = "levelComplete" />
<Entidad x = "60" y = "140" type = "player" />
</ Nivel>

Sólo lo modifiqué este nivel un poco, para ser más capaz de jugar, y el nivel agregado
objeto completo al final del "nivel" probarlo para ver cómo funciona, la ventana completa
de nivel se debe mostrar (con 2 amarillo y uno inicio gris como un ejemplo)