Nuss… E Agora?!?

4out/090

Marios, Máquinas de Estados e o Padrão de Projetos State – Parte 3

Como prometido na parte 2 da série, esse é um exemplo de Diagrama de Transição de Estados do nosso código do Mario.

12set/091

O que raios é a UML – Parte 3

Como pedido pelo Alexandre Ceni na 2a parte da micro-série sobre a UML, a 3a parte consiste em exemplos gráficos dos diagramas previamente citados.  Os diagramas que não fazem parte do Nuss... E agora?!? são da wikipedia. Essa página vai estar em constante modificação, pois vou substituindo os diagramas da wikipedia por aqueles que forem pintando nos artigos aqui. Não é foco do artigo  ensinar como desenvolver tais diagramas, até porque isso  é assunto para futuros artigos. Portanto, vamos a eles?

23ago/094

O que raios é a UML – Parte 2

Continuando a micro-série sobre a UML, é hora de falarmos sobre como utilizá-la. A UML nos disponibiliza diversas ferramentas ou artefatos para que possamos modelar as diversas partes do nosso projeto. Tais ferramentas são chamadas de “diagramas” e não passam de uma forma padronizada de desenhar determinado tipo de problema de forma a simplificar a forma de ver o que eles querem mostrar.

“Mas e a flexibilidade que você mencionou no artigo anterior?” Então... ela tem a ver com a possibilidade de não utilizarmos todos os diagramas e sim aqueles que são relevantes ao nosso problema. Isso diminui muito a quantidade de trabalho e permite que nos foquemos somente no que nos é importante (lembram-se do princípio de pareto, né?).

12ago/096

O que raios é a UML – Parte 1

“Tiago, você fala tanto sobre a UML, já falou de Casos de Uso, já mostrou diagramas e mais diagramas, mas até agora não disse: o que raios é a UML?”

26jul/093

Decorando um jogo com o padrão de projetos Decorator – Parte 2

Para fechar o artigo anterior, como foi prometido, segue abaixo o diagrama do padrão de projetos Decorator. Apesar da longa explicação e do funcionamento diferente, o diagrama é bem simples:

20jul/094

Decorando um jogo com o padrão de projetos Decorator – Parte 1

Você e 4 amigos, uma esquadrilha de netherdrakes, helicópteros, grifos e hipogrifos, girando por Oshu’gun enquanto procuram o gigante comedor de dragões Durn the Hungerer. Apesar da ameaça, vocês estão confiantes em seu grupo. O entardecer de Nagrand mostra a silhueta do gigante no horizonte e vocês sabem que a hora chegou.

A luta foi perfeita: o gigante arrasou com o grupo nos 20s mais estilosos que qualquer monstro do World of Warcraft já viu. Depois de 15min de brigas sobre quem tem a culpa, alguém descobre que o grupo não estava tão preparado assim. Todos então resolvem melhorar seus equipamentos... Mas como?

Apresento-lhes a morte do grande gigante, o padrão Decorator.

22abr/087

Padrões de Projeto: questão de bom senso

Tá, eu já falei várias vezes sobre as maravilhas de se usar padrões de projeto, como eles resolvem problemas e coisas do gênero. Porém, fica sempre uma dúvida no ar: quando usar Padrões de Projeto?

23dez/072

Já que o Ano Novo tá ae,…

... eu tô cheio de recessos no trabalho e ainda se bateu um desespero programístico sobre mim, resolvi implementar uma série de padrões de projeto com uma visão bem voltada para os jogos. Não vou colocar nada aqui ainda, pois estou trabalhando em outras pequenas surpresas que podem vir a aparecer ainda em Janeiro.

O ano vai começar com artigos no ritmo do artigo sobre o Singleton e o MVC: explicação do conceito + Diagramação UML + Código + comentários. Deixa só passar o ressacão do Reveillon prá gente sacudir isso aqui.

"Boas festas"; "se forem dirigir, não bebam", "Feliz Natal" e todos os outros clichês que estão nos dizendo. Aguardem o novo ano que vamos ter coisas boas por aqui! Até lá!

P.S.: Esqueci de dizer: caso alguém queira um padrão específico, pode pedir aí. Não garanto que eu consiga trazê-lo pro blog, mas vou fazer de tudo para dissecar o menino!
11dez/073

Casos de Uso? Mas hein?

Tá, tá, foi vacilo meu, mas é que eu nem me toquei que o termo Casos de Uso pudesse significar interrogações pra vários de vocês. Pra resolver isso, ta aí: uma explicação sobre os Casos de Uso!Esses tais Casos de Uso (CdUs daqui pra frente) não são nada mais que cada uma das diversas interações que o usuário vai ter com o seu programa. Na maioria das vezes, cada tela ou janela diferente significa um CdU diferente, mas como jogos são muito mais complexos, várias vezes tempos diversos CdUs na mesma janela. “Andar com o personagem”, “utilizar magia”, “selecionar alvo”, “pegar item” e “conversar” são diversos CdU que você realiza na mesma tela: a tela de jogo.

24set/071

Singleton: Limitando e Distribuindo

O nosso Jogo tem uma característica muito especial: ele é traduzido dinamicamente, sem a necessidade de recompilação. Para isso, estamos colocando todo o texto em uma classe especial, a TIdioma. O problema é que, se nós estivéssemos utilizando um objeto simples, a cada “new” que déssemos, teríamos uma cópia inútil do objeto ocupando espaço inutilmente. Dessa forma, se tivéssemos 500k de texto, poderíamos estar ocupando vários megas da memória.

Isso, quando temos um projeto pequeno, não faz tanta diferença: acaba-se sabendo tudo que está ou não na memória, principalmente quando somente um programador fez aquilo tudo. Porém, há uma grande falha de programação: quando agregássemos um novo programador, ele teria que saber TUDO que já foi feito, da forma que foi feita, entendendo a lógica de tudo que já tá pronto para, aí sim, programar sem erros.Para resolver esse problema, o primeiro padrão de projeto que usamos para resolver um problema no Jogo foi o Singleton. Esse padrão GoF garante que a classe possui somente uma instância, criando um ponto de acesso global à ela. Isso é feito da seguinte forma: o programador NÃO cria um objeto daquela classe. Ao invés disso, a própria classe testa se ela possui uma instância dela mesma. Em caso negativo, a classe cria e retorna essa instância para o programador; em caso positivo, ela simplesmente retorna essa instância já criada.

Utilizamos esse tal de Singleton para garantir que, durante toda a execução do nosso programa, tivéssemos somente uma ÚNICA classe de tradução jogada na memória. Ela é criada no início do programa e, então, todo acesso à TIdioma é realizado via um ponteiro para ela.

O singleton pode ser aplicado à qualquer classe que você queira limitar. Abaixo vai o código genérico que deve ser aplicado:

package
{
	public class TSingleton
	{
		// Atributo de instância
		private static var _instancia:TSingleton = new TSingleton();

Esse atributo _instancia é a chave toda do Singleton e será explicado mais abaixo. O interessante é ver que, com o = new TSingleton(); a instância é inicializada na hora da criação do objeto.

		 // Atributo de teste
		private var _valor:int;

_valor é um atributo qualquer. Vamos usar aqui só para testar o funcionamento do padrão Singleton.

O construtor de uma classe Singleton deveria, por definição, ser protegido, para que, ao tentar usá-lo, o compilador desse um erro. Porém, o Action Script 3.0 NÃO PERMITE construtores privados. Como resolver isso?

		 //-----------------------------------------------------------
		public function TSingleton()
		{
			if (_instancia)
				throw new Error("Uso: TSingleton.Instancia.Metodo()");
		}

Quando _instancia é iniciada lá em cima, na criação da classe, o construtor é chamado a 1ª e única vez. Todas as outras vezes que alguém tentar construir na mão a classe, o teste é vai garantir que não seja possível criar uma segunda instância.

“Mas Tiago, se eu num posso chamar o construtor, como que eu vou criar um objeto da TSingleton???”. Isso é fácil. Você NÃO CRIA!Mas hein?!?

		//-----------------------------------------------------------
		// Esse método é o que iremos chamar daqui pra frente
		 // ao invés do construtor da classe
		public static function get Instancia():TSingleton
		{
			return TSingleton._instancia;
		}

Toda vez que você precisar acessar um método de uma classe com o Singleton (no nosso caso, a própria TSingleton), você vai usar pela linha TSingleton.Instancia.Metodo() (onde Metodo() é qualquer método da classe), garantindo que em TODAS AS VEZES você está acessando a mesma instância. Abaixo, mais 2 outros métodos de teste.

		//-----------------------------------------------------------
		// Método simples para retornar um atributo qualquer,
		// nesse caso, ‘valor’
		public function Valor():int
		{
			return this._valor;
		}

		//-----------------------------------------------------------
		// Como o método anterior, mas agora setando o valor do
		// atributo
		public function SetarValor( valor:int )
		{
			 this._valor = valor;
		 }
		//-----------------------------------------------------------
	}
}

Agora vai uma classe extra mostrando como usar uma classe com o padrão Singleton. A lógica de uso, nesse caso específico, está imbutida no construtor da classe, mas poderia estar em qualquer local.

Explicando passo a passo:

import TSingleton;

TODA classe que terá visibilidade de Singleton DEVE incluí-la. Dessa forma, mesmo sendo uma classe Global, áreas do programa que NÃO deveriam vê-la, NÃO verão. Isso evita muitos problemas de acoplamento, efeitos colaterais e melhora muito a reutilização.

public function TPrincipal()

{

	// Provocando o erro:

	//var teste:TSingleton = new TSingleton();

	TSingleton.Instancia.SetarValor(345);

	this.Exibe();

}

Como o construtor da TSingleton está protegido do acesso do programador, usar var teste:TSingleton = new TSingleton() vai resultar no erro:

Error: Uso: TSingleton.Instancia.Metodo()

at TSingleton$iinit()

at TPrincipal$iinit()

Lembrando que Uso: TSingleton.Instancia.Metodo() é a string que passamos para throw new Error lá no construtor de TSingleton, permitindo que vocês troquem a mensagem para algo mais descritivo, caso queiram.

Só para terminar, eu ressalto que esse é somente um dos vários algoritmos diferentes para o Singleton que vocês podem encontrar aí pela internet. Ele foi criado pelo Douglas prá nossa TIdioma há algumas poucas semanas, pois nenhum dos que encontramos era satisfatório o suficiente. Alguém aí tem mais algum exemplo do Singleton?


PS.: Aqueles que querem mesmo testar o Singleton, os arquivos estão aqui ó. Download Action Script 3.0 Singleton class (portuguese) here. Saiba mais: Wikipedia