C++ / Patron de comando

Bienvenidos sean a este post, hoy veremos uno de los patrones para nuestro juego.

Al igual que sucede con cualquier programa, al momento de diseñar un juego usaremos al paradigma de OOP. Despues de todo, un juego representa una combinacion de objetos que interactua intensamente unos con los otros. En nuestro «juego» tenemos edificios construidos por unidades, edificios que a su vez construyen unidades, unidades que se defienden cuando la atacan, etc. Esta intercomunicacion nos lleva a un crecimiento de la complejidad, evolucion y mas caracteristicas pero que incrementa tambien la dificultad de brindar un mejor soporte. Por esta razon, el diseño es una de las partes fundamentales e incorporar patrones de diseño mejorara drasticamente tanto el diseño de proceso y soporte del proyecto, comencemos a hablar sobre el patron del titulo.

Se tiende a categorizar a los patrones en las categorias de creacional, estructural, y conductual. El patron de comando es un patron de diseño conductual. Estos patrones se centran principalmente en proveer flexibilidad en la comunicacion entre objetos. Esto lo hace mediante la encapsulacion de una accion en un objeto que contiene la informacion necesaria junto con la accion misma. Con esto, podemos decir que el patron de comando se comporta como una funcion avanzada, y su forma mas simple de implementarla es mediane una sobrecarga del operador () para una clase. Veamos una posibilidad:

class Comando
{
public:
  void operator()() { std::cout << "Soy muy listo!"; }
};

Una clase con un operador () sobrecargado puede ser considerado como functor. El codigo anterior es casi como la declaracion de una funcion comun:

void miFuncion() { std::cout << "No soy muy listo!"; }

Por lo tanto, podemos decir que el llamado a la funcion como a la clase van a ser similares:

miFunction();
Comando miComando;
miCommando();

La diferencia entre ambas las vamos a ver cuando necesitemos usar un estado para la funcion. Para almacenar el estado en una funcion normal se utiliza una variable estatica. En cambio, para el objeto usamos al objeto mismo. Veamos como puede ser un ejemplo de esto:

class Comando
{
public:
  Comando() : llamado_(0) {}

  void operator()() { 
    	++llamado_;
	std::cout << "Soy intelectual!"; 
    	std::cout << "Se lo llamo " << llamado_ << " veces.\n"; 		}

private:
  int llamado_;
};

Primero establecemos en la parte privada la propiedad que llevara el conteo de los llamados al objeto. En la parte publica, lo iniciaremos con el constructor y luego en la sobrecarga del operador () la incrementaremos con cada llamado a este, y agregamos una linea para mostrar el valor de esta. La ventaja de hacerlo de esta forma, es que cada llamado es unico para cada objeto y llevaremos un control individual de cada uno, a diferencia de uno estatico. Con esto comentado, veamos como lo podemos aplicar al videojuego.

Salvo que hagamos un juego de texto, nuestro juego tendra una interfaz grafica que permitira al jugar poder controlar los elementos de este. Tomemos el caso de que un lector construya una casa, no una barraca, y para ello debemos seleccionar el icono correspondiente en el panel del juego. Por lo general, las interfaces se componen de un panel de juego, un mapa y un conjunto de botones para controlar las dinamicas del juego. Los comandos que debemos proveer al jugador son los siguientes:

• Mover la unidad del punto A al punto B
• Atacar al enemigo
• Construir un edificio
• Ordenar la casa

Si tomamos lo comentado anteriormente, deberiamos convertir a la clase Comando en una interfaz, que tendra la sobrecarga del operador (), y despues creamos una clase para cada uno de los comandos que seran herederas de esta interfaz y cada una de estas definira su propia sobrecarga el operador. Esto hara principalmente que cada clase encapsule la logica de cada accion, evitando que el codigo del cliente (jugador) se preocupe por el procesamiento de la accion. Este opera con punteros de comandos, donde cada uno apuntara al comando correspondiente, pero si observan al listado estos son solo los comandos basicos relacionados al jugador. Y a su vez, el juego se comunica entre modulos usando comandos. Algunos comandos automaticos que podemos tener son: Correr, morir, defender o crear. Todos estos comandos mencionados son eventos que sucederan durante el gameplay y para poder escucharlos entra otro patron denominado como observador pero esto sera un tema para el proximo post. Les dejo una serie de clases que podemos tener para los comandos:

class Comando
{
public:
  virtual void operator() = 0;
};

class Atacar : public Comando
{
pulic:
   void operator()() {
	codigo para atacar
   }
   // resto del codigo de la clase.
}

class Construir : public Comando
{
public:
   void operator()() {
	codigo para construir
   }
   // resto del codigo de la clase.
}

En resumen, hoy hemos visto al patron de comandos, que es, para que sirve, como se pueden utilizar, como lo aplicamos para nuestro juego y un vistazo de como seria. Espero les haya sido de utilidad 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.