Juegos en Android / Invasores del espacio

Bienvenidos sean a este post, en el post de hoy les traigo el codigo final de nuestro quinto proyecto.

Al igual que vinimos haciendo cada vez que finalizamos un proyecto o juego, les paso el codigo completo, sin explicacion, para compararlo o ver como que es para realizarlo, en caso de necesitar una explicacion de alguna parte les dejo el listado de todos los posts donde lo trabajamos:

• Nuestro quinto proyecto
• Primeras modificaciones
• La clase GameState
• Seguimos con GameState
• La clase SoundEngine
• Diseñando el HUD
• La clase Renderer
• El patron Observador
• La clase UIcontroladora
• Agregando la explosion
• Creando las fisicas
• Las especificaciones de los objetos
• Las interfaces de los componentes
• Las clases de componentes para el fondo y el jugador
• La clase Transformar
• La clase GameObjeto
• Completando al jugador
• Completemos el fondo
• La fabrica
• La clase nivel
• Implementando todo
• El movimiento del Chaser y los laser
• El resto de los componentes Aliens
• Generando a los aliens
• Detectando colisiones

Este es el archivo de los sonidos del juego

Este es el archivo de las imagenes en el juego

Las caracteristicas para la creacion de este proyecto son las siguientes:

• Dispositivos: Phone and Tablet
• Actividad: Empty Activity
• Nombre: Invasores del Espacio
• Nombre de paquete: org.example.invasores
• API Minimo: API 14 (Android 4.0)

Comencemos con los codigos de las distintas clases, un detalle a tener en cuenta es que entre las clases habra interfaces por lo que se deben fijar si es una clase o una interfaz antes de crearla, tambien hay una de tipo abstracta, sin mas preambulos estos son los codigos para crear el proyecto:

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="org.example.invasores">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".ActividadJuego"
            android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
            android:screenOrientation="landscape">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

ActividadJuego

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();
    }
}

AlienChaserEspec

package org.example.invasores;

import android.graphics.PointF;

class AlienChaserEspec extends ObjetoEspec {
    private static final String tag = "alien";
    private static final String bitmapNombre = "alien_ship1";
    private static final float velocidad = 4f;
    private static final PointF escalaRelativa =
            new PointF(15f,15f);
    private static final String[] componentes = new String[]{
            "ComponentesGraficosStd",
            "ComponenteAlienChaserMovimiento",
            "ComponenteGeneraAlienHorizontal"};

    AlienChaserEspec(){
        super(tag, bitmapNombre,
                velocidad,
                escalaRelativa,
                componentes);
    }
}

AlienDiverEspec

package org.example.invasores;

import android.graphics.PointF;

class AlienDiverEspec extends ObjetoEspec {
    private static final String tag = "alien";
    private static final String bitmapNombre = "alien_ship3";
    private static final float velocidad = 4f;
    private static final PointF escalaRelativa =
            new PointF(60f,30f);
    private static final String[] componentes = new String[]{
            "ComponentesGraficosStd",
            "ComponenteAlienDiverMovimiento",
            "ComponenteGeneraAlienVertical"};

    AlienDiverEspec(){
        super(tag, bitmapNombre,
                velocidad,
                escalaRelativa,
                componentes);
    }
}

AlienLaseEspec

package org.example.invasores;

import android.graphics.PointF;

class AlienLaseEspec extends ObjetoEspec {
    private static final String tag = "alien laser";
    private static final String bitmapNombre = "alien_laser";
    private static final float velocidad = .75f;
    private static final PointF escalaRelativa =
            new PointF(14f,160f);
    private static final String[] componentes = new String[]{
            "ComponentesGraficosStd",
            "ComponenteLaserMovimiento",
            "ComponenteGeneraLaser"};

    AlienLaseEspec(){
        super(tag, bitmapNombre,
                velocidad,
                escalaRelativa,
                componentes);
    }
}

AlienPatrolEspec

package org.example.invasores;

import android.graphics.PointF;

class AlienPatrolEspec extends ObjetoEspec {
    private static final String tag = "alien";
    private static final String bitmapNombre = "alien_ship2";
    private static final float velocidad = 5f;
    private static final PointF escalaRelativa =
            new PointF(15f,15f);
    private static final String[] componentes = new String[]{
            "ComponentesGraficosStd",
            "ComponenteAlienPatrolMovimiento",
            "ComponenteGeneraAlienHorizontal"};

    AlienPatrolEspec(){
        super(tag, bitmapNombre,
                velocidad,
                escalaRelativa,
                componentes);
    }
}

ComponenteAlienChaserMovimiento

package org.example.invasores;

import android.graphics.PointF;

import java.util.Random;

class ComponenteAlienChaserMovimiento implements ComponenteMovimiento {
    private Random mDisparoAlazar = new Random();
    private GeneradorLaserAlien generadorLaserAlien;

    ComponenteAlienChaserMovimiento (GeneradorLaserAlien gla){
        generadorLaserAlien = gla;
    }

    @Override
    public boolean mover(long fps, Transformar t,
                         Transformar jugadorTransformar){
        final int TOMAR_DISPARO = 0;
        final int CHANCE_DISPARO = 100;

        float anchoPantalla = t.getTamanoPantalla().x;
        PointF ubicacionJugador = jugadorTransformar.getPosicion();

        float altura = t.getObjetoAltura();
        boolean mirandoDerecha = t.getMirandoDerecha();

        float mDistanciaPersecucion = t.getTamanoPantalla().x / 3f;
        float mDistanciaVision = t.getTamanoPantalla().x / 1.5f;
        PointF ubicacion = t.getPosicion();
        float velocidad = t.getVelocidad();

        float diferenciaVelocidadVertical = .3f;
        float reduccionRelativaAlJugador = 1.8f;
        float reboteBusquedaVertical = 20f;

        if (Math.abs(ubicacion.x - ubicacionJugador.x)
                > mDistanciaPersecucion){
            if (ubicacion.x < ubicacionJugador.x){
                t.apuntarDerecha();
            }
            else if (ubicacion.x > ubicacionJugador.x) {
                t.apuntarIzquierda();
            }
        }

        if (Math.abs(ubicacion.x - ubicacionJugador.x)
                <= mDistanciaVision){

            if ((int) ubicacion.y - ubicacionJugador.y
                    < -reboteBusquedaVertical){
                t.apuntarAbajo();
            }
            else if ((int) ubicacion.y - ubicacionJugador.y
                    > reboteBusquedaVertical){
                t.apuntarArriba();
            }

            if (!jugadorTransformar.getMirandoDerecha()) {
                ubicacion.x += velocidad * reduccionRelativaAlJugador/fps;
            } else {
                ubicacion.x -= velocidad * reduccionRelativaAlJugador/fps;
            }
        } else {
            t.pararVertical();
        }

        if (t.apuntandoAbajo()){
            ubicacion.y += velocidad * diferenciaVelocidadVertical / fps;
        }
        else if (t.apuntandoArriba()) {
            ubicacion.y -= velocidad * diferenciaVelocidadVertical / fps;
        }

        if (t.apuntandoIzquierda())
            ubicacion.x -= (velocidad) / fps;

        if (t.apuntandoDerecha())
            ubicacion.x += (velocidad) / fps;

        t.actualizaColision();

        if (mDisparoAlazar.nextInt(CHANCE_DISPARO) == TOMAR_DISPARO ){
            if (Math.abs(ubicacionJugador.y - ubicacion.y) < altura){
                if ((mirandoDerecha && ubicacionJugador.x > ubicacion.x
                        || !mirandoDerecha && ubicacionJugador.x < ubicacion.x)
                        && Math.abs(ubicacionJugador.x - ubicacion.x)
                        < anchoPantalla){
                    generadorLaserAlien.generaLaserAlien(t);
                }
            }
        }

        return true;
    }
}

ComponenteAlienDiverMovimiento

package org.example.invasores;

import android.graphics.PointF;

import java.util.Random;

class ComponenteAlienDiverMovimiento implements ComponenteMovimiento {
    @Override
    public boolean mover(long fps,
                         Transformar t,
                         Transformar jugadorTransformar){
        PointF ubicacion = t.getPosicion();
        float velocidad = t.getVelocidad();
        float reduccionRelativaAlJugador = 1.8f;

        if (!jugadorTransformar.getMirandoDerecha()){
            ubicacion.x += velocidad * reduccionRelativaAlJugador / fps;
        } else {
            ubicacion.x -= velocidad * reduccionRelativaAlJugador / fps;
        }

        ubicacion.y += velocidad / fps;

        if (ubicacion.y > t.getTamanoPantalla().y){
            Random random = new Random();
            ubicacion.y = random.nextInt(300) - t.getObjetoAltura();
            ubicacion.x = random.nextInt((int) t.getTamanoPantalla().x);
        }

        t.actualizaColision();
        return true;
    }
}

ComponenteAlienPatrolMovimiento

package org.example.invasores;

import android.graphics.PointF;

import java.util.Random;

class ComponenteAlienPatrolMovimiento implements ComponenteMovimiento {
    private GeneradorLaserAlien generadorLaserAlien;
    private Random mDisparoAlAzar = new Random();

    ComponenteAlienPatrolMovimiento(GeneradorLaserAlien gla){
        generadorLaserAlien = gla;
    }

    @Override
    public boolean mover(long fps,
                         Transformar t,
                         Transformar jugadorTransformar){
        final int TOMAR_DISPARO = 0;
        final int CHANCE_DISPARO = 100;
        PointF ubicacionJugador = jugadorTransformar.getPosicion();
        final float LIMITE_MINIMO_VERTICAL = 0;
        float pantallaX = t.getTamanoPantalla().x;
        float pantallaY = t.getTamanoPantalla().y;
        float mDistanciaVision = pantallaX * .5f;
        PointF pos = t.getPosicion();
        float velocidad = t.getVelocidad();
        float altura = t.getObjetoAltura();
        final float LIMITE_MAXIMO_VERTICAL = pantallaY - altura;
        final float LIMITE_MINIMO_HORIZONTAL = 2 * -pantallaX;
        final float LIMITE_MAXIMO_HORIZONTAL = 2 * pantallaX;
        float ajusteVelocHorizRelativaAlJugador = 0;
        float modifAjusteVelocidadHorizontal = .8f;

        if (Math.abs(pos.x - ubicacionJugador.x) < mDistanciaVision){
            if (jugadorTransformar.getMirandoDerecha()
                    != t.getMirandoDerecha()){
                ajusteVelocHorizRelativaAlJugador = velocidad
                        * modifAjusteVelocidadHorizontal;
            } else {
                ajusteVelocHorizRelativaAlJugador =
                        -(velocidad * modifAjusteVelocidadHorizontal);
            }
        }

        if (t.apuntandoIzquierda()){
            pos.x -= (velocidad - ajusteVelocHorizRelativaAlJugador)
                    / fps;
            if (pos.x < LIMITE_MINIMO_HORIZONTAL){
                pos.x = LIMITE_MINIMO_HORIZONTAL;
                t.apuntarDerecha();
            }
        } else {
            pos.x += (velocidad + ajusteVelocHorizRelativaAlJugador)
                    / fps;
            if (pos.x > LIMITE_MAXIMO_HORIZONTAL){
                pos.x = LIMITE_MAXIMO_HORIZONTAL;
                t.apuntarIzquierda();
            }
        }

        if (t.apuntandoAbajo()){
            pos.y += (velocidad)/fps;
            if (pos.y > LIMITE_MAXIMO_VERTICAL)
                t.apuntarArriba();
        } else {
            pos.y -= (velocidad)/fps;
            if (pos.y < LIMITE_MINIMO_VERTICAL)
                t.apuntarAbajo();
        }

        t.actualizaColision();

        if (Math.abs(mDisparoAlAzar.nextInt(CHANCE_DISPARO))
                == TOMAR_DISPARO){
            if (Math.abs(ubicacionJugador.y - pos.y) < altura){
                if ((t.getMirandoDerecha() && ubicacionJugador.x > pos.x
                        || !t.getMirandoDerecha() && ubicacionJugador.x
                        < pos.x)
                        && Math.abs(ubicacionJugador.x - pos.x)
                        > pantallaX){
                    generadorLaserAlien.generaLaserAlien(t);
                }
            }
        }

        return true;
    }
}

ComponenteEntrada

package org.example.invasores;

interface ComponenteEntrada {
    void setTransformar(Transformar t);
}

ComponenteEntradaJugador

package org.example.invasores;

import android.graphics.Rect;
import android.view.MotionEvent;

import java.util.ArrayList;

class ComponenteEntradaJugador implements ComponenteEntrada,
        InputObservador {

    private Transformar mTransformar;
    private GeneradorLaserJugador mGLJ;

    ComponenteEntradaJugador(GameEngine ger){
        ger.addObservador(this);
        mGLJ = ger;
    }

    @Override
    public void setTransformar(Transformar transformar){
        mTransformar = transformar;
    }

    @Override
    public void handleInput(MotionEvent evento,
                            GameState estadoJuego,
                            ArrayList<Rect> botones){
        int i = evento.getActionIndex();
        int x = (int)evento.getX(i);
        int y = (int)evento.getY(i);

        switch(evento.getAction() & MotionEvent.ACTION_MASK){
            case MotionEvent.ACTION_UP:
                if (botones.get(HUD.ARRIBA).contains(x,y)
                        || botones.get(HUD.ABAJO).contains(x,y)){
                    mTransformar.pararVertical();
                }
                break;
            case MotionEvent.ACTION_DOWN:
                if (botones.get(HUD.ARRIBA).contains(x,y))
                    mTransformar.apuntarArriba();
                else if (botones.get(HUD.ABAJO).contains(x,y))
                    mTransformar.apuntarAbajo();
                else if (botones.get(HUD.VUELTA).contains(x,y))
                    mTransformar.voltear();
                else if (botones.get(HUD.DISPARO).contains(x,y))
                    mGLJ.generaLaserJugador(mTransformar);
                break;
            case MotionEvent.ACTION_POINTER_UP:
                if (botones.get(HUD.ARRIBA).contains(x,y)
                        || botones.get(HUD.ABAJO).contains(x,y)){
                    mTransformar.pararVertical();
                }
                break;
            case MotionEvent.ACTION_POINTER_DOWN:
                if (botones.get(HUD.ARRIBA).contains(x,y))
                    mTransformar.apuntarArriba();
                else if (botones.get(HUD.ABAJO).contains(x,y))
                    mTransformar.apuntarAbajo();
                else if (botones.get(HUD.VUELTA).contains(x,y))
                    mTransformar.voltear();
                else if (botones.get(HUD.DISPARO).contains(x,y))
                    mGLJ.generaLaserJugador(mTransformar);
                break;
        }
    }
}

ComponenteFondoMovimiento

package org.example.invasores;

class ComponenteFondoMovimiento implements ComponenteMovimiento {

    @Override
    public boolean mover(long fps,
                      Transformar t,
                      Transformar jugadorTransformar){
        int actualXClip = t.getXClip();

        if (jugadorTransformar.getMirandoDerecha()){
            actualXClip -= t.getVelocidad() / fps;
            t.setXClip(actualXClip);
        } else {
            actualXClip += t.getVelocidad() / fps;
            t.setXClip(actualXClip);
        }

        if (actualXClip >= t.getTamano().x){
            t.setXClip(0);
            t.flipPrimeraInvertida();
        }
        else if (actualXClip <= 0){
            t.setXClip((int)t.getTamano().x);
            t.flipPrimeraInvertida();
        }

        return true;
    }

}

ComponenteGeneraAlienHorizontal

package org.example.invasores;

import android.graphics.PointF;

import java.util.Random;

class ComponenteGeneraAlienHorizontal implements ComponenteGenerar{
    @Override
    public void generar(Transformar jugadorTransformar,
                        Transformar t){
        PointF tp = t.getTamanoPantalla();
        Random random = new Random();
        boolean izquierda = random.nextBoolean();
        float distancia = random.nextInt(2000)
                + t.getTamanoPantalla().x;
        float generaAltura = random.nextFloat()
                * tp.y - t.getTamano().y;

        if (izquierda){
            t.setPosicion(-distancia,generaAltura);
            t.apuntarDerecha();
        } else {
            t.setPosicion(distancia,generaAltura);
            t.apuntarIzquierda();
        }
    }
}

ComponenteGeneraAlienVertical

package org.example.invasores;

import java.util.Random;

class ComponenteGeneraAlienVertical implements ComponenteGenerar {
    @Override
    public void generar(Transformar jugadorTransformar,
                        Transformar t){
        Random random = new Random();
        float posicionX = random.nextInt((int)
                t.getTamanoPantalla().x);
        float alturaGenera = random.nextInt(300)
                - t.getObjetoAltura();
        t.setPosicion(posicionX,alturaGenera);
        t.apuntarAbajo();
    }
}

ComponenteGeneraFondo

package org.example.invasores;

class ComponenteGeneraFondo implements ComponenteGenerar {

    @Override
    public void generar(Transformar jugadorTransformar,
                        Transformar t){
        t.setPosicion(0f,0f);
    }
}

ComponenteGeneraJugador

package org.example.invasores;

class ComponenteGeneraJugador implements ComponenteGenerar {
    @Override
    public void generar(Transformar jugadorTransformar,
                        Transformar t){
        t.setPosicion(t.getTamanoPantalla().x/2,
                t.getTamanoPantalla().y/2);
    }
}

ComponenteGeneraLaser

package org.example.invasores;

import android.graphics.PointF;

class ComponenteGeneraLaser implements ComponenteGenerar {
    @Override
    public void generar(Transformar jugadorTransformar,
                        Transformar t){
        PointF posicionInicial = jugadorTransformar
                .getPosicionDisparo(t.getTamano().x);
        t.setPosicion((int)posicionInicial.x,
                (int)posicionInicial.y);

        if(jugadorTransformar.getMirandoDerecha())
            t.apuntarDerecha();
        else
            t.apuntarIzquierda();
    }
}

ComponenteGenerar

package org.example.invasores;

interface ComponenteGenerar {
    void generar(Transformar jugadorTransformar,
                 Transformar t);
}

ComponenteGraficos

package org.example.invasores;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.PointF;

interface ComponenteGraficos {
    void inicializar(Context c,
                     ObjetoEspec e,
                     PointF tamanoPantalla);
    void dibujar(Canvas canvas,
                 Paint pincel,
                 Transformar t);
}

ComponenteJugadorMovimiento

package org.example.invasores;

import android.graphics.PointF;

class ComponenteJugadorMovimiento implements ComponenteMovimiento {

    @Override
    public boolean mover(long fps,
                         Transformar t,
                         Transformar jugadorTransformar){
        float pantallaAltura = t.getTamanoPantalla().y;
        PointF ubicacion = t.getPosicion();
        float velocidad = t.getVelocidad();
        float altura = t.getObjetoAltura();

        if (t.apuntandoAbajo()){
            ubicacion.y += velocidad / fps;
        }
        else if (t.apuntandoArriba()){
            ubicacion.y -= velocidad / fps;
        }

        if (ubicacion.y > (pantallaAltura - altura)){
            ubicacion.y = pantallaAltura - altura;
        }
        else if (ubicacion.y < 0){
            ubicacion.y = 0;
        }

        t.actualizaColision();
        return true;
    }
}

ComponenteLaserMovimiento

package org.example.invasores;

import android.graphics.PointF;

class ComponenteLaserMovimiento implements ComponenteMovimiento {
    @Override
    public boolean mover(long fps,
                         Transformar t,
                         Transformar jugadorTransformar){
        float rango = t.getTamanoPantalla().x * 2;
        PointF ubicacion = t.getPosicion();
        float velocidad = t.getVelocidad();

        if (t.apuntandoDerecha()){
            ubicacion.x += velocidad / fps;
        }
        else if (t.apuntandoIzquierda()){
            ubicacion.x -= velocidad / fps;
        }

        if (ubicacion.x < -rango || ubicacion.x > rango)
            return  false;

        t.actualizaColision();
        return true;
    }
}

ComponenteMovimiento

package org.example.invasores;

interface ComponenteMovimiento {
    boolean mover(long fps,
                  Transformar t,
                  Transformar jugadorTransformar);
}

ComponentesGraficosFondo

package org.example.invasores;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PointF;
import android.graphics.Rect;

class ComponentesGraficosFondo implements ComponenteGraficos {

    private Bitmap mBitmap;
    private Bitmap mBitmapInverso;

    @Override
    public void inicializar(Context c,
                            ObjetoEspec e,
                            PointF tamanoObjeto){
        int resID = c.getResources()
                .getIdentifier(
                        e.getBitmapNombre(),
                        "drawable",
                        c.getPackageName());
        mBitmap = BitmapFactory.decodeResource(
                c.getResources(),resID);
        mBitmap = Bitmap.createScaledBitmap(
                mBitmap,
                (int)tamanoObjeto.x,
                (int)tamanoObjeto.y,
                false);
        Matrix matrix = new Matrix();
        matrix.setScale(-1,1);
        mBitmapInverso = Bitmap.createBitmap(mBitmap,
                0,0,
                mBitmap.getWidth(),
                mBitmap.getHeight(),
                matrix,
                true);
    }

    @Override
    public void dibujar(Canvas canvas,
                        Paint pincel,
                        Transformar t){
        int xClip = t.getXClip();
        int ancho = mBitmap.getWidth();
        int alto = mBitmap.getHeight();
        int yInicial = 0;
        int yFinal = (int)t.getTamanoPantalla().y + 20;

        Rect desdeRect1 = new Rect(0,0,ancho - xClip,alto);
        Rect haciaRect1 = new Rect(xClip,yInicial,ancho,yFinal);

        Rect desdeRect2 = new Rect(ancho - xClip,0,ancho,alto);
        Rect haciaRect2 = new Rect(0,yInicial,xClip,yFinal);

        if (!t.getPrimeraInvertida()){
            canvas.drawBitmap(
                    mBitmap,
                    desdeRect1,
                    haciaRect1,
                    pincel);
            canvas.drawBitmap(
                    mBitmapInverso,
                    desdeRect2,
                    haciaRect2,
                    pincel);
        } else {
            canvas.drawBitmap(mBitmap,
                    desdeRect2,
                    haciaRect2,
                    pincel);
            canvas.drawBitmap(
                    mBitmapInverso,
                    desdeRect1,
                    haciaRect1,
                    pincel);
        }
    }
}

ComponentesGraficosStd

package org.example.invasores;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PointF;

class ComponentesGraficosStd implements ComponenteGraficos {
    private Bitmap mBitmap;
    private Bitmap mBitmapInverso;

    @Override
    public void inicializar(Context contexto,
                            ObjetoEspec espec,
                            PointF tamanoObjeto){
        int resID = contexto.getResources()
                .getIdentifier(espec.getBitmapNombre(),
                        "drawable",
                        contexto.getPackageName());
        mBitmap = BitmapFactory.decodeResource(
                contexto.getResources(), resID);
        mBitmap = Bitmap.createScaledBitmap(
                mBitmap,
                (int)tamanoObjeto.x,
                (int)tamanoObjeto.y,
                false);
        Matrix matrix = new Matrix();
        matrix.setScale(-1,1);
        mBitmapInverso = Bitmap.createBitmap(
                mBitmap,
                0,0,
                mBitmap.getWidth(),
                mBitmap.getHeight(),
                matrix,
                true);
    }

    @Override
    public void dibujar(Canvas canvas,
                        Paint pincel,
                        Transformar t){
        if (t.getMirandoDerecha()){
            canvas.drawBitmap(mBitmap,
                    t.getPosicion().x,
                    t.getPosicion().y,
                    pincel);
        } else {
            canvas.drawBitmap(mBitmapInverso,
                    t.getPosicion().x,
                    t.getPosicion().y,
                    pincel);
        }
    }
}

FisicasEngine

package org.example.invasores;

import android.graphics.PointF;
import android.graphics.RectF;

import java.util.ArrayList;

class FisicasEngine {
    boolean actualizar(long fps,
                       ArrayList<GameObjeto> objetos,
                       GameState ge,
                       SoundEngine se,
                       SistemaParticula sp){
         for(GameObjeto objeto : objetos){
            if (objeto.chekaActivo()){
                objeto.actualizar(fps,
                        objetos.get(Nivel.INDICE_JUGADOR)
                                .getTransformar());
            }
        }

        if (sp.mEstaCorriendo)
            sp.actualizar(fps);

        return detectarColisiones(ge, objetos, se, sp);
    }

    private boolean detectarColisiones(
            GameState mGameState,
            ArrayList<GameObjeto> objetos,
            SoundEngine se,
            SistemaParticula sp){
        boolean impactoJugador = false;

        for(GameObjeto go1 : objetos){
            if (go1.chekaActivo()){
                for(GameObjeto go2 : objetos){
                    if (go2.chekaActivo()){
                        if (RectF.intersects(
                                go1.getTransformar().getColision(),
                                go2.getTransformar().getColision())){

                            switch(go1.getTag() + " con " + go2.getTag()){
                                case "jugador con laser alien":
                                    impactoJugador = true;
                                    mGameState.perderVida(se);
                                    break;
                                case "jugador con alien":
                                    impactoJugador = true;
                                    mGameState.perderVida(se);
                                    break;
                                case "jugador laser con alien":
                                    mGameState.incrementaPuntaje();
                                    sp.emitirParticulas(new PointF(
                                            go2.getTransformar().getPosicion().x,
                                            go2.getTransformar().getPosicion().y)
                                    );
                                    go2.setInactivo();
                                    go2.generar(objetos.get(Nivel.INDICE_JUGADOR)
                                            .getTransformar());
                                    go1.setInactivo();
                                    se.repAlienExplotar();
                                    break;
                                default:
                                    break;
                            }
                        }
                    }
                }
            }
        }
        return impactoJugador;
    }
}

FondoEspec

package org.example.invasores;

import android.graphics.PointF;

class FondoEspec extends ObjetoEspec {
    private static final String tag = "fondo";
    private static final String bitmapNombre = "background";
    private static final float velocidad = 2f;
    private static final PointF escalaRelativa =
            new PointF(1f,1f);
    private static final String[] componentes = new String[]{
            "ComponentesGraficosFondo",
            "ComponenteFondoMovimiento",
            "ComponenteGeneraFondo"};

    FondoEspec(){
        super(tag, bitmapNombre,
                velocidad,
                escalaRelativa,
                componentes);
    }
}

GameEngine

package org.example.invasores;

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

import java.util.ArrayList;

class GameEngine extends SurfaceView implements Runnable,
        Iniciador,
        GameEngineBroadcaster,
        GeneradorLaserJugador,
        GeneradorLaserAlien{
    private Thread mThread = null;
    private long mFPS;

    UIcontroladora mUIcontroladora;
    SistemaParticula mSistemaParticula;
    FisicasEngine mFisicasEngine;

    private ArrayList<InputObservador> inputObservadores =
            new ArrayList<>();

    private GameState mGameState;
    private SoundEngine mSoundEngine;

    HUD mHud;
    Renderer mRenderer;
    Nivel mNivel;

    public GameEngine(Context contexto, Point tamano){
        super(contexto);
        mUIcontroladora = new UIcontroladora(this);
        mGameState = new GameState(this, contexto);
        mSoundEngine = new SoundEngine(contexto);
        mHud = new HUD(tamano);
        mRenderer = new Renderer(this);
        mSistemaParticula = new SistemaParticula();
        mSistemaParticula.iniciar(1000);
        mFisicasEngine = new FisicasEngine();
        mNivel = new Nivel(contexto,
                new PointF(tamano.x,tamano.y),
                this);
    }

    public void addObservador(InputObservador o){
        inputObservadores.add(o);
    }

    @Override
    public void run(){
        while(mGameState.getThreadCorriendo()){
            long frameInicio = System.currentTimeMillis();
            ArrayList<GameObjeto> objetos = mNivel.getObjetos();

            if (!mGameState.getPausado()){
                if (mFisicasEngine.actualizar(mFPS,objetos,mGameState,
                        mSoundEngine,mSistemaParticula))
                    desapareceReaparece();
            }
            mRenderer.dibujar(objetos,mGameState,mHud,mSistemaParticula);
            long frameActual = System.currentTimeMillis() - frameInicio;
            if (frameActual >= 1){
                final int MILISEGUNDOS = 1000;
                mFPS = MILISEGUNDOS / frameActual;
            }
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent evento){
        for(InputObservador o : inputObservadores){
            o.handleInput(evento,mGameState,mHud.getControles());
        }

        return true;
    }

    public void stopThread(){
        mGameState.detenerTodo();

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

    public void startThread(){
        mGameState.startThread();
        mThread = new Thread(this);
        mThread.start();
    }

    public void desapareceReaparece(){
       ArrayList<GameObjeto> objetos = mNivel.getObjetos();
        for(GameObjeto o : objetos){
            o.setInactivo();
        }

        objetos.get(Nivel.INDICE_JUGADOR)
                .generar(objetos.get(Nivel.INDICE_JUGADOR)
                        .getTransformar());
        objetos.get(Nivel.INDICE_FONDO)
                .generar(objetos.get(Nivel.INDICE_FONDO)
                        .getTransformar());

        for(int i = Nivel.PRIMER_ALIEN;
            i !=  Nivel.ULTIMO_ALIEN + 1; i++){

            objetos.get(i).generar(objetos.get(
                    Nivel.INDICE_JUGADOR).getTransformar());
        }
    }

    @Override
    public boolean generaLaserJugador(Transformar transformar){
        ArrayList<GameObjeto> objetos = mNivel.getObjetos();

        if (objetos.get(Nivel.mProximoLaserJugador)
                .generar(transformar)){
            Nivel.mProximoLaserJugador++;
            mSoundEngine.repDisparar();
            if (Nivel.mProximoLaserJugador >= Nivel.ULTIMO_LASER_JUGADOR){
                Nivel.mProximoLaserJugador = Nivel.PRIMER_LASER_JUGADOR;
            }
        }
        return true;
    }

    public void generaLaserAlien(Transformar transformar){
        ArrayList<GameObjeto> objetos = mNivel.getObjetos();
        if (objetos.get(Nivel.mProximoLaserAlien).generar(transformar)){
            Nivel.mProximoLaserAlien++;
            mSoundEngine.repDisparar();
            if (Nivel.mProximoLaserAlien >= Nivel.ULTIMO_LASER_ALIEN)
                Nivel.mProximoLaserAlien = Nivel.PRIMER_LASER_ALIEN;
        }
    }
}

GameEngineBroadcaster

package org.example.invasores;

interface GameEngineBroadcaster {
    void addObservador(InputObservador o);
}

GameObjeto

package org.example.invasores;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.PointF;

class GameObjeto {
    private Transformar mTransformar;
    private boolean estaActivo = false;
    private String mTag;

    private ComponenteGraficos componenteGraficos;
    private ComponenteMovimiento componenteMovimiento;
    private ComponenteGenerar componenteGenerar;

    void setGenerador(ComponenteGenerar g){
        componenteGenerar = g;
    }

    void setGraficos(ComponenteGraficos g, Context c,
                     ObjetoEspec espec, PointF tamanoObjeto){
        componenteGraficos = g;
        g.inicializar(c, espec, tamanoObjeto);
    }

    void setMovimiento(ComponenteMovimiento m){
        componenteMovimiento = m;
    }

    void setEntrada(ComponenteEntrada e){
        e.setTransformar(mTransformar);
    }

    void setTag(String tag){
        mTag = tag;
    }

    void setTransformar(Transformar t){
        mTransformar = t;
    }

    void dibujar(Canvas canvas, Paint pincel){
        componenteGraficos.dibujar(canvas,pincel,mTransformar);
    }

    void actualizar(long fps, Transformar jugadorTransformar){
        if (!(componenteMovimiento.mover(fps,mTransformar,
                jugadorTransformar))){
            estaActivo = false;
        }
    }

    boolean generar(Transformar jugadorTransformar){
        if (!estaActivo){
            componenteGenerar.generar(jugadorTransformar,mTransformar);
            estaActivo = true;
            return true;
        }
        return false;
    }

    boolean chekaActivo(){
        return estaActivo;
    }

    String getTag(){
        return mTag;
    }

    void setInactivo(){
        estaActivo = false;
    }

    Transformar getTransformar(){
        return mTransformar;
    }
}

GameObjetoFabrica

package org.example.invasores;

import android.content.Context;
import android.graphics.PointF;

class GameObjetoFabrica {
    private Context mContexto;
    private PointF mTamanoPantalla;
    private GameEngine mGameEngineReferencia;

    GameObjetoFabrica(Context c,
                      PointF tamanoPantalla,
                      GameEngine gameEngine){
        this.mContexto = c;
        this.mTamanoPantalla = tamanoPantalla;
        this.mGameEngineReferencia = gameEngine;
    }

    GameObjeto crear(ObjetoEspec espec){

        GameObjeto objeto = new GameObjeto();
        int numComponentes = espec.getComponentes().length;
        final float OCULTO = -2000f;
        objeto.setTag(espec.getTag());
        float velocidad = mTamanoPantalla.x / espec.getVelocidad();

        PointF tamanoObjeto = new PointF(
                mTamanoPantalla.x / espec.getEscala().x,
                mTamanoPantalla.y / espec.getEscala().y);

        PointF ubicacion = new PointF(OCULTO,OCULTO);

        objeto.setTransformar(new Transformar(
                velocidad,
                tamanoObjeto.x,
                tamanoObjeto.y,
                ubicacion,
                mTamanoPantalla));

        for(int i=0; i < numComponentes; i++){
            switch (espec.getComponentes()[i]){
                case "ComponenteEntradaJugador":
                    objeto.setEntrada(new ComponenteEntradaJugador(
                            mGameEngineReferencia));
                    break;
                case "ComponentesGraficosStd":
                    objeto.setGraficos(new ComponentesGraficosStd()
                            ,mContexto,espec,tamanoObjeto);
                    break;
                case "ComponenteJugadorMovimiento":
                    objeto.setMovimiento(new ComponenteJugadorMovimiento());
                    break;
                case "ComponenteGeneraJugador":
                    objeto.setGenerador(new ComponenteGeneraJugador());
                    break;
                case "ComponenteLaserMovimiento":
                    objeto.setMovimiento(new ComponenteLaserMovimiento());
                    break;
                case "ComponenteGeneraLaser":
                    objeto.setGenerador(new ComponenteGeneraLaser());
                    break;
                case "ComponentesGraficosFondo":
                    objeto.setGraficos(new ComponentesGraficosFondo(),
                            mContexto,espec,tamanoObjeto);
                    break;
                case "ComponenteFondoMovimiento":
                    objeto.setMovimiento(new ComponenteFondoMovimiento());
                    break;
                case "ComponenteGeneraFondo":
                    objeto.setGenerador(new ComponenteGeneraFondo());
                    break;
                case "ComponenteAlienChaserMovimiento":
                    objeto.setMovimiento(new ComponenteAlienChaserMovimiento(
                            mGameEngineReferencia));
                    break;
                case "ComponenteAlienDiverMovimiento":
                    objeto.setMovimiento(new ComponenteAlienDiverMovimiento());
                    break;
                case "ComponenteAlienPatrolMovimiento":
                    objeto.setMovimiento(new ComponenteAlienPatrolMovimiento(
                            mGameEngineReferencia));
                    break;
                case "ComponenteGeneraAlienHorizontal":
                    objeto.setGenerador(new ComponenteGeneraAlienHorizontal());
                    break;
                case "ComponenteGeneraAlienVertical":
                    objeto.setGenerador(new ComponenteGeneraAlienVertical());
                    break;
                default:
                    break;
            }
        }
        return objeto;
    }
}

GameState

package org.example.invasores;

import android.content.Context;
import android.content.SharedPreferences;

final class GameState {
    private static volatile boolean mThredCorriendo = false;
    private static volatile boolean mPausado = true;
    private static volatile boolean mGameOver = true;
    private static volatile boolean mDibujando = false;

    private Iniciador mIniciador;

    private int mPuntaje;
    private int mPuntajeAlto;
    private int mNumNaves;

    private SharedPreferences.Editor mEditor;

    GameState(Iniciador ji, Context contexto){
        mIniciador = ji;
        SharedPreferences prefs;
        prefs = contexto.getSharedPreferences(
                "Record",Context.MODE_PRIVATE);
        mEditor = prefs.edit();
        mPuntajeAlto = prefs.getInt("Record",0);
    }

    private void finJuego(){
        mGameOver = true;
        mPausado = true;
        if (mPuntaje>mPuntajeAlto){
            mPuntajeAlto = mPuntaje;
            mEditor.putInt("Record",mPuntajeAlto);
            mEditor.commit();
        }
    }

    void iniciaNuevoJuego(){
        mPuntaje = 0;
        mNumNaves = 3;
        detenDibujar();
        mIniciador.desapareceReaparece();
        retomar();
        iniciaDibujar();
    }

    void perderVida(SoundEngine se){
        mNumNaves--;
        se.repJugExplotar();
        if (mNumNaves==0){
            pausar();
            finJuego();
        }
    }

    int getNumNaves(){
        return mNumNaves;
    }

    void incrementaPuntaje(){
        mPuntaje++;
    }

    int getPuntaje(){
        return mPuntaje;
    }

    int getPuntajeAlto(){
        return mPuntajeAlto;
    }

    void pausar(){
        mPausado = true;
    }

    void retomar(){
        mPausado = false;
        mGameOver = false;
    }

    void detenerTodo(){
        mPausado = true;
        mGameOver = true;
        mThredCorriendo = false;
    }

    boolean getThreadCorriendo(){
        return mThredCorriendo;
    }

    void startThread(){
        mThredCorriendo = true;
    }

    private void detenDibujar(){
        mDibujando = false;
    }

    private void iniciaDibujar(){
        mDibujando = true;
    }

    boolean getDibujando(){
        return mDibujando;
    }

    boolean getPausado(){
        return mPausado;
    }

    boolean getGameOver(){
        return mGameOver;
    }
}

GeneradorLaserAlien

package org.example.invasores;

interface GeneradorLaserAlien {
    void generaLaserAlien(Transformar transformar);
}

GeneradorLaserJugador

package org.example.invasores;

public interface GeneradorLaserJugador {
    boolean generaLaserJugador(Transformar transformar);
}

HUD

package org.example.invasores;

import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Point;
import android.graphics.Rect;

import java.util.ArrayList;

class HUD {
    private int mTextoFormato;
    private int mScreenAlto;
    private int mScreenAncho;

    private ArrayList<Rect> controles;

    static int ARRIBA = 0;
    static int ABAJO = 1;
    static int VUELTA = 2;
    static int DISPARO = 3;
    static int PAUSA = 4;

    HUD(Point tamano){
        mScreenAlto = tamano.y;
        mScreenAncho = tamano.x;
        mTextoFormato = tamano.x / 50;
        prepararControles();
    }

    private void prepararControles(){
        int botonAncho = mScreenAncho / 14;
        int botonAlto = mScreenAlto / 12;
        int botonPadding = mScreenAncho / 90;

        Rect arriba = new Rect(botonPadding,
                mScreenAlto - (botonAlto * 2)
                        - (botonPadding*2),
                botonAncho + botonPadding,
                mScreenAlto - botonAlto
                        -(botonPadding * 2) );
        Rect abajo = new Rect(botonPadding,
                mScreenAlto - botonAlto
                        - botonPadding,
                botonAncho + botonPadding,
                mScreenAlto - botonPadding);
        Rect vuelta = new Rect(mScreenAncho
                - botonPadding - botonAncho,
                mScreenAlto - botonAlto
                        - botonPadding,
                mScreenAncho - botonPadding,
                mScreenAlto - botonPadding);
        Rect disparo = new Rect(mScreenAncho
                - botonPadding - botonAncho,
                mScreenAlto - (botonAlto*2)
                        - (botonPadding*2),
                mScreenAncho - botonPadding,
                mScreenAlto - botonAlto
                        - (botonPadding * 2));
        Rect pausa = new Rect(mScreenAncho
                - botonPadding - botonAncho,
                botonPadding,
                mScreenAncho - botonPadding,
                botonPadding + botonAlto);
        controles = new ArrayList<>();
        controles.add(ARRIBA,arriba);
        controles.add(ABAJO,abajo);
        controles.add(VUELTA,vuelta);
        controles.add(DISPARO,disparo);
        controles.add(PAUSA,pausa);
    }

    void dibujar(Canvas c, Paint p, GameState gs){
        p.setColor(Color.argb(255,255,255,255));
        p.setTextSize(mTextoFormato);
        c.drawText("Top:" + gs.getPuntajeAlto(),
                mTextoFormato,mTextoFormato,p);
        c.drawText("Puntaje:" + gs.getPuntaje(),
                mTextoFormato,mTextoFormato*2,p);
        c.drawText("Vidas:" + gs.getNumNaves(),
                mTextoFormato,mTextoFormato*3,p);
        if (gs.getGameOver()){
            p.setTextSize(mTextoFormato * 5);
            c.drawText("PRESIONA PLAY",
                    mScreenAncho/6,mScreenAlto/2,p);
        }
        if (gs.getPausado() && !gs.getGameOver()){
            p.setTextSize(mTextoFormato * 5);
            c.drawText("PAUSADO",
                    mScreenAncho/3,mScreenAlto/2,p);
        }
        dibujaControles(c,p);
    }

    private void dibujaControles(Canvas c, Paint p){
        p.setColor(Color.argb(100,255,255,255));
        for(Rect r: controles){
            c.drawRect(r.left, r.top, r.right, r.bottom, p);
        }
        p.setColor(Color.argb(255,255,255,255));
    }

    ArrayList<Rect> getControles(){
        return controles;
    }
}

Iniciador

package org.example.invasores;

interface Iniciador {

    public void desapareceReaparece();
}

InputObservador

package org.example.invasores;

import android.graphics.Rect;
import android.view.MotionEvent;

import java.util.ArrayList;

interface InputObservador {
    void handleInput(MotionEvent evento,
                     GameState gs,
                     ArrayList<Rect> controles);
}

JugadorEspec

package org.example.invasores;

import android.graphics.PointF;

class JugadorEspec extends ObjetoEspec {
    private static final String tag = "jugador";
    private static final String bitmapNombre = "player_ship";
    private static final float velocidad = 1f;
    private static final PointF escalaRelativa =
            new PointF(15f,15f);
    private static final String[] componentes = new String[]{
            "ComponenteEntradaJugador",
            "ComponentesGraficosStd",
            "ComponenteJugadorMovimiento",
            "ComponenteGeneraJugador"};

    JugadorEspec(){
        super(tag, bitmapNombre,
                velocidad,
                escalaRelativa,
                componentes);
    }
}

JugadorLaserEspec

package org.example.invasores;

import android.graphics.PointF;

class JugadorLaserEspec extends ObjetoEspec {
    private static final String tag = "jugador laser";
    private static final String bitmapNombre = "player_laser";
    private static final float velocidad = .65f;
    private static final PointF escalaRelativa =
            new PointF(8f,160f);
    private static final String[] componentes = new String[]{
            "ComponentesGraficosStd",
            "ComponenteLaserMovimiento",
            "ComponenteGeneraLaser"};

    JugadorLaserEspec(){
        super(tag, bitmapNombre,
                velocidad,
                escalaRelativa,
                componentes);
    }
}

Nivel

package org.example.invasores;

import android.content.Context;
import android.graphics.PointF;

import java.util.ArrayList;

class Nivel {
    public static final int INDICE_FONDO = 0;
    public static final int INDICE_JUGADOR = 1;
    public static final int PRIMER_LASER_JUGADOR = 2;
    public static final int ULTIMO_LASER_JUGADOR = 4;
    public static int mProximoLaserJugador;
    public static final int PRIMER_ALIEN = 5;
    public static final int SEGUNDO_ALIEN = 6;
    public static final int TERCER_ALIEN = 7;
    public static final int CUARTO_ALIEN = 8;
    public static final int QUINTO_ALIEN = 9;
    public static final int SEXTO_ALIEN = 10;
    public static final int ULTIMO_ALIEN = 10;
    public static final int PRIMER_LASER_ALIEN = 11;
    public static final int ULTIMO_LASER_ALIEN = 15;
    public static int mProximoLaserAlien;

    private ArrayList<GameObjeto> objetos;

    public Nivel(Context contexto,
                 PointF mTamanoPantalla,
                 GameEngine ge){
        objetos = new ArrayList<>();
        GameObjetoFabrica fabrica = new GameObjetoFabrica(
                contexto,mTamanoPantalla,ge);
        construirGameObjetos(fabrica);
    }

    ArrayList<GameObjeto> construirGameObjetos(
            GameObjetoFabrica fabrica){
        objetos.clear();
        objetos.add(INDICE_FONDO,
                fabrica.crear(new FondoEspec()));
        objetos.add(INDICE_JUGADOR,
                fabrica.crear(new JugadorEspec()));
        for (int i = PRIMER_LASER_JUGADOR;
             i != ULTIMO_LASER_JUGADOR + 1; i++){
            objetos.add(i, fabrica.crear(
                    new JugadorLaserEspec()));
        }
        mProximoLaserJugador = PRIMER_LASER_JUGADOR;
        objetos.add(PRIMER_ALIEN,
                fabrica.crear(new AlienChaserEspec()));
        objetos.add(SEGUNDO_ALIEN,
                fabrica.crear(new AlienPatrolEspec()));
        objetos.add(TERCER_ALIEN,
                fabrica.crear(new AlienPatrolEspec()));
        objetos.add(CUARTO_ALIEN,
                fabrica.crear(new AlienChaserEspec()));
        objetos.add(QUINTO_ALIEN,
                fabrica.crear(new AlienDiverEspec()));
        objetos.add(SEXTO_ALIEN,
                fabrica.crear(new AlienDiverEspec()));
        for (int i = PRIMER_LASER_ALIEN;
             i != ULTIMO_LASER_ALIEN + 1; i++){
            objetos.add(i,fabrica.crear(new AlienLaseEspec()));
        }
        mProximoLaserAlien = PRIMER_LASER_ALIEN;

        return objetos;
    }

    ArrayList<GameObjeto> getObjetos(){
        return objetos;
    }
}

ObjetoEspec

package org.example.invasores;

import android.graphics.PointF;

abstract class ObjetoEspec {
    private String mTag;
    private String mBitmapNombre;
    private float mVelocidad;
    private PointF mEscalaTamano;
    private String[] mComponentes;

    ObjetoEspec(String tag,
                String bitmapNombre,
                float velocidad,
                PointF escalaRelativa,
                String[] componentes){
        mTag = tag;
        mBitmapNombre = bitmapNombre;
        mVelocidad = velocidad;
        mEscalaTamano = escalaRelativa;
        mComponentes = componentes;
    }

    String getTag(){
        return mTag;
    }

    String getBitmapNombre(){
        return mBitmapNombre;
    }

    float getVelocidad(){
        return mVelocidad;
    }

    PointF getEscala(){
        return mEscalaTamano;
    }

    String[] getComponentes(){
        return mComponentes;
    }
}

Particula

package org.example.invasores;

import android.graphics.PointF;

class Particula {
    PointF mVelocidad;
    PointF mPosicion;

    Particula (PointF direccion){

        mVelocidad = new PointF();
        mPosicion = new PointF();

        mVelocidad.x = direccion.x;
        mVelocidad.y = direccion.y;
    }

    void actualizar(){
        mPosicion.x += mVelocidad.x;
        mPosicion.y += mVelocidad.y;
    }

    void setPosicion(PointF posicion){
        mPosicion.x = posicion.x;
        mPosicion.y = posicion.y;
    }

    PointF getPosicion(){
        return mPosicion;
    }
}

Renderer

package org.example.invasores;

import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

import java.util.ArrayList;

class Renderer {
    private Canvas mCanvas;
    private SurfaceHolder mSurfaceHolder;
    private Paint pincel;

    Renderer(SurfaceView sv){
        mSurfaceHolder = sv.getHolder();
        pincel = new Paint();
    }

    void dibujar(ArrayList<GameObjeto> objetos, GameState gs,
                 HUD hud, SistemaParticula sp){
        if (mSurfaceHolder.getSurface().isValid()){
            mCanvas = mSurfaceHolder.lockCanvas();
            mCanvas.drawColor(Color.argb(255,0,0,0));

            if (gs.getDibujando()){
                for(GameObjeto objeto : objetos){
                    if (objeto.chekaActivo())
                        objeto.dibujar(mCanvas,pincel);
                }
            }

            if (gs.getGameOver()){
                objetos.get(Nivel.INDICE_FONDO).dibujar(mCanvas,pincel);
            }

            if (sp.mEstaCorriendo)
                sp.dibujar(mCanvas,pincel);

            hud.dibujar(mCanvas,pincel,gs);
            mSurfaceHolder.unlockCanvasAndPost(mCanvas);
        }
    }
}

SistemaParticula

package org.example.invasores;

import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PointF;

import java.util.ArrayList;
import java.util.Random;

class SistemaParticula {
    float mDuracion;

    ArrayList<Particula> mParticulas;
    Random random = new Random();
    boolean mEstaCorriendo = false;

    void iniciar(int numParticulas){
        mParticulas = new ArrayList<>();

        for(int i=0; i < numParticulas; i++){
            float angulo = (random.nextInt(360));
            angulo = angulo * 3.14f / 180.f;
            float velocidad = (random.nextInt(20) + 1);

            PointF direccion;

            direccion = new PointF(
                    (float)Math.cos(angulo) * velocidad,
                    (float)Math.sin(angulo) * velocidad);

            mParticulas.add(new Particula(direccion));
        }
    }

    void actualizar(long fps){
        mDuracion -= (1f/fps);

        for(Particula p : mParticulas)
            p.actualizar();

        if (mDuracion < 0)
            mEstaCorriendo = false;
    }

    void emitirParticulas(PointF posicionInicial){
        mEstaCorriendo = true;
        mDuracion = 1f;

        for(Particula p : mParticulas)
            p.setPosicion(posicionInicial);
    }

    void dibujar(Canvas canvas, Paint pincel){
        for(Particula p : mParticulas){
            pincel.setColor(Color.argb(255,
                    random.nextInt(256),
                    random.nextInt(256),
                    random.nextInt(256)));
            canvas.drawRect(p.getPosicion().x,
                    p.getPosicion().y,
                    p.getPosicion().x+25,
                    p.getPosicion().y+25,
                    pincel);
        }
    }
}

SoundEngine

package org.example.invasores;

import android.content.Context;
import android.media.AudioAttributes;
import android.media.AudioManager;
import android.media.SoundPool;
import android.os.Build;
import android.util.Log;

class SoundEngine {
    private SoundPool mSP;
    private int mDisparo_ID = -1;
    private int mAlien_Explosion_ID = -1;
    private int mNave_Explosion_ID = -1;

    SoundEngine(Context contexto){
        if (Build.VERSION.SDK_INT>=Build.VERSION_CODES.LOLLIPOP){
            AudioAttributes atributos = new AudioAttributes.Builder()
                    .setUsage(AudioAttributes.USAGE_MEDIA)
                    .setContentType(
                            AudioAttributes.CONTENT_TYPE_SONIFICATION)
                    .build();
            mSP = new SoundPool.Builder()
                    .setMaxStreams(5)
                    .setAudioAttributes(atributos)
                    .build();
        } else {
            mSP = new SoundPool(5, AudioManager.STREAM_MUSIC,0);
        }
        try{
            mDisparo_ID = mSP.load(contexto,R.raw.shoot,0);
            mAlien_Explosion_ID = mSP.load(contexto,R.raw.alien_explosion,0);
            mNave_Explosion_ID = mSP.load(contexto,R.raw.player_explosion,0);
        } catch (Exception e){
            Log.e("Invasores","Ha ocurrido un error con los archivos");
        }
    }

    void repDisparar(){
        mSP.play(mDisparo_ID,1,1,0,0,1);
    }

    void repJugExplotar(){
        mSP.play(mNave_Explosion_ID,1,1,0,0,1);
    }

    void repAlienExplotar(){
        mSP.play(mAlien_Explosion_ID,1,1,0,0,1);
    }
}

Transformar

package org.example.invasores;

import android.graphics.PointF;
import android.graphics.RectF;

class Transformar {
    private int mXClip;
    private boolean mPrimeraInvertida = false;

    private RectF mColision;
    private PointF mPosicion;
    private boolean mMirandoDerecha = true;
    private boolean mApuntandoArriba = false;
    private boolean mApuntandoAbajo = false;
    private boolean mApuntandoIzquierda = false;
    private boolean mApuntandoDerecha = false;
    private float mVelocidad;
    private float mObjetoAltura;
    private float mObjetoAncho;
    private static PointF mTamanoPantalla;

    Transformar(float velocidad,
                float objetoAncho,
                float objetoAltura,
                PointF posicionInicial,
                PointF tamanoPantalla){

        mColision = new RectF();
        mVelocidad = velocidad;
        mObjetoAltura = objetoAltura;
        mObjetoAncho = objetoAncho;
        mPosicion = posicionInicial;
        mTamanoPantalla = tamanoPantalla;
    }

    boolean getPrimeraInvertida(){
        return mPrimeraInvertida;
    }

    void flipPrimeraInvertida(){
        mPrimeraInvertida = !mPrimeraInvertida;
    }

    int getXClip(){
        return mXClip;
    }

    void setXClip(int nuevoXClip){
        mXClip = nuevoXClip;
    }

    PointF getTamanoPantalla(){
        return mTamanoPantalla;
    }

    void apuntarArriba(){
        mApuntandoArriba = true;
        mApuntandoAbajo = false;
    }

    void apuntarAbajo(){
        mApuntandoArriba = false;
        mApuntandoAbajo = true;
    }

    void apuntarIzquierda(){
        mApuntandoIzquierda = true;
        mApuntandoDerecha = false;
        mMirandoDerecha = false;
    }

    void apuntarDerecha(){
        mApuntandoIzquierda = false;
        mApuntandoDerecha = true;
        mMirandoDerecha = true;
    }

    boolean apuntandoArriba(){
        return mApuntandoArriba;
    }

    boolean apuntandoAbajo(){
        return mApuntandoAbajo;
    }

    boolean apuntandoIzquierda(){
        return mApuntandoIzquierda;
    }

    boolean apuntandoDerecha(){
        return mApuntandoDerecha;
    }

    void actualizaColision(){
        mColision.top = mPosicion.y + (mObjetoAltura / 10);
        mColision.left = mPosicion.x + (mObjetoAncho / 10);
        mColision.bottom = (mColision.top + mObjetoAltura)
                - mObjetoAltura/10;
        mColision.right = (mColision.left + mObjetoAncho)
                - mObjetoAncho/10;
    }

    float getObjetoAltura(){
        return mObjetoAltura;
    }

    void pararVertical(){
        mApuntandoAbajo = false;
        mApuntandoArriba = false;
    }

    float getVelocidad(){
        return mVelocidad;
    }

    void setPosicion(float horizontal, float vertical){
        mPosicion = new PointF(horizontal,vertical);
        actualizaColision();
    }

    PointF getPosicion(){
        return mPosicion;
    }

    PointF getTamano(){
        return new PointF((int)mObjetoAltura,
                (int)mObjetoAncho);
    }

    void voltear(){
        mMirandoDerecha = !mMirandoDerecha;
    }

    boolean getMirandoDerecha(){
        return mMirandoDerecha;
    }

    RectF getColision(){
        return mColision;
    }

    PointF getPosicionDisparo(float longitudLaser){
        PointF mPosicionDisparo = new PointF();

        if (mMirandoDerecha){
            mPosicionDisparo.x = mPosicion.x
                    + (mObjetoAncho / 8f);
        } else {
            mPosicionDisparo.x = mPosicion.x
                    + (mObjetoAncho / 8f) - (longitudLaser);
        }
        mPosicionDisparo.y = mPosicion.y + (mObjetoAltura / 1.28f);
        return mPosicionDisparo;
    }
}

UIcontroladora

package org.example.invasores;

import android.graphics.Rect;
import android.view.MotionEvent;

import java.util.ArrayList;

class UIcontroladora implements InputObservador {

    public UIcontroladora(GameEngineBroadcaster b){
        b.addObservador(this);
    }

    @Override
    public void handleInput(MotionEvent evento,
                            GameState estadoJuego,
                            ArrayList<Rect> botones){

        int i = evento.getActionIndex();
        int x = (int) evento.getX(i);
        int y = (int) evento.getY(i);

        int tipoEvento = evento.getAction() & MotionEvent.ACTION_MASK;

        if (tipoEvento == MotionEvent.ACTION_UP ||
                tipoEvento == MotionEvent.ACTION_POINTER_UP){

            if (botones.get(HUD.PAUSA).contains(x,y)){
                if(!estadoJuego.getPausado()){
                    estadoJuego.pausar();
                } else if (estadoJuego.getGameOver()){
                    estadoJuego.iniciaNuevoJuego();
                } else if (estadoJuego.getPausado()
                        && !estadoJuego.getGameOver()){
                    estadoJuego.retomar();
                }
            }
        }
    }
}

Recuerden que ActividadJuego es la consecuencia de renombrar (refactor) de la clase MainActivity, esto deben hacerlo bien generado el proyecto, con esto aclarado y todos codigos bien pasados deberan obtener un resultado similar a este

En resumen, recuerden que ante cualquier duda con el codigo tienen los posts donde creamos y explicamos las clases, 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.