Diana Jazmín Rojas Alvarado 1219382

Mónica Rosario Cruz Hernández 1334360

Patricia Cárdenas Suarez 1443698

Leonardo Rafael Peña Hernández 1420729

Héctor Rosas Taraco 1458975

Es la segunda parte de entrega del Proyecto Integrador I, el cual es un juego, fue codificado en java, para tener usabilidad en la plataforma de Android. Este proyecto consta de diferentes herramientas:

Una palanca que permite el mando de la nave que permite desplazarse por el área de juego.

Una opción de disparo que nos sirve para destruir a los enemigos que aparecerán a lo largo del juego.

Así como estas herramientas tenemos la barra de vida que nos permitirá indicar cuánto daño han causado a nuestra nave.

En el juego:

El usuario será capaz de manipular una nave, la cual cuenta con una opción de disparar, para asi destruir las naves enemigas, si no las destruye disminuye las vidas de la nave, así cuando ya no tenga mas, el juego terminara.

Esta aplicación tiene como objetivo entretener al usuario que decide bajar nuestra aplicación, siendo muy

amigable en interfaz grafica, así como un fácil uso.

En el inicio del semestre nos planteamos el proyecto a presentar, así como involucrarnos en la temática y familiarizarnos con las herramientas para su creación.

Después de medio curso nos hemos enfocado a la creación de la aplicación desde el diseño hasta la programación.

// se declara objeto Player_1

static final int VelocityPlayer_1 = 300;

private Player Player_1;

// Cargamos la carpeta de recursos gfx, donde estan las imágenes que usaremos para la nave, mapa, enemigos y disparos.

BitmapTextureRegionFactory.setAssetBasePath("gfx/");

// asignamos un espacio para Player_1, su imagen, textura y posición inicial

this.BitmapTexture_Player_1 = new BitmapTexture(128, 128,

TextureOptions.DEFAULT);

this.TextureRegion_Player1 = BitmapTextureRegionFactory

.createTiledFromAsset(this.BitmapTexture_Player_1, this,

"Player_1.png", 0, 0, 1, 1);

this.mEngine.getTextureManager().loadTexture(

this.BitmapTexture_Player_1);

// Cargamos el mapa a la Pantalla y el player al mapa

this.BackgroundTexture = new BitmapTexture(1024, 1024,

TextureOptions.DEFAULT);

this.BackgroundLayerBack = BitmapTextureRegionFactory.createFromAsset(

this.BackgroundTexture, this, "background.png", 0, 0);

this.mEngine.getTextureManager().loadTextures(

this.BitmapTexture_Player_1, this.BackgroundTexture);

// Camarastatic final int CAMERA_WIDTH = 800;static final int CAMERA_HEIGHT = 480;al intCAMERA_HEIGHT = 480;

// Margenes Pantallapublic Shape ground;public Shape roof;public Shape left; public Shape right;

ground = new Rectangle(0, CAMERA_HEIGHT - 25, CAMERA_WIDTH, 25);roof = new Rectangle(0, 0, CAMERA_WIDTH, 25);left = new Rectangle(0, 0, 50, CAMERA_HEIGHT);right = new Rectangle(CAMERA_WIDTH - 50, 0, 50, CAMERA_HEIGHT);

//Pondremos como no visibles los margenes ya que solo se deben mostrar durante el juego

ground.setVisible(false);

roof.setVisible(false);

left.setVisible(false);

right.setVisible(false);

scene.attachChild(ground);

scene.attachChild(roof);

scene.attachChild(left);

scene.attachChild(right);

// Declaración de objeto enemigo, su bitmap , su textura , cantidad de enemigos y una lista que nos ayudara a enlistar la manera en que aparecerán.

private BitmapTexture BitmapTexture_EnemyUFO;

private TiledTextureRegionTextureRegion_EnemyUFO;

public int num_Enemy = 5;

private ArrayList<Enemy> listaEnemigos = new ArrayList<Enemy>();

// Asignacion de espacio, textura, imagen y posicion del enemigo

this.BitmapTexture_EnemyUFO = new BitmapTexture(512, 512,

TextureOptions.DEFAULT);

this.TextureRegion_EnemyUFO = BitmapTextureRegionFactory

.createTiledFromAsset(this.BitmapTexture_EnemyUFO, this,

"EnemyUFO.png", 0, 0, 8, 5);

this.mEngine.getTextureManager().loadTexture(

this.BitmapTexture_EnemyUFO);

//Declaracion del Joystick, para el movimiento de la nave

private DigitalOnScreenControlmDigitalOnScreenControl;

private BitmapTexture mOnScreenControlTexture;

private TextureRegionmOnScreenControlBaseTextureRegion;

private TextureRegionmOnScreenControlKnobTextureRegion;

public float DigitalControlX = 0;

public float DigitalControlY = 0;

// Cargamos las imagenes del joystick, dandole un espacio, textura y posicion dentro del mapa

this.mOnScreenControlTexture = new BitmapTexture(256, 128,

TextureOptions.BILINEAR_PREMULTIPLYALPHA);

this.mOnScreenControlBaseTextureRegion = BitmapTextureRegionFactory

.createFromAsset(this.mOnScreenControlTexture, this,

"onscreen_control_base.png", 0, 0);

//Cargamos el control de movimiento digital

this.mOnScreenControlKnobTextureRegion = BitmapTextureRegionFactory

.createFromAsset(this.mOnScreenControlTexture, this,

"onscreen_control_knob.png", 128, 0);

this.mEngine.getTextureManager().loadTextures(

this.BitmapTexture_Player_1, this.mOnScreenControlTexture);

// Declaración de Boton dispararprivate BitmapTexture BitmapTexture_boton_Disparo;private TextureRegion TextureRegion_boton_Disparo;

// Cargamos la imagen Boton disparo, en un espacio, con textura y su posicionBitmapTexture_boton_Disparo = new BitmapTexture(128, 128,TextureOptions.DEFAULT);TextureRegion_boton_Disparo = BitmapTextureRegionFactory.createFromAsset(BitmapTexture_boton_Disparo, this,"botonDisparar.png", 0, 0);mEngine.getTextureManager().loadTexture(this.BitmapTexture_boton_Disparo);

//Declaración del Disparo

private BitmapTexture BitmapTexture_Disparo;

public TiledTextureRegion TextureRegion_Disparo;

private ArrayList<Disparo> listaDisparos = new ArrayList<Disparo>();

public boolean flag_disparo = false;

// Agregamos el Disparoa la pantalla en un espacio, con textura y la posicion inicial

this.BitmapTexture_Disparo = new BitmapTexture(64, 64,

TextureOptions.DEFAULT);

this.TextureRegion_Disparo = BitmapTextureRegionFactory

.createTiledFromAsset(this.BitmapTexture_Disparo, this,

"disparo.png", 0, 0, 1, 2);

this.mEngine.getTextureManager()

.loadTexture(this.BitmapTexture_Disparo);

// Level Live

public Rectangle level_life;

private BitmapTexture BitmapTexture_level_life_Background;

private TextureRegion TextureRegion_level_life_Background;

// Cargamos imagenes de la barra de vida con sus datos correspondientes

BitmapTexture_level_life_Background = new BitmapTexture(128, 32,

TextureOptions.DEFAULT);

TextureRegion_level_life_Background = BitmapTextureRegionFactory

.createFromAsset(this.BitmapTexture_level_life_Background,

this, "level_life_background.png", 0, 0);

mEngine.getTextureManager().loadTexture(

BitmapTexture_level_life_Background);

Gracias a que en temáticas de juegos siempre puede haber mejoras de diseño o complejidad, nos hemos trazado el objetivo de aumentar la dificultad para el usuario, por ejemplo poner ya sea obstáculos y enemigos mas imponentes.

Tuvimos dificultades desde el principio, en el diseño, en el planteamiento, y también en el código.

La creación de enemigos, así como la terminación del juego son planteamientos que se deben iniciar antes de codificar. Tener la idea antes es primordial.

Ampliamos nuestro conocimiento sobre aplicaciones android.