O que acontece quando um MMORPG faz sua atualização cíclica? “Adiciona novos itens e monstros, Tiago”. Não só isso, mas também novas áreas, desafios, magias e coisas do gênero, tudo para manter seus jogadores entretidos por mais um período, até que outra expansão seja necessária... e mais outra... e mais outra, num ciclo infinito.

Deathwing não é só "mais um dos 300"...

Seguindo essa linha de raciocínio, imagine que queiramos trazer para um mundo um desses eventos gigantescos dignos dos livros de histórias. Algo que mude completamente o planeta, um grande cataclismo como o dilúvio, a era glacial ou o meteoro que exterminou os dinossauros, mas onde os jogadores sejam parte ativa, presenciando todo o caos e não somente lendo sobre ele nos livros espalhados pelas bibliotecas. Queremos algo grandioso... Algo como trazer uma criatura de poder imensurável que pretende aniquilar o planeta e reformulá-lo a seu bel prazer. “Ah ta. Uma grande novidade... eu posso listar aí uns 300 vilões que querem fazer isso..”

Sim, todo jogo tem algo do gênero. Independente do tamanho de seu escopo, um vilão normalmente quer mudar as coisas de forma caótica, deixando aos heróis o serviço de impedir que ele consiga. A diferença em nosso caso é que o vilão CONSEGUIU fazer isso, cabendo aos heróis impedir que ele CONTINUE fazendo.

Não se trata de impedir que ele ganhe poder, é tentar sobreviver em um mundo completamente modificado pelo poder que ele já conseguiu. Alguns jogos offline já fizeram isso, sendo The Legendo Zelda: Ocarina of Time talvez o mais notável: você começa jogando como criança e termina 7 anos após, com o mundo já tomado pelo poder caótico do vilão final. Porém, o que queremos aqui vai além: temos que mudar um mundo de jogo conhecido há anos, onde milhares de jogadores convivem.

Auberdine em: Havia uma Cidade Aqui.

Pode não parecer, mas essa é uma das decisões tidas como “divisores de águas”. Mudar profundamente algo que já foi aceito por seu mercado pode sempre trazer insatisfação e a perda de público. Pense bem: mudaremos os costumes dos jogadores, sua rotina e, mais ainda, seu conhecimento sobre tudo. Imagine as possíveis surpresas que um jogador pode ter ao andar por uma área antes conhecida:

• Uma ponte não estará mais lá, necessitando um caminho alternativo.
• Uma cidade não estará mais lá, necessitando encontrar a nova posição de um NPC.
• Uma península não estará mais lá, necessitando encontrar outro local para caçar.

Jogadores de anos serão lançados para um nível pouco acima daquele dos jogadores novatos: mesmo que cada um por sua perspectiva, todos estarão descobrindo o mundo de jogo. Arriscado isso, não? Pois então... a Blizzard arriscou.

A nova expansão do World of Warcraft (carinhosamente entitulada World of Warcraft: Cataclysm, que deu o título a esse artigo) trará de volta uma criatura histórica, um dragão extremamente poderoso chamado Deathwing que, no passado, enlouqueceu, deixando de ser o protetor da terra para ser seu destruidor. Com seu poder imensurável, Deathwing passa a remodelar os continentes Kalimdor e Eastern Kingdoms, trazendo o caos às terras clássicas do mundo do jogo.

Uma vez decidido, tamanho evento no mundo de jogo requer muita análise: para que ele não se torne artificial, sendo “outro vilão prá lista dos 300” não basta simplesmente implementar a criatura e colocá-la no fim de um calabouço de 5h de duração, modificando o mapa de alguns lugares. Os efeitos de tal cataclismo devem ser estudados a fundo por afetarem a fundo o que demorou anos para ser construído. Prepare-se para uma completa reestruturação de tudo aquilo que era tido como aceito.

Até Azeroth na logo está em pedaços!

“Que isso, Tiago. Que exagero!” Parece exagero, mas não é. Pensemos bem: como a logo da expansão explicita, o mundo está sendo DESTRUÍDO. Não é um terremoto, uma enchente, um tufão... é isso tudo junto, e mais! É um cataclismo. As forças naturais estão desbalanceadas e, graças à luta dos elementos, várias regiões do mundo devem ser completamente remodeladas: movimentos na crosta farão montanhas surgirem onde antes planícies dominavam. Com isso, rios aparecerão enquanto outros sumirão, movendo florestas e desertos de lugar. No WoW, esse efeito não será sutil: desertos virarão florestas, praias paradisíacas virarão cânions de lava..

Tamanhas mudanças afetam principalmente as criaturas que habitam as áreas modificadas, forçando-as a migrarem para as

Aqui, o deserto de Desolace vira uma rica floresta.

regiões que não foram tão afetadas, quando não extinguindo-as por completo. Nesse ponto, o cataclismo deixa de ser somente físico e passa para a esfera política: a disputa por novas regiões trará guerra onde antes a paz dominava. Governos neutros farão alianças com facções, tentando a todo custo minimizar seu extermínio iminente, possivelmente tornando-se parte das facções mais fortes. Isso influencia diretamente os costumes de seu povo, agregando novos traços de culinária, arquitetura, vocabulário, esporte...

Nesses tempos de turbulência e renovação, cidades serão construídas e governantes surgirão, possivelmente mudando a estrutura de comércio. As grandes cidades que antes estavam nessas rotas de comércio podem ter que mudar sua economia para não sumirem. Uma economia em colapso ou um governante inexperiente poderão trazer o caos para os muros das cidades, fazendo florescer guildas de ladrões, pestes e guerras civis. Reinos enfraquecidos poderão ser invadidos e tomados por seus adversários oportunistas, fazendo com que cidadãos livres tornem-se escravos e monumentos sejam reconstruídos.

Cidades e vilas migram para território inimigo para não desaparecerem por completo.

As ruínas das cidades destruídas podem ser tomadas por criaturas vindas dos mais diversos locais, tornando-se áreas onde o perigo espreita em cada sombra. Cultos sombrios, mortos-vivos e tribos humanóides poderão estar atrás dos inúmeros tesouros restantes.

Tais mudanças perduram depois da morte do vilão. O mundo tem que reestabelecer sua nova normalidade e os jogadores terão que reacostumar-se. Ganchos para futuras alterações podem vir na forma de cidades submersas e templos soterrados que vieram à superfície mais uma vez.

Com tais mudanças não existe certo nem errado: tudo vai do conhecimento do gosto do seu público-alvo, da relação entre riscos e ganhos e, claro, de um trabalho de design sólido e bem fundamentado. E você, teria coragem de fazer o mesmo?

Para ver o vídeo e imagens em maior resolução, visite o site oficial.

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.

Vários jogos permitem a seus jogadores um vasto leque de personalização. Eles permitem que configuremos os personagens para que eles sejam o mais parecido possível com a gente em muito mais que só altura e cor de cabelos. Tais jogos permitem que configuremos também a forma com que esse personagem reage ao mundo de jogo, definindo coisas como a velocidade, o tipo de magia que ele usa ou o quanto sustenta de dano. Alguns jogos permitem até que você configure os itens que eles usam. Assim é o World of Warcraft, a febre do momento no mundo dos RPGS massivos (os MMORPGS).

Para vencer os desafios no WoW, os jogadores podem utilizar encantamentos, gemas, itens e diversos efeitos diferentes para aumentar suas características. Se foi isso que faltou no grupo, é isso que daremos a ele.

Comecemos pegando uma das armas dos jogadores. Essa arma exemplo será a classe TArma abaixo:

package Efeitos
{
	public class TArma
	{
		protected var _nome:String; // Damos um nome qualquer e …
		protected var _efeito:String; // … um efeito…

		public function TArma()
		{
			// ... mas setamos para os valores normais ...
			// ... afinal de contas, a arma não tem nada de especial ...
			// ... ainda
			this._nome = "Arma sem Bônus";
			this._efeito = "";
		}

		public function retornaNome():String
		{ return this._nome; }

		public function retornaEfeito():String
		{ return this._efeito; }
	}
}

Essa arma é o que os personagens têm no momento e, como já sabemos, isso não é o suficiente. Que tal incluirmos esses tais efeitos e encantamentos? Assim estaríamos adicionando a força necessária que os personagens precisam, não Tiago? É só criar uns métodos retornaEncantamento() como você fez e pronto.

Não só poderíamos adicionar tais características como várias outras características à arma. O problema é o futuro: a cada vez que um ou vários novos bônus aparecessem no nosso jogo, fossem modificados ou simplesmente excluídos do jogo (o que acontece com muita frequência), teríamos que atualizar essa classe Tarma, bem como TODO O CÓDIGO fazendo as chamadas a esses bônus, no caso deles simplesmente não existirem mais . Isso a torna alvo de alterações cíclicas, o que é longe de ser legal. A idéia aqui é encapsular essas alterações, aplicando-as como um skin ou tema à arma.

Para conseguirmos tal estrutura, usaremos o padrão Decorator: iremos “enfeitar” a arma com quantos bônus especiais precisarmos, aproveitando que ela já possui algo engatilhado para isso (afinal de contas, o método retornaEfeito() não está lá à toa) . Para isso, precisamos inicialmente criar a classe TDecoratorBonus:

package Efeitos
{
	//import Status.TStatus;

	public class TDecoratorBonus extends TArma
	{
		protected var _arma:TArma; // O Decorador possui uma instância de TArma.

		/***************************************************************
		Construtor da classe. Tem os atributos da TArma a ser decorada ...
		... por ser um tipo de arma.
		****************************************************************/
		public function TDecoratorBonus()
		{
			this._nome = "sem nome";
			this._efeito="";
		}
		/***************************************************************
		Esse método sobrescreve (overrides) o método retornaNome() da ...
		... classe TArma.
		****************************************************************/
		public override function retornaNome():String
		{ return this._nome; }
	}
}

Essa classe é o coração do nosso decorador: ela é a responsável pela estrutura de encapsulamento dos diversos efeitos. A principal estrela dessa clase é, sem dúvidas, o atributo protected var _arma:TArma. Sua função é guardar a camada de efeitos no caso dessa camada ser envolvida por outra camada. Não entendi nada, Tiago.Como assim camada envolvida por outra camada? Bom, se você pensar bem, estou falando de camadas como aquelas bonecas russas chamadas matrioshka que guardam outras bonecas idênticas dentro: essa instância seria uma "âncora" para que pudéssemos ir para a "boneca de dentro". Essa boneca de dentro, por sua vez, também tem sua boneca de dentro até o ponto em que não haja mais bonecas dentro.

Cada uma dessas bonecas é, no nosso exemplo, uma das camadas de bônus do padrão decorador, como a classe abaixo:

package Efeitos
{
	public class TEfeito extends TDecoratorBonus
	{

		/***************************************************************
		Construtor da classe recebe um objeto TArma. Ele é jogado para ...
		... a instância this._arma, encapsulando assim mais um nível para ...
		... a recursividade do padrão.
		****************************************************************/
		public function TEfeito(arma:TArma)
		{
			//Os seguintes atributos vieram por herança de TDecoratorBonus;
			this._arma = arma;
			this._efeito = "+10";
		}

		/***************************************************************
		Método que sobrescreve o retornaEfeito da classe TDecoratorBonus, ...
		... chamando ele próprio na instância this._arma da classe. Dessa ...
		... forma, o método inicia uma cadeia de chamadas que termina ...
		... na classe mais interna, a que não possui uma instância de ...
		... _arma.
		****************************************************************/
		public override function retornaEfeito():String
		{
			// Por ser um padrão de recursividade, é obrigatório que...
			// ... chamemos this._arma.retornaEfeito(). Só assim o ...
			// ... método continuará chamando os efeitos encapsulados.
			return (this._efeito + " " + this._arma.retornaEfeito());
		}
	}
}

Para fazer as camadas de bônus funcionarem, entra em ação uma coisa chamada recursividade: de forma simplificada (e, quem sabe, um dia eu escreva de forma completa), recursividade é a capacidade de um método ou função chamar a si mesma por várias vezes, retornando resultados para ela própria. Por enquanto, basta saber que o método retornaEfeito() é recursivo por chamae retornaEfeito() novamente, mas agora na camada de dentro (que, como já sabemos, é o atributo this._arma). A camada interna, por sua vez, chama retornaEfeito() de sua this._arma, que chama retornaEfeito() de sua this._arma, que chama retornaEfeito() de sua... Isso só acaba quando chegamos na arma inicial, a TArma, cujo método retornaEfeito() não chama outro retornaEfeito() e sim, exibe seu this._efeito.

Nesse momento, cada retornaEfeito() chamado retorna seu this._efeito para o método retornaEfeito() que o chamou, que concatena com seu próprio this._efeito e retorna para o método retornaEfeito() que o chamou, que concatena com seu próprio this._efeito e retorna para o método retornaEfeito() que o chamou, que concatena com seu próprio this._efeito e retorna... O fim desse ciclo se dá quando não houver mais retornos a chamadas a retornaEfeito(), o que no nosso exemplo acontece na classe TMain mais à frente.

Essa estrutura fica assim:

Camadas

Com o padrão conseguimos criar uma arma genérica que possui ao seu redor várias camadas de efeitos e que funciona do exato mesmo jeito que uma arma que não possui efeito algum. Além disso, podemos ter diferentes tipos de efeitos, cada um implementado por uma classe diferente. Vou criar agora um TEncantamento:

package Efeitos
{
	import Efeitos.TDecoratorBonus;

	public class TEncantamento extends TDecoratorBonus
	{

		public function TEncantamento(arma:TArma)
		{
			this._arma = arma;
			this._efeito = "Mongoose";
		}

		public override function retornaEfeito():String
		{
			return (this._arma.retornaEfeito() + " " + this._efeito);
		}
	}
}

Por fim, basta decorarmos a arma:

package
{
	import flash.display.MovieClip;
	import Efeitos.TDecoratorBonus;
	import Efeitos.TEncantamento;
	import Efeitos.TEfeito;
	import Efeitos.TArma;

	public class TMain extends MovieClip
	{
		public function TMain()
		{
			// Criamos uma arma qualquer ...
			var arma = new TArma();

			trace ("Antes dos efeitos"); // ... e exibimos seus bônus iniciais.
			trace ( arma.retornaEfeito() );
			trace ();
			trace("---------------------------------------");
			trace ();

			// Agora o padrão entra em ação. Criamos um efeito TEfeito que ...
			// encapsula a arma atual e é passado para ela mesma. Agora ...
			// arma tem dentro de si um TEfeito.
			// Efeito +10
			arma = new TEfeito(arma);

			// Pegamos agora a TEfeito e jogamos dentro de TEncantamento, ...
			// ... passando novamente para a arma. Agora ela tem um ...
			// TEncantamento que tem um TEfeito.
			arma = new TEncantamento(arma);

			// ... que vai dentro de mais um TEfeito ...
			arma = new TEfeito(arma);

			// ... que termina dentro de outro TEfeito
			arma = new TEfeito(arma);

			// Ao realizarmos a chamada a arma.retornaEfeito(), o próprio ...
			// ... método se encarrega de chamar retornaEfeito() das ...
			// ... instâncias encapsuladas, de forma recursiva.

			trace ( arma.retornaEfeito() );
		}
	}
}

No próximo artigo eu disponibilizo o projeto (Flash CS3) e os arquivos das classes (Action Script 3.0). Falo também do diagrama de classes dessa brincadeira toda. Até lá, caso alguém tenha qualquer dúvida, basta perguntar.

No final de uma longa batalha, O gigante finalmente tomba. Seu colossal corpo vai agora servir de alimento para as criaturas que das quais sua linhagem alimentou-se durante eras. Os heróis retornam para suas montarias e tudo volta a ser tranqüilo, graças ao padrão Decorator.