arquitetura

A arquitetura do War Multiplayer é inspirada pelo modelo MVC 
(Model-View-Controller) - modelo, visão e controle, em português. Onde 
temos três camadas de classes que trocam mensagens entre si através de 
chamadas de métodos.
No modelo padrão, cada camada tem sua responsabilidade dentro da 
aplicação em si:
 * Modelo (model): Pode ser entendida como uma representação de toda 
 informação operada pelo sistema. É responsável por aplicar as regras
 do negócio, e armazenar as informações.
 * Visão (view): É a visualização e manipulação dos dados pelo usuário.
 Reponsável por receber os dados do Controle e mostrar ao usuário, além
 de notificar o Controle sobre qualquer interação do usuário.
 * Controle (controller): É a camada que fica entre os dados (Modelo) e
 o usuário (Visão). Interpreta os comandos do usuário na visão e aciona
 os modelos para que os dados reflitam esta ação. Também é nesta camada
 que os dados são consultados (através de métodos implementados pelo 
 Modelo) e mostrados para a Visão.
 
No War Multiplayer temos essa arquiterura separada em duas partes: 
Servidor e Cliente. Onde o servidor é um único processo reponsável por 
centralizar os dados do sistema, aplicar as devidas regras a esses 
dados e enviar as informações necessárias ao clientes conectados. O 
cliente é um processo rodando em um navegador de internet.
As camadas da aplicação podem ser divididas da seguinte maneira:
 * Servidor
  ** Modelo:
  ** Controle:
  
 * Cliente
  ** Controle:
  ** Visão:




Classes no lado servidor
========================

A biblioteca Rack::Websocket precisa de uma classe herdada de *Rack::Websocket::Application*.
Essa classe é o ponto de entrada e saída do servidor. É ela que recebe os dados e envia 
respostas aos clientes, é ela que é chamada nos eventos de nova conexão (on_open) e conexão 
fechada (on_close)

********************
* ServerConnection *
********************

No War Multiplayer, a classe filha de *Rack::Websocket::Application* é a *ServerConnection*
Cada cliente conectado ao servidor é 'representado' durante toda a duração da conexão por 
uma instancia de *ServerConnection*.


 - Ao receber uma mensagem (on_message)
   * Trasnforma a string JSON em um objeto Hash
   * Encaminha o hash para o objeto da aplicação (Application)
 
 - Ao enviar uma mensagem (send_message)
   * Transforma o objeto hash em JSON
   * Envia ao cliente
 
 - Eventos (on_open, on_close)
   * Encaminhados ao objeto da aplicacao
   
***************
* Application *
***************

A classe Application faz a ponte entre os controladores e as instancias ServerConnection 
(que representam os clientes).
Ela mantem uma lista de todos os controladores instanciados, e todas as ServerConnection 
instanciadas. Ao receber uma mensagem de um determinado cliente ela dispacha essa mensagem
ao controlador responsavel por ela

 - Eventos (on_open, on_close)
   * Procura entre os objetos controladores, quais deles implementam os métodos on_open e 
   on_close
   * Aciona o(s) controlador(es), caso exista, chamando o método em questão
 
 -