Anuncios

Bienvenidos sean a este post, en el post anterior vimos como implementar los componentes para una clase de Alien y el laser pero hoy nos centraremos en los restantes.

Anuncios

Esto lo hago asi porque el componente para el Alien Chaser resulto mas complejo y largo de lo que esperaba, sin mas preambulos comencemos con la creacion de una nueva clase llamada ComponenteAlienDiverMovimiento, una vez creada modificaremos el codigo generado automaticamente por el siguiente:

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

Este es muy similar al visto en el post anterior pero un poco mas simple porque no necesita perseguir al jugador sino simplemente tendra otro movimiento, por ello tendremos tres variables:

  • ubicacion, la ubicacion de nuestro Alien
  • velocidad, la velocidad de nuestro Alien
  • reduccionRelativaAlJugador, la reduccion de velocidad relativa al jugador
Anuncios
Anuncios

Despues tendremos un condicional donde compensaremos el movimiento del Alien con respecto al jugador pero solo cuando esta en la vista, primero verifica si no esta mirando a la derecha el jugador y en caso de ser verdadero incrementa el valor del eje X en base a una multiplicacion entre la velocidad y la division entre la reduccion relativa al jugador y los fps, de lo contrario (es decir que este mirando a la derecha) vuelve a hacer el calculo pero en lugar de incrementar el eje X lo usamos para disminuirlo, luego usaremos una operacion entre la division de la velocidad y los fps para incrementar el eje Y de la ubicacion del Alien, este lo usaremos para caer y reaparecer en la parte superior de la pantalla, por ultimo tendremos un condicional donde verificamos si el eje Y es mayor al eje Y de la pantalla, en caso de ser verdadero creamos un objeto random para generar numeros al azar, luego usamos al objeto para generar entre un numero entre 0 y 300 al cual le restaremos el tamaño del alien, y este valor lo asignaremos al eje Y de la ubicacion, la siguiente linea genera un numero al azar tomando como referencia el ancho de la pantalla (es decir el valor de x) y lo asigna al eje X de la ubicacion, esto nos generara un alien que puede caer desde cualquier lado, luego actualizaremos las colisiones y por ultimo devolvemos true, para no tener errores con nuestro metodo y siga activo.

Anuncios

Con esto hemos terminado la clase del Alien Diver, para nuestra siguiente modificacion vamos a crear una nueva clase con el nombre ComponenteGeneraAlienHorizontal, una vez creada modificaremos su codigo con el siguiente:

package org.example.invasores;

import android.graphics.PointF;

import java.util.Random;

class ComponenteGeneraAlienVertical 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.getTamanoPantalla().y;

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

Esta clase se encargara de generar aliens de manera completamente al azar a la derecha o a la izquierda, en este caso vamos a definir cinco variables:

  • tp, almacena el ancho de la pantalla
  • random, lo usaremos para generar un numero al azar
  • izquierda, almacenara de forma al azar los dos valores booleanos
  • distancia, genera un numero al azar entre 0 y 2000 y le suma el valor del eje X del tamaño de pantalla
  • generaAltura, similar al anterior pero para ubicar a que altura lo vamos a ubicar
Anuncios

Una vez que tenemos todos estos datos, usaremos un condicional donde verifica si izquierda esta en verdadero, en caso de ser verdadero ubica al alien del lado izquierdo, para ello convierte a distancia en negativo y lo hace apuntar a la derecha, en caso contrario usa la distancia en positivo y lo hace apuntar a la izquierda, con esto tenemos el componente que se encarga de generar los aliens en cualquiera de las dos puntas de la pantalla, pasemos a nuestra siguiente clase.

Anuncios

Para la siguiente modificacion debemos crear una nueva clase y la llamaremos ComponenteAlienPatrolMovimiento, una vez creada la clase reemplazaremos el codigo con el siguiente:

    @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 ((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

Este metodo es muy similar al metodo mover que vimos en el post anterior pero con unas sutiles diferencias, tenemos las dos constantes para utilizar el mismo mecanismo de disparo, tambien vamos a tener varias variables nuevas y otras que ya usamos en el metodo mover del post anterior, veamos las declaradas:

Anuncios
  • ubicacionJugador, almacena la ubicacion del jugador
  • LIMITE_MINIMO_VERTICAL, establece el limite superior vertical de la pantalla
  • pantallaX, establece el maximo valor del eje X
  • pantallaY, idem al anterior pero del eje Y
  • mDistanciaVision, almacena el rango de vision del alien
  • pos, almacena la ubicacion del alien
  • velocidad, almacena la velocidad del alien
  • altura, almacena la altura del alien
  • LIMITE_MAXIMO_VERTICAL, establece el limite inferior vertical de la pantalla
  • LIMITE_MINIMO_HORIZONTAL, establece el limite a la izquierda de la pantalla
  • LIMITE_MAXIMO_HORIZONTAL, establece el limite a la derecha de la pantalla
  • ajusteVelocHorizRelativaAlJugador, almacena el valor para el ajuste de la velocidad del alien relativa al jugador
  • modifAjusteVelocidadHorizontal, almacena el valor que usaremos para modificar el ajuste de velocidad horizontal
Anuncios

Despues tendremos este bloque de condiciones:

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

Este bloque es muy similar tambien al visto en el otro metodo mover porque se usa para verificar si el jugador esta dentro del rango de vision del alien, primero verfica si el jugador esta mirando a la derecha y el alien no, en caso de ser verdadero establece un valor positivo para ajusteVelocHorizRelativaAlJugador, en caso contrario establece el mismo valor pero negativo, despues tendremos este condicional:

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

Este condicional hace que nuestra nave se mueva horizontalmente, primero verifica si esta apuntando a la derecha, en caso de ser verdadero va disminuyendo el valor del eje X de ubicacion, usamos un condicional si el eje X es menor al valor establecido en LIMITE_MINIMO_HORIZONTAL lo establecemos como valor del eje X y ejecutamos a apuntarDerecha, en caso contrario (es decir que no este mirando a la derecha) incrementamos el valor del eje X y usamos un condicional donde si este eje es mayor a LIMITE_MAXIMO_HORIZONTAL tambien lo establecemos como valor y llamamos a apuntarIzquierda, despues viene el siguiente condicional:

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

En este caso lo usaremos para mover en forma vertical a nuestro alien, para este caso no modificaremos su velocidad y para ello verificamos si esta apuntando hacia abajo, incrementa el valor del eje Y y si este incremento es mayor a LIMITE_MAXIMO_VERTICAL hace que apunte hacia arriba, en el caso contrario disminuye el valor del eje Y, si este es menor a LIMITE_MINIMO_VERTICAL hace que apunte hacia abajo, por ultimo llamamos al metodo encargado de actualizar las colisiones, despues tenemos el mismo condicional visto en el post anterior donde si el numero al azar de disparos es igual al numero para tomar disparo y verificando una serie de condiciones y de cumplirse todas estas procede a disparar, con esto cubrimos la clase de movimiento del alien Patrol, solo nos falta una clase.

Anuncios

De vuelta vamos a crear una nueva clase que llamaremos ComponenteGeneraAlienVertical, una vez creada modificaremos el codigo generado por el siguiente:

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

Este sera usado para generar el lugar donde nuestros aliens seran generados fuera de la pantalla pero como esta orientado a los Divers y estos solo descienden de forma vertical para esta clase solamente generaremos dos valores al azar, una vez generados lo estableceremos con el setPosicion y por ultimo llamamos a apuntarAbajo, con esta ultima clase ya tenemos todos nuestros componentes creados para nuestros aliens pero todavia no los generamos, en el proximo post veremos como se genera y como esta hasta ahora nuestro juego.

Anuncios

En resumen, hoy hemos agregado los aliens que nos faltaban, las dos formas de como generar a nuestros aliens (horizonal y vertical), hemos visto como hacerles tener distintas conductas, en el proximo post ya iremos concretando mas a nuestro proyecto, 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.

Tambien podes donar

Es para mantenimiento del sitio, gracias!

$1.00