Anuncios

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

Anuncios

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:

Anuncios
Anuncios

Este es el archivo de los sonidos del juego

Anuncios

Este es el archivo de las imagenes en el juego

Anuncios

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)
Anuncios

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>
Anuncios

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

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

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

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

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

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;
    }
}
Anuncios

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;
    }
}
Anuncios

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;
    }
}
Anuncios

ComponenteEntrada

package org.example.invasores;

interface ComponenteEntrada {
    void setTransformar(Transformar t);
}
Anuncios

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;
        }
    }
}
Anuncios

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

}
Anuncios

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

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

ComponenteGeneraFondo

package org.example.invasores;

class ComponenteGeneraFondo implements ComponenteGenerar {

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

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

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

ComponenteGenerar

package org.example.invasores;

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

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

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;
    }
}
Anuncios

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;
    }
}
Anuncios

ComponenteMovimiento

package org.example.invasores;

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

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

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

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;
    }
}
Anuncios

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

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;
        }
    }
}
Anuncios

GameEngineBroadcaster

package org.example.invasores;

interface GameEngineBroadcaster {
    void addObservador(InputObservador o);
}
Anuncios

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;
    }
}
Anuncios

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;
    }
}
Anuncios

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;
    }
}
Anuncios

GeneradorLaserAlien

package org.example.invasores;

interface GeneradorLaserAlien {
    void generaLaserAlien(Transformar transformar);
}
Anuncios

GeneradorLaserJugador

package org.example.invasores;

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

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;
    }
}
Anuncios

Iniciador

package org.example.invasores;

interface Iniciador {

    public void desapareceReaparece();
}
Anuncios

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

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

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

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;
    }
}
Anuncios

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;
    }
}
Anuncios

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;
    }
}
Anuncios

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

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

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

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;
    }
}
Anuncios

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

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

Anuncios

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.

Anuncios

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.

Donación

Es para mantenimento del sitio, gracias!

$1.00