Anuncios

Bienvenidos sean a este post, hoy veremos como sera nuestra clase Bala para disparar a Pepe.

Anuncios

Esta no es muy complicada y notaran ciertas similitudes a la pelota de Pong pero sin mas preambulos comencemos modificando el acceso a la clase y declarando las variables que usaremos:

class Bala {
    private RectF mRect;
    private float mVelocidadX;
    private float mVelocidadY;
    private float mAncho;
    private float mAlto;
}
Anuncios
Anuncios

Como a partir de la version 4.0 de Android Studio solo nos deja ponerlo como publica (public), para poder hacer a nuestra clase privada (private) debemos eliminar el modificador de acceso Public, nuestro siguiente paso la declaracion de los objetos/variables que necesitamos, el primero va a ser un objeto que al igual que en Pong no solamente lo usaremos para dibujar a nuestra bala sino tambien para detectar las colisiones pero de eso hablaremos mas adelante, las siguientes dos variables son para manipular la velocidad en los ejes X e Y respectivamente, y las ultimas dos son para el ancho y el alto de nuestra bala, nuestra siguiente modificacion sera agregar el constructor de nuestra clase, para ello agregaremos el siguiente bloque:

    Bala(int screenX){
        mAncho = screenX / 100;
        mAlto = screenX / 100;
        mRect = new RectF();
        mVelocidadX = screenX / 5;
        mVelocidadY = screenX / 5;
    }
Anuncios

En este caso sera una construccion sencilla porque primero recibira un parametro el cual sera el valor del ancho de la pantalla, luego tenemos iniciaremos al ancho y alto de la bala por medio del valor obtenido entre la division del numero pasado en el argumento y 100, despues iniciaremos a nuestro objeto mRect con new y por ultimo asignaremos los valores para la velocidad de los ejes haciendo una division entre el valor informado al constructor y cinco, esto nos asegura que la bala recorra la pantalla en cinco segundos, el siguiente paso sera agregar el metodo para obtener el objeto, recuerden que lo declaramos como privado, y poder utilizarlo para nuestro engine y para ello agregaremos el siguiente metodo:

    public RectF getRect(){
        return mRect;
    }
Anuncios

Con este metodo simplemente devolveremos el objeto mRect creado en esta clase y sera utilizado por el metodo actualizar, esto va a trabajar de la misma forma que la pelota en Pong, a continuacion definiremos al metodo actualizar agregando el siguiente bloque:

    void actualizar(long fps){
        mRect.left += (mVelocidadX/fps);
        mRect.top += (mVelocidadY/fps);
        mRect.right = mRect.left + mAncho;
        mRect.bottom = mRect.top + mAlto;
    }
Anuncios

Este sera el encargado de actualizar los valores de nuestro objeto mRect en base a la velocidad y los fps (frames-per-second), en la primera linea actualizaremos el valor de left sumandole el resultado de la division de mVelocidadX y fps, el cual le enviamos como argumento, lo mismo sucede con top, si se preguntan por esta forma de expresarlo tomemos la primer linea y la misma equivaldria a esta:

mRect.left = mRect.left + (mVelocidadX/fps);
Anuncios

Es decir al valor que tiene actualmente left le sumamos el valor de la division, lo mismo hacemos con top, las siguientes lineas son gracia a las dos primeras porque una vez definido tanto left como top lo que debemos hacer es tomar esa referencia e incrementar a left con el ancho, para asignar el valor de right, y al otro incrementarle el valor del alto para asignarlo a bottom, con esto ya tenemos los cuatro paramentros de nuestro objeto mRect, si quieren saber porque trabajamos de esta forma les recomiendo visitar este post donde explicamos el porque, con nuestros cuatro parametros actualizados podemos pasar a los siguientes dos metodos:

    void invertirVelocidadX(){
        mVelocidadX = -mVelocidadX;
    }

    void invertirVelocidadY(){
        mVelocidadY = -mVelocidadY;
    }
Anuncios

Estos dos metodos seran las encargadas de crear la ilusion de rebote de nuestra bala porque al usarla con deteccion de colisiones y se cumpla la condicion invertira el valor de la velocidad del eje X (el sentido horizontal) o del eje Y (el sentido vertical) ya que si es positivo lo volvera negativo y viceversa, esto es para que nuestra bala no se vaya de la pantalla pero ya lo veremos mas adelante, nuestro ultimo metodo sera el necesario para generar la bala, para ello debemos agregar el siguiente metodo:

    void generar(int pX, int pY, int vX, int vY){
        mRect.left=pX;
        mRect.top=pY;
        mRect.right=mRect.left + mAncho;
        mRect.bottom=mRect.top + mAlto;
        
        mVelocidadX = mVelocidadX * vX;
        mVelocidadY = mVelocidadY * vY;
    }
Anuncios

En este metodo recibiremos cuatro parametros:

  • pX, el cual sera para el valor inicial en el eje X
  • pY, sera para el valor inicial en el eje Y
  • vX, el valor inicial de la velocidad en el eje X
  • vY, velocidad inicial para el eje Y
Anuncios
Anuncios

Despues tenemos cuatro lineas donde trabaja de la misma forma que el metodo actualizar, en las dos primeras asignamos los valores de left y top en base a los recibidos en pX y pY respectivamente, luego asignaremos los valores de right y bottom en base al valor de left incrementado con mAncho y el valor de top incrementado con mAlto respectivamente, las siguientes dos lineas se encargan de asignar los valores de velocidad para la bala y lo que haremos es multiplicar el valor informado en vX y vY con los valores asignados por el constructor a mVelocidadX y mVelocidadY respectivamente, con esto tenemos nuestra clase concluida veamos como quedo el codigo final:

package org.example.balacera;

import android.graphics.RectF;

class Bala {
    private RectF mRect;
    private float mVelocidadX;
    private float mVelocidadY;
    private float mAncho;
    private float mAlto;

    Bala(int screenX){
        mAncho = screenX / 100;
        mAlto = screenX / 100;
        mRect = new RectF();
        mVelocidadX = screenX / 5;
        mVelocidadY = screenX / 5;
    }

    public RectF getRect(){
        return mRect;
    }

    void actualizar(long fps){
        mRect.left += (mVelocidadX/fps);
        mRect.top += (mVelocidadY/fps);
        mRect.right = mRect.left + mAncho;
        mRect.bottom = mRect.top + mAlto;
    }

    void invertirVelocidadX(){
        mVelocidadX = -mVelocidadX;
    }

    void invertirVelocidadY(){
        mVelocidadY = -mVelocidadY;
    }

    void generar(int pX, int pY, int vX, int vY){
        mRect.left=pX;
        mRect.top=pY;
        mRect.right=mRect.left + mAncho;
        mRect.bottom=mRect.top + mAlto;

        mVelocidadX = mVelocidadX * vX;
        mVelocidadY = mVelocidadY * vY;
    }
}
Anuncios

Con esto concluido podemos hacer una prueba pero para ello debemos modificar nuestro codigo del post anterior de la siguiente forma.

Anuncios

Generando una bala

Primero debemos volver a nuestra clase BalaceraJuego y en la lista de variables agregaremos el siguiente objeto:

Bala balaDeFogeo;
Anuncios

Nuestro siguiente paso sera agregar esta linea en el constructor de la clase antes de llamar a iniciaJuego:

        balaDeFogeo = new Bala(mScreenX);
        iniciaJuego();
Anuncios

La siguiente modificacion sera agregar esta linea en el metodo actualizar:

balaDeFogeo.actualizar(mFPS);
Anuncios

La proxima modificacion sera en el metodo dibujar donde agregaremos la siguiente linea despues que definimos el color de mPincel y antes del condicional de verificacion de imprimirDepuracion:

mCanvas.drawRect(balaDeFogeo.getRect(),mPincel);
Anuncios

Y por ultimo debemos agregar las siguientes lineas dentro del metodo onTouchEvent antes del return true:

        mPausado = false;
        balaDeFogeo.generar(0,0,1,1);
Anuncios

Con todas estas modificaciones realizadas podemos proceder a probar nuestro juego y se debera ver como en el siguiente video

Anuncios

Como pueden observar por ahora es simplemente un punto que cruza la pantalla pero ya dimos un gran adelanto en nuestro juego, en los proximos posts ya iremos logrando mejores cosas y completaremos al juego.

Anuncios
Nota: Esto fue solamente de prueba les recomiendo borrar estas ultimas lineas que agregaron porque proximamente implementaremos esto de manera correcta.
Anuncios

En resumen, hoy hemos completado la clase encargada de generar las balas, hemos agregado todos los metodos y paramentros necesarios para la misma y tambien hemos visto un pequeño ejemplo de implementacion pero mas adelante lo implementaremos correctamente, 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