Juegos en Android / Objetos del juego

Bienvenidos sean a este post, hoy veremos un tema relacionado a los objetos que podemos tener en nuestro juego.

Hasta este juego siempre que tratamos a los distintos elementos de los juegos como clases, es decir que teniamos una clase para dibujar al bate y otra para la pelota, o una clase para Pepe y otra para la bala, o la cabeza de la serpiente y el cuerpo de la misma y la clase para la manzana, en todos los casos tuvimos un metodo que se encargaba de actualizar y otro de dibujar pero en el proyecto anterior tuvimos un acercamiento a lo que veremos hoy porque incrementabamos su cuerpo y podiamos manejar a cada uno de los elementos que adicionabamos, y si bien nosotros podemos implementar algo similar al final de este juego se convertira en una verdadera pesadilla 😱

Para entender mejor el concepto vamos a suponer el siguiente ejemplo, cuando trabajamos con el juego anterior primero creabamos los objetos para la manzana y la serpiente (snake), luego actualizabamos a la serpiente por medio de actualizar y por ultimo usabamos el dibujar de ambas clases, vamos a aplicar este mismo concepto a nuestro nuevo proyecto, primero vamos a crear los objetos:

Diver mDiver = new Diver(argumentos);
Chaser mChaser = new Chaser(argumentos);
Patroller mPatroller = new Patroller(argumentos);
Jugador mJugador = new Jugador(argumentos);

Nuestro siguiente paso sera actualizarlos:

mDiver.actualizar(mFPS);
mChaser.actualizar(mFPS);
mPatroller.actualizar(mFPS);
mJugador.actualizar(mFPS);

Por ultimo los dibujamos:

mDiver.dibujar(pincel, mCanvas);
mChaser.dibujar(pincel, mCanvas);
mPatroller.dibujar(pincel, mCanvas);
mJugador.dibujar(pincel, mCanvas);

Hasta aca podemos decir que no representa ningun problema, verdad? Pero que sucederia si necesitamos tres chasers? Debemos crear los objetos de la siguiente forma:

Diver mDiver = new Diver(argumentos);
Chaser mChaser1 = new Chaser(argumentos);
Chaser mChaser2 = new Chaser(argumentos);
Chaser mChaser3 = new Chaser(argumentos);
Patroller mPatroller = new Patroller(argumentos);
Jugador mJugador = new Jugador(argumentos);

Parece una solucion simple pero el inconveniente vendra a la hora de actualizarlos y dibujarlos porque deberemos extender a estos metodos para contemplar simultaneamente estos nuevos objetos, por no hablar a la hora de detectar las colisiones tanto sea de los enemigos como de los lasers tanto de ellos como los nuestros, y si en lugar de estos tres necesitamos unos diez o unos veinte, entrariamos en una espiral inmensa que nos ocasionaria mas de un dolor de cabeza.

Por no hablar de los problemas con la herencia, ya que no podriamos aplicarlo debido a que todos los elementos tienen una manera casi identica de dibujarse pero necesitariamos seis metodos para dibujarlos, y a su vez si algo cambiara deberiamos hacerlo en los seis metodos nuevamente 🤪

Una solucion podria ser que consideremos a cada objeto como un tipo generico y este empaquetarlo en un ArrayList o algo similar y despues por medio de un for pasar por cada metodo actualizar y dibujar de cada uno de los objetos, por ejemplo podriamos crear una Interfaz llamada GameObjeto (o similar) y extender cada una de las clases que necesitamos (Jugador, enemigos, lasers, etc).

Seria una buena solucion porque el metodo dibujar seria identico para los seis pero el inconveniente esta en que nuestros enemigos tienen cada uno su comportamiento y como podriamos separarlos en nuestro metodo de actualizar? Una solucion podria ser:

void actualizar(long fps){
	switch(tipoEnemigo){
		case "chaser":
			... instrucciones ...
			break;
		case "diver":
			... instrucciones ...
			break;
		case "patroller":
			... instrucciones ...
			break;
	}
}

Esto generara un metodo muchos mas grande que la clase en si y a su vez no consideramos al jugador y a los laser, una solucion podria ser sobreescribir (override) las funciones pero el inconveniente estaria en la clase GameEngine ya que necesita saber cual son los que se estan actualizando, tambien podemos encontrar algunas alternativas pero la mejor opcion sera comenzar a pensar en una manera mas practica para generar nuestros objetos.

Aqui entra en juego un concepto como es la composicion sobre la herencia, es decir componer (crear) objetos con otros objetos, pensemos esto:

Que sucederia si pudieramos programar una clase que se encargue de manejar como dibujar un objeto?

Luego con cada clase que se dibuja a si mismo podriamos instanciarlas dentro de nuestra clase GameObjeto y cuando esta haga algo diferente podemos dibujarla, actualizarla o lo que necesite nuestro objeto, todas las que sean similares no solo se beneficiaran con el mismo codigo sino que las diferentes se beneficiaran siendo encapsuladas y abstraidas (sacadas de) de la clase base, si bien esto no reemplaza a la herencia que vimos hasta ahora si nos permitira complementarlo, a pesar de que ya tenemos todo mas o menos encaminado a nivel teorico todavia nos falta la fabrica para poder trabajar con este concepto pero eso sera un tema del proximo post.

En resumen, hoy hemos visto el problema que tenemos en nuestro proyecto si implementamos el concepto que vimos hasta ahora, hemos analizado cada una de las probabilidades, hemos visto como podria solucionarlo algunas de las posibles fallas y sus respectivas consecuencias hasta llegar a la posibilidad mas plausible que usaremos, 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.