Juegos en Android / Las clases de componentes para el fondo y el jugador

Bienvenidos sean a este post, en los posts anteriores establecimos que cada elemento sera una clase lo cual nos permitira tener no solo de manera independiente a cada elemento sino que nos permitira tener una independencia sobre cada uno de ellos y no tener que estar siempre trabajando sobre una sola clase como es GameObjeto.

Si bien en el post anterior «implementamos» las interfaces que se encargaran de identificar de manera correcta a nuestros elementos con los metodos del GameEngine, o la proxima clase GameObjeto, en esta ocasion lo que haremos son las clases que identificamos cuando hablamos de los componentes en este post pero en blanco para que nos sirvan de estructura para que vayamos completando a las mismas en los posts venideros, para comenzar vamos a generar una nueva clase con las siguientes caracteristicas:

• Nombre: ComponentesGraficosStd
• Tipo: Class

Esta es la clase de componentes mas universal que tenemos entre todos los objetos, una vez creada la clase reemplazaremos el codigo con el siguiente:

package org.example.invasores;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
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){

    }

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

    }
}

Esta clase sera la encargada de manejar el componente de los graficos por lo tanto estara en todos los elementos, como podemos ver tendremos dos variables, ambas de tipo Bitmap una de ellas representa al grafico del objeto (mBitmap) y la otra que va a ser la misma imagen pero invertida (mBitmapInverso) pero esta accion la haremos mas adelante, en esta clase vamos a implementar a la interfaz ComponenteGraficos y en la misma vamos a definir (por ahora en blanco) a los dos metodos propios de la interfaz, vamos a crear nuestra siguiente clase con las siguientes caracteristicas:

• Nombre: ComponenteJugadorMovimiento
• Tipo: Class

Reemplacemos el codigo generado por el siguiente:

package org.example.invasores;

class ComponenteJugadorMovimiento implements ComponenteMovimiento {

    @Override
    public boolean mover(long fps,
                         Transformr t,
                         Transformar jugadorTransformar){
        return true;
    }
}

Como pueden ver implementamos a la interfaz ComponenteMovimiento y definimos a la funcion mover para que devuelva true.

Nota: Nos quedara en error pero lo solucionaremos cuando hagamos nuestra clase faltante.

Con esto realizado pasemos a crear nuestra nueva clase:

• Nombre: ComponenteGeneraJugador
• Tipo: Class

El codigo para esta clase es el siguiente:

package org.example.invasores;

class ComponenteGeneraJugador implements ComponenteGenerar {
    @Override
    public void generar(Transformar jugadorTransformar, 
                        Transformar t){
        
    }
}

En esta ocasion implementamos a la interfaz ComponenteGenerar donde definiremos al metodo generar pero por ahora en blanco, nuestro siguiente movimiento sera crear una nueva clase con las siguientes caracteristicas:

• Nombre: ComponenteEntradaJugador
• Tipo: Class

Nuevamente reemplazamos el codigo generado por el siguiente:

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

    }

    @Override
    public void setTransformar(Transformar transformar){

    }

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

En esta clase tenemos una particularidad porque no solamente implementamos la interfaz ComponenteMovimiento sino tambien a la InputObservador, despues crearemos dos objetos pero ambas nos quedaran con error porque una es Transformar que todavia no existe y la otra es una encargada de generar el laser del jugador pero pronto la implementaremos, despues definiremos un constructor para esta clase pero por el momento lo dejaremos en blanco, el siguiente metodo sera la definicion del metodo de la interfaz ComponenteMovimiento que tambien quedara en blanco y la ultima es para implementar la interfaz InputObservador, cuando llegue el momento explicaremos en detalle a cada una de ellas, ahora procederemos a crear la clase mencionada en esta ultima:

• Nombre: GeneradorLaserJugador
• Tipo: Interface

Reemplacemos el codigo con el siguiente:

package org.example.invasores;

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

Como todas las interfaces que vimos hasta ahora declaramos un prototipo para este metodo y cuando implementemos esta interfaz definiremos a la misma, nuestro siguiente paso sera ir al GameEngine y modificaremos al comienzo de la clase:

class GameEngine extends SurfaceView implements Runnable,
        Iniciador, GameEngineBroadcaster {

De la siguiente manera:

class GameEngine extends SurfaceView implements Runnable,
        Iniciador, 
        GameEngineBroadcaster, 
        GeneradorLaserJugador{

Con esto implementamos a nuestra nueva interfaz en el GameEngine, nuestro siguiente es definir al metodo de esta clase para dejarla implementada, para ello agregaremos en la GameEngine el siguiente bloque:

    @Override
    public boolean generaLaserJugador(Transformar transformar){
        return false;
    }

En este caso quedo solucionado el tema de la implementacion de la interfaz pero todavia nos queda el error de la clase Transformar, volviendo a nuestras tareas lo siguiente sera crear una nueva clase con estas caracteristicas:

• Nombre: ComponenteLaserMovimiento
• Tipo: Class

Nuevamente reemplazamos el codigo existente con el siguiente:

package org.example.invasores;

class ComponenteLaserMovimiento implements ComponenteMovimiento {
    @Override
    public boolean mover(long fps,
                         Transformar t,
                         Transformar jugadorTransformar){
        return true;
    }
}

Al igual que cuando hicimos la clase para el movimiento del jugador aca tambien implementa a la interfaz de ComponenteMovimiento y su respectivo metodo, pasemos a la siguiente clase que debemos generar:

• Nombre: ComponenteGeneraLaser
• Tipo: Class

De nuevo despues de generada debemos modificar el codigo con el siguiente:

package org.example.invasores;

class ComponenteGeneraLaser implements ComponenteGenerar {
    @Override
    public void generar(Transformar jugadorTransformar, 
                        Transformar t){
        
    }
}

En este caso implementamos a ComponenteGenerar nuevamente, tal como vimos anteriormente pasemos a la siguiente clase:

• Nombre: ComponentesGraficosFondo
• Tipo: Class

Reemplacemos el codigo generado automaticamente con el siguiente:

package org.example.invasores;

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

class ComponentesGraficosFondo implements ComponenteGraficos {

    private Bitmap mBitmap;
    private Bitmap mBitmapInverso;

    @Override
    public void inicializar(Context c,
                            ObjetoEspec e,
                            PointF tamanoObjeto){

    }

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

    }
}

En este caso volvemos a implementar a la interfaz ComplementoGraficos con la definicion de sus respectivos metodos, vamos a generar la nueva clase:

• Nombre: ComponenteFondoMovimiento
• Tipo: Class

Modifiquemos el codigo generado automaticamente de la siguiente manera:

package org.example.invasores;

class ComponenteFondoMovimiento implements ComponenteMovimiento {
    @Override
    public boolean mover(long fps, 
                      Transformar t, 
                      Transformar jugadorTransformar){

        return true;
        
    }
}

En esta clase volvemos a implementar ComponenteMovimiento como hicimos anteriormente, vamos a crear la nueva clase:

• Nombre: ComponenteGeneraFondo
• Tipo: Class

Modifiquemos el codigo generado con el siguiente:

package org.example.invasores;

class ComponenteGeneraFondo implements ComponenteGenerar {

    @Override
    public void generar(Transformar jugadorTransformar,
                        Transformar t){

    }
}

Con esta ultima clase hemos completado todas las clases para los componentes de las especificaciones que vimos en este post pero en este caso por ahora trabajaremos con el jugador, el laser del jugador y el fondo de pantalla, en los proximos posts iremos solucionando los errores que nos quedaron pendientes y tambien iremos completando los metodos que por ahora estan en blanco y tambien explicaremos cada uno de ellos.

En resumen, hoy hemos establecido las estructuras de algunos de los elementos de nuestro juego, hemos creado las clases de las especificaciones, hemos implementado las clases del post anterior y hemos hecho algunas modificaciones de las cuales hablaremos mas adelante, les pido un poco de paciencia que esto se va a poner muy bueno, 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.