Juegos en Android / Componentes decorativos e inanimados

Bienvenidos sean a este post, en este post creamos las dos interfaces que se encargan de los componentes de graficos y actualizar pero hoy agregaremos los que completarian este proyecto.

Para este post vamos a trabajar con tres clases, comencemos con la primera:

• Nombre: ComponenteActualizaBloqueDecorativo
• Tipo: Class

Una vez creada la nueva clase modificaremos el codigo con el siguiente:

package org.example.pepeaventura;

class ComponenteActualizaBloqueDecorativo
        implements ComponenteActualizar {
    @Override
    public void actualizar(
            long fps,
            Transformar t,
            Transformar transformarJugador) {
        
    }
}

En esta clase implementaremos el ComponenteActualizar y para esta ocasion debemos definir a actualizar, recibimos todos los datos pero como ven no tiene ninguna accion o instruccion porque es simplemente decorativo, no se debe mover ni debe tener colisiones por ende lo dejamos como esta, pasemos a la siguiente clase.

La siguiente clase que debemos crear posee las siguientes caracteristicas:

• Nombre: ComponenteGraficoBloqueInanimado
• Tipo: Class

Una vez creada la clase, al igual que el caso anterior modifiquemos su codigo con el siguiente:

package org.example.pepeaventura;

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

import org.example.pepeaventura.especoj.EspecJuegoObjeto;

class ComponenteGraficoBloqueInanimado
        implements ComponenteGraficos {

    private String mBitmapNombre;

    @Override
    public void inicializar(Context contexto,
                            EspecJuegoObjeto espec,
                            PointF tamanoObjeto,
                            int pixelsPorMetro){

        mBitmapNombre = espec.getBitmapNombre();

        BitmapAlmacen.agregarBitmap(
                contexto,
                mBitmapNombre,
                tamanoObjeto,
                pixelsPorMetro,
                false);
    }

    @Override
    public void dibujar(Canvas canvas,
                        Paint pincel,
                        Transformar t,
                        Camara cam){

        Bitmap bitmap = BitmapAlmacen.getBitmap(mBitmapNombre);

        Rect coordinadasPantalla = cam.mundoApantalla(
                t.getUbicacion().x,
                t.getUbicacion().y,
                t.getTamano().x,
                t.getTamano().y);

        canvas.drawBitmap(bitmap,
                coordinadasPantalla.left,
                coordinadasPantalla.top,
                pincel);
    }
}

En esta clase implementaremos a ComponenteGraficos para poder usarla y para ello debemos definir los dos metodos, pero antes creamos un objeto de tipo Bitmap al cual llamaremos bitmap, muy original 😂, con esto comentado veamos al primer metodo:

    @Override
    public void inicializar(Context contexto,
                            EspecJuegoObjeto espec,
                            PointF tamanoObjeto,
                            int pixelsPorMetro){

        mBitmapNombre = espec.getBitmapNombre();

        BitmapAlmacen.agregarBitmap(
                contexto,
                mBitmapNombre,
                tamanoObjeto,
                pixelsPorMetro,
                false);
    }

En este caso sera inicializar y recibira cuatro atributos, entre ellos uno de tipo EspecJuegoObjeto (lo cual hace la implementacion de nuestro paquete), despues tendremos uno para contexto, otro para el tamaño del objeto y uno para la escala de pixels por metro, el primer paso sera utilizar a espec para obtener el nombre del Bitmap del objeto y lo asignamos a mBitmapNombre, con esto realizado pasamos a agregar el bitmap en el almacen por medio de agregarBitmap y para ello le enviamos todos los datos que recibimos y procesamos, por ultimo en este metodo usamos un false porque este caso no tiene un bitmap inverso, recuerden que es inanimado, pasemos al siguiente metodo:

    @Override
    public void dibujar(Canvas canvas,
                        Paint pincel,
                        Transformar t,
                        Camara cam){

        Bitmap bitmap = BitmapAlmacen.getBitmap(mBitmapNombre);

        Rect coordenadasPantalla = cam.mundoApantalla(
                t.getUbicacion().x,
                t.getUbicacion().y,
                t.getTamano().x,
                t.getTamano().y);

        canvas.drawBitmap(bitmap,
                coordenadasPantalla.left,
                coordenadasPantalla.top,
                pincel);
    }

Este sera el encargado de dibujar, para este caso recibiremos un Canvas, un pincel (Paint), el objeto transformado y la camara (que aun no creamos), el primer paso que haremos sera crear un objeto llamado bitmap y al cual por medio de getBitmap en BitmapAlmacen le pasamos a mBitmapNombre para que nos devuelva el objeto procesado en esta clase, despues tendremos este bloque:

        Rect coordenadasPantalla = cam.mundoApantalla(
                t.getUbicacion().x,
                t.getUbicacion().y,
                t.getTamano().x,
                t.getTamano().y);

El cual se encargara de trasladar las coordenadas del mundo relativas al jugador dentro de las coordenadas de la pantalla, pero este metodo lo veremos cuando hagamos a la clase Camara, el ultimo paso sera dibujar el bitmap por medio de las coordenadas creadas en el bloque anterior, al ser de tipo Rect le pasaremos el left y top que tiene asignado, con esto ya tenemos a nuestra clase terminada pero como se daran cuenta aun no funciona pero ya lo solucionaremos mas adelante, pasemos a la siguiente clase.

La ultima clase que debemos crear tiene las siguientes caracteristicas:

• Nombre: ComponenteActualizaBloqueInanimado
• Tipo: Class

Como en los casos anteriores modifiquemos el codigo con el siguiente:

package org.example.pepeaventura;

class ComponenteActualizaBloqueInanimado
        implements ComponenteActualizar {

    private boolean mChocadorNoSeteado = true;

    @Override
    public void actualizar(
            long fps,
            Transformar t,
            Transformar transformarJugador){

        if (mChocadorNoSeteado){
            t.actualizaChocador();
            mChocadorNoSeteado = false;
        }
    }
}

Esta clase vuelve a implementar a ComponenteActualizar, lo primero que haremos sera crear una variable de tipo boolean llamada mChocadorNoSeteado y la definiremos como true, luego definiremos a actualizar (como en la primer clase) pero esta vez si agregaremos una instruccion, en este caso un condicional donde verifica si la variable que definimos en esta clase es verdadera, si se cumple (y lo hara) llama a actualizaChocador del objeto Transformar (t) y luego lo setea como false pero porque hacemos esto? Primero para evitar que este elemento se deba actualizar cuando se lo genera pero implica a agregar mas codigo que se puede evitar con esto y tambien por el chocador o detectador de colisiones se debe setear una sola vez porque no se mueve, con esto ya tenemos a nuestra clase completa.

Como podran ver todo esto esta pensado para los objetos que no se mueven y usaremos como plataformas, trampas y decoracion de los niveles pero nos permitira poder trabajar con los mismos y hacer algunas tareas pero todavia nos falta para poder probarlo.

En resumen, hoy hemos agregado las tres clases que necesitan los elementos que no se mueven en nuestro nivel, ya sea desde las plataformas hasta las decoraciones, hemos implementado las dos interfacces encargadas de los graficos y las actualizaciones, 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.