Juegos en Android / Primeras modificaciones

Bienvenidos sean a este post, hoy comenzaremos con las primeras modificaciones en nuestro proyecto, las cuales seran la modificacion de ActividadJuego y la creacion de una nueva clase llamada GameEngine.

La clase ActividadJuego

Como siempre tendremos una clase de entrada para nuestro juego y esta no es otra que ActividadJuego, para comenzar modificaremos el codigo existente con el siguiente:

package org.example.invasores;

import android.app.Activity;
import android.graphics.Point;
import android.os.Bundle;
import android.view.Display;

public class ActividadJuego extends Activity {

    GameEngine mGameEngine;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Display display = getWindowManager().getDefaultDisplay();
        Point tamano = new Point();
        display.getSize(tamano);
        mGameEngine = new GameEngine(this,tamano);
        setContentView(mGameEngine);
    }

    @Override
    protected void onResume(){
        super.onResume();
        mGameEngine.startThread();
    }

    @Override
    protected void onPause(){
        super.onPause();
        mGameEngine.stopThread();
    }
}

Nuestra modificacion sera pasar de AppCompatActivity a Activity despues de extends, lo siguiente es crear un objeto de tipo GameEngine, les va a quedar en error pero hagan esto igualmente porque en breve lo solucionamos, despues en el metodo onCreate volvemos a usar las tres lineas que vinimos usando hasta ahora:

Display display = getWindowManager().getDefaultDisplay();
Point tamano = new Point();
display.getSize(tamano);

Con la primer linea obtenemos cual es el display predeterminado, con el siguiente estableceremos un Point para almacenar el tamaño de nuestra pantalla y este valor lo otendremos con nuestro ultima linea que en realidad establecera el valor maximo de x e y, la siguiente linea crea el objeto con el constructor y le pasaremos el entorno y el objeto con el tamaño de la pantalla, por ultimo tenemos al setContentView que sera la vista que mostraremos en pantalla y no sera otro que nuestro proxima clase, GameEngine, pero eso lo solucionaremos proximamente, por ultimo tenemos los dos metodos que se encargan de manejar nuestros threads, los cuales se encargaran de retomar (resume) y pausarlo (pause) pero estos dos metodos los veremos proximamente, con esto ya completamos nuestra clase ActividadJuego, pasemos a la siguiente.

La clase GameEngine

Para esta ocasion debemos crear a nuestra nueva clase y para ello debemos click con el boton derecho en la carpeta donde esta nuestra clase anterior, seleccionen New->Java Class aparecera un nuevo cuadro y completaremos estos campos:

• Nombre: GameEngine
• Tipo: Class

Con nuestra nueva clase vamos a proceder a modificar el codigo existente con el siguiente:

package org.example.invasores;

import android.content.Context;
import android.graphics.Point;
import android.util.Log;
import android.view.MotionEvent;
import android.view.SurfaceView;

class GameEngine extends SurfaceView implements Runnable {
    private Thread mThread = null;
    private long mFPS;

    public GameEngine(Context contexto, Point tamano){
        super(contexto);
    }

    @Override
    public void run(){
        long frameInicio = System.currentTimeMillis();
        long frameActual = System.currentTimeMillis() - frameInicio;
        if (frameActual >= 1){
            final int MILISEGUNDOS = 1000;
            mFPS = MILISEGUNDOS / frameActual;
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent evento){
        return true;
    }

    public void stopThread(){

        try{
            mThread.join();
        } catch (InterruptedException e){
            Log.e("Exception","stopThread" +
                    e.getMessage());
        }
    }

    public void startThread(){

        mThread = new Thread(this);
        mThread.start();
    }
}

Esta es la clase que usaremos para nuestro Game Engine, esta sera la base e iremos agregando mas codigo a medida que vayamos necesitando, lo primero que modificaremos en nuestra clase sera para hacerla heredera de la clase SurfaceView e implementara a la interfaz Runnable, despues crearemos un objeto de tipo Thread para manejar el thread de nuestro juego, luego crearemos una variable la cual usaremos para almacenar los fps (frames-per-seconds), el siguiente bloque sera el constructor para nuestra clase, la cual recibe el contexto y el tamaño de la pantalla, y lo unico que hara por ahora es llamar al constructor de la clase maestra y le informa el contexto, nuestro siguiente metodo es el siguiente:

    @Override
    public void run(){
        long frameInicio = System.currentTimeMillis();
        long frameActual = System.currentTimeMillis() - frameInicio;
        if (frameActual >= 1){
            final int MILISEGUNDOS = 1000;
            mFPS = MILISEGUNDOS / frameActual;
        }
    }

Este metodo existe primero para poder implementar a la interfaz Runnable pero tambien sera la encargada de actualizar todos nuestros objetos y a su vez dibujara las nuevas posiciones de nuestros objetos, por ahora en este bloque definiremos dos variables una llamada frameInicio para saber cual es el momento en que se inicio el juego y la siguiente es frameActual la cual almacenara la diferencia entre el tiempo actual y el almacenado en frameInicio, luego tendremos un condicional donde verifica si frameActual es mayor o igual a uno y en caso de ser cierto crearemos una constante llamada MILISEGUNDOS para utilizarla en la siguiente linea donde asignaremos el valor a mFPS siendo la division de la constante por el valor almacenado en frameActual, con esto sabremos cuantos fps puede manejar el dispositivo, con esto completamos por ahora este metodo, nuestro siguiente metodos es este:

    @Override
    public boolean onTouchEvent(MotionEvent evento){
        return true;
    }

Este sera el encargado de manejar nuestros toques en pantalla pero por ahora solamente devolvera el valor true, pasemos a los ultimos dos metodos:

    public void stopThread(){

        try{
            mThread.join();
        } catch (InterruptedException e){
            Log.e("Exception","stopThread" +
                    e.getMessage());
        }
    }

    public void startThread(){

        mThread = new Thread(this);
        mThread.start();
    }

Estos dos metodos se encargan de manejar la conducta del thread de nuestro juego, el primero se encarga de detenerlo y para esta ocasion usaremos un bloque try/catch por si surge algun error, en el bloque try usaremos a join para detener a nuestro thread (mThread), y el catch lo usaremos para interceptar cualquier excepcion de interrupcion y la escribiremos en el log para saber porque fallo, en cambio el metodo startThread es mas directo y genera una nuevo objeto y lo inicia por medio de start, esto ya sea porque esta iniciando el juego o esta retomando el mismo, si observamos ahora a nuestras dos clases estaran libres de errores pero no cumplen ninguna accion.

En resumen, hoy hemos creado nuestra actividad principal, tal como vinimos haciendo hasta ahora, despues creamos a nuestro Game Engine, la hicimos heredera e implementamos la interfaz tal como vinimos trabajando hasta ahora, agregamos todos los metodos que se necesitan en esta para implementarla y tambien los metodos que nos faltaban en la clase principal, espero les haya gustado sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.

Tengo un Patreon donde podes acceder de manera exclusiva a material para este blog antes de ser publicado, sigue los pasos del link para saber como.