Mais um passo dado na recuperação da PDJ!


Caso alguém esteja lendo isso, não se preocupe: a equipe de admins da PDJ ainda está viva (e tentando colocar as coisas em ordem)!

O ataque que tivemos foi muito pior do que eu imaginava – só a base de dados dos artigos do antigo blog apresentava mais de 28 MB de “conteúdo” que, após ser limpa (isto é, apagar tudo quanto era spam) ficou com somente 908 KB!

Comecei a reestruturação a partir da parte do blog para retornar os artigos do mesmo ao ar logo bem como porque sua base de dados é bem menor que a do fórum, logo é bem mais rápido para terminar – e mesmo assim não terminei tudo ainda, só recuperei e publiquei os artigos publicados no ano 2007, ainda faltam os de 2008 e 2009!

Não se preocupem que esta semana ainda (se possível, até amanhã), devo estar encerrando a recuperação do blog e iniciando a recuperação do fórum de discussão. E outra razão para não ter iniciado pelo fórum é pelo simples fato de que o arquivo de recuperação do banco do mesmo possui “apenas” quase 2 milhões de linhas! Sei que o fórum tem produzido muito conteúdo, mas tenho certeza de que muito do que ali está é spam e com certeza não será fácil de limpar ele antes de inserir todo o conteúdo no novo banco de dados. Mas não se preocupem, que estamos trabalhando nisso! ;-)

Quem vos fala é Christiano Santos, admin da PDJ, encerrando a transmissão!

Christiano Lima Santos

Formação acadêmica

Graduado em Ciência da Computação (Bacharelado) pela Universidade Federal de Sergipe (UFS);

Especialista em Gestão de Negócios pela Universidade Cidade de São Paulo (UNICID);

Mestre em Ciência da Computação (linha: Engenharia de Software) pela Universidade Federal de Sergipe (UFS).

Atuação profissional

Trabalhou em 2006 na empresa O2 Games como desenvolvedor de jogos em Flash;

Desenvolveu diversos jogos em Flash (singleplayer e multiplayer) ao longo dos anos 2007 até a presente data;

Atuou como professor temporário em disciplinas de Programação (programação estruturada em C e Pascal, programação lógica em Prolog e programação funcional em Haskell) e Computação Inteligente (envolvendo principalmente algoritmos de busca, máquinas de estados finitos, algoritmos genéticos e redes neurais) na UFS;

Atualmente, desenvolve um novo projeto de jogo multiplayer e multi-plataforma (em Adobe AIR).

Outros projetos

Possui diversos blogs e websites sobre assuntos de seu interesse, como o Instituto dos Jogos, Clube do Dinheiro, Nutrição em Foco e Carmaziel Games.

PDJ em manutenção!

Olá a todos! Como vocês já devem ter percebido, a PDJ (Programadores de Jogos) passou as últimas semanas “fora do ar” devido a um ataque à nossa conta de hospedagem, que foi usada em ações de spamming, levando o provedor de serviços de hospedagem a suspendê-lo. Bem, o processo de reconstrução da mesma está sendo lento,  mas ela voltará – e ainda mais forte, pode ter certeza disso! ;-)

Nos próximos dias, estaremos reconfigurando a estrutura principal do website e do fórum de discussão a fim de evitar novos ataques, bem como “subindo” todo o conteúdo que havia em nosso blog, nosso fórum e no já extinto wiki (se possível for).

Então, não se preocupem, logo, logo teremos a boa e velha PDJ, ou melhor, a PDJ em uma versão nova e mais dinâmica!

Desenvolvendo Jogos em Delphi

Autor: Christiano Lima Santos

Um grande “olá” a todos!

Demoramos, mas não falhamos em publicar aqui mais um tópico e hoje é a vez de apresentar um pouco do mundo da programação de jogos em Delphi.

Não, não será este um curso completo de programação em Delphi + criação de jogos em Delphi. Acho que está mais para um bate-papo sobre o que pode ser feito com a ferramenta e onde procurar informações que o nortearão neste processo de aprendizagem, ok?

Aos que não conhecem, uma apresentação sobre a ferramenta: Delphi não é uma ferramenta desenvolvida ESPECIFICAMENTE para a criação de jogos. Delphi trata-se de uma IDE (Integrated Development Environment) para a linguagem Object Pascal (os mais xiitas dizem ser uma variação da Object Pascal a linguagem com que Delphi trabalha). É uma ferramenta RAD, ou seja, para o desenvolvimento rápido de sistemas, e talvez isso explique por que esta ferramenta popularizou-se tanto dentre o pessoal de programação.

Por ser uma ferramenta RAD, o desenvolvimento de sistemas tradicionais é feito muito rápido nessa ferramenta, já com jogos, nem tanto, mas também não é nenhum bicho de sete cabeças!

Na verdade, considero o desenvolvimento de jogos em Delphi mais fácil do que em outras linguagens, mas não vou me prolongar mais a fim de evitar atritos desnecessários, como a “guerra das linguagens”.

O Borland Delphi é uma ferramenta paga, mas a Borland lançou o Delphi Explorer, uma versão free de seu software e que pode ser usado livremente.

Você deve estar se perguntando: e o que será que serei capaz de criar em Delphi? Será que há bons jogos desenvolvidos nisso?

Até há!

Um exemplo que já foi muito citado anos atrás são os jogos da série Age of Wonders. Quem quiser conhecer um pouco, pode ver o jogo Age of Wonders 2. Nos sites abaixo (o primeiro é o da empresa desenvolvedora) você poderá encontrar várias informações e telas dele:

http://www.triumphstudios.com/ageofwonders/

http://aow2.heavengames.com/

Um lugar cheio de informações e jogos desenvolvidos em Delphi pode ser encontrado no seguinte site:

http://www.delphigamer.com/main.php

Bem, se você quer criar jogos em Delphi, pode ser uma boa idéia primeiro conhecer a ferramenta, não? Algumas pessoas me perguntam se não há um curso pronto, onde ensine Delphi e desenvolvimento de jogos nesse ambiente. Olha, pode até ter! Se quer em português, o único lugar onde você deve encontrar é a Tilt.net .

Na PDJ nós temos alguns tutoriais, mas nada ensinando o básico de programação em Delphi, então o jeito é ou procurar na Internet (salve Google!) ou correr atrás de alguma empresa/escola que ofereça isso.

Uma vez que você já conhece um pouco a feramenta (aprendeu sobre como ela funciona e fez alguns programas para testar esse aprendizado) você estará apto a começar a pesquisar e estudar sobre a criação de jogos nele.

Uma boa ideia é começar vendo um pouco sobre como desenvolver jogos sem uso de APIs, bibliotecas, etc. voltados ao desenvolvimento de jogos. Por quê? Assim você não se prende aos “vícios” que nos acostumamos quando aprendemos a criar somente com um determinado conjunto de bibliotecas.

A revista ClubeDelphi apresenta esporadicamente artigos e tutoriais sobre criação de jogos, então você pode procurar por edições que sejam do seu interesse. Como já foi citado, a Tilt.net também pode lhe ser de bastante ajuda. Além disso, não se esqueça de nosa querida PDJ.

Você pode encontrar alguns tutoriais sobre jogos em Delphi no seguinte link:

http://www.programadoresdejogos.com/forum/viewtopic.php?t=5758

Se você vai começar estudando desenvolvimento de jogos em Delphi do zero ( o que acho excelente!), você provavelmente vai começar desenhando tudo diretamente no Canvas.

Canvas é uma superfície de um objeto na qual podemos desenhar, por exemplo, quando você coloca uma bitmap para aparecer num TImage, é no canvas do mesmo que ele desenha! Dá para se desenhar no canvas de diversos componentes: TForms, TImages, TPaintbox, etc.
Se você for trabalhar puramente com o Delphi, sem nenhuma biblioteca em especial, experimente brincar de desenhar no canvas do TPaintBox.

O Canvas possui um atributo Pixels, que é um array bidimensional, onde cada ponto representa a cor de um determinado pixel naquele objeto. Pronto! Você precisará mexer com esses pixels para desenhar no canvas.

Desenhe sempre o que vai ficar “por baixo” antes do que vai ficar “por cima”, porque o que você desenha sempre vai cobrir o que já estava lá antes!

Como desenhar um personagem com fundo transparente? Simples! Vamos supor que o preto é a nossa cor transparente… Então para cada ponto que você for desenhar você verifica se aquele pixel é da cor preta, se for, desconsidere-o, caso contrário, pinte no Canvas (plotar um pixel, eis o termo mais usado).

Legal, mas você está querendo criar uma esfera semi-transparente que irá ficar em volta do personagem, dando a impressão de ser um escudo, né? Bem, depois de plotar o seu personagem, você vai, para cada ponto da sua esfera (lembrando de só plotar os que não são parte do fundo!) fazer a média entre a cor que pertence à esfera e a cor que já está na posição em que você vai plotar. Desta forma, você consegue plotar algo com 50% de transparência. Bem, mas você talvez não tenha entendido direito esse cálculo, ou queira que seja plotada a imagem com outro percentual de transparência, então… Vamos a uma rápida fórmula para fazer esse cálculo, ok?
R1,G1,B1 -> são os valores RGB da cor de um dado pixel da esfera
R2,G2,B2 -> são os valores RGB da cor de um dado pixel no canvas
P -> percentual de transparência (0 a esfera não aparece, 100 a esfera aparece sem transparência)
RF,GF,BF -> são os valores RGB da cor que nós plotaremos no pixel
RF = (R1*P + R2*(100-P))/100
GF = (G1*P + G2*(100-P))/100
BF = (B1*P + B2*(100-P))/100
Pronto, ae é só pegar os valores RGB, converter para a cor e jogar nesse pixel!

Agora, você deve perceber que quando for aparecer na tela, ela às vezes ficará piscando. Por que isso? É que enquanto ainda está sendo desenhado no seu PaintBox, o formulário já está sendo desenhado na tela, ae fica mostrando a imagem se formando ainda (flickering ou cintilação, esse é o nome do efeito).
Para resolver isso é só ativar a dupla bufferização nos componentes sendo utilizados. Dependendo de qual o componente usado para desenhar, ativa-se no formulário ou no próprio componente. É só dizer: nome_componente.doublebuffered := true;
Dupla bufferização (ou double buffering) é uma técnica que usa uma superfície auxiliar para desenhar, enquanto que exibe somente a principal. Após concluir o desenho, essas superfícies são trocadas. Assim, o que sempre é visto na tela é uma superfície já totalmente desenhada.

Bem, mas você precisa que tudo isso seja executado infinitamente, num laço. O Delphi te oferece, para isso, um componente Timer. Ajuste o intervalo para que fique razoável a velocidade. Nele você deverá:
1. Verificar quais teclas foram pressionadas;
2. Apagar a tela;
3. Cálculos de colisões, física, etc;
4. Movimentar objetos;
5. Redesenhar a Tela;
6. Validações de vitória, derrota, etc;

Pronto! É algo mais ou menos assim!
Treine bastante a parte de manipulação gráfica e cálculos para detecção de colisão. Após “maestrar” a parte gráfica, cuide da parte sonora.

Como seu objetivo nos primeiros projetos será fazer tudo sem bibliotecas extras, você pode usar o componente MediaPlayer que devem estar em seu Delphi.

Depois de um ou dois projetos completos assim, você deverá ter compreendido as dificuldades que há no desenvolvimento de jogos sem as facilidades das APIs e bibliotecas auxiliares.

Há várias opções para quem está interessado em criar seus jogos em Delphi, algumas delas são:

DelphiX

– Jedi-SDL

– Jedi-DirectX

– GLScene

Eu já usei bastante a DelphiX. Thiago Martinez (W_Snipes) já estudou a GLScene. Enfim, todo mundo que já estudou Delphi para jogos já se envolveu com alguma delas e conhece um pouco de suas vantagens e desvantagens, então querendo conversar sobre, é só falar, ok?

Quando você começar a criar seus jogos, vai perceber que irá precisar de um editor de mapas para criar mais cenários facilmente. Se precisar, pode usar o editor de mapas que eu criei para os meus projetos de jogos 2D tiled. Se bem me lembro, já está com o código-fonte, então você poderá estudá-lo e desenvolver o seu próprio, se preferir.

Bem, como disse, este não é um tutorial. Acho que está mais para um guia falando sobre o que você irá precisar e onde pode encontrar algo sobre. Quem souber tirar proveito pode conseguir com isso um excelente pontapé em seus estudos.

É isso. Até breve!

LuaJava – uma ferramenta de scripting para Java

Autor: Edmar Souza Jr.

Hoje vamos falar sobre como estender a linguagem Java usando a linguagem Lua. Mostraremos o Lua Java e como usá-lo para as principais operações.

Lua

Hoje não estamos aqui para falar do satélite natural da Terra, mas sim da linguagem de scripting Lua. Desenvolvida totalmente em território tupiniquim pelo time da TecGraf (Pontifícia Universidade Católica do Rio de Janeiro – Puc-rio). Lua é leve, veloz, é basicamente procedural, tipada dinamicamente, tem suporte a threads e possúi suporte a Orientação a Objetos usando metamecanismos (LuaTables!!).

Lua já foi empregada com sucesso em vários jogos comerciais, entre eles MDK2, World of Warcraft e Grim Fandango.

Você pode obter mais informações sobre Lua em www.lua.org.
LuaJava

Não, a Nasa não descobriu uma ilha chamada Java na Lua, nem tão pouco os cientistas da ilha de Java estão indo para a Lua. LuaJava é uma biblioteca que permite estender a linguagem Java usando Lua como ferramenta de scripting.

A grande jogada da biblioteca LuaJava é permitir interoperabilidade total entre o ambiente Java e o ambiente Lua. Você pode, por exemplo, criar classes em Lua e usar uma interface para instanceá-las em Java, ou então “importar” uma biblioteca escrita em Java (seja ela criada por você ou do pacote padrão) e usar em seus scripts Lua.
Indo para Lua com Java

A primeira coisa que precisamos para dar início a nossa viagem é do LuaJava, que pode ser adquirido em: http://www.keplerproject.org/luajava/.

Existem dois arquivos necessários para o funcionamento de LuaJava: luajava-x.x.jar e luajava-x.x.dll (libluajava-x.x.so para usuários do Linux)

Para instalar a biblioteca basta copiar o arquivo luajava-x.x.dll para a pasta bin no diretório do seu Java runtime (ou no diretório bin do seu Jdk), o arquivo luajava-x.x.jar deve ficar em algum caminho do CLASSPATH.

Feito isso você estará com o LuaJava instalado e funcionando.

Iniciando o LuaJava

A primeira coisa que você que já programou com Lua em C ou C++ antes deve saber é que as funções da API Lua estão totalmente disponíveis aqui através da classe org.keplerproject.luajava.LuaState. Entretanto, quem não tem intimidade com a API Lua, não fique desesperado. A LuaJava oferece várias funções que facilitam a integração de Lua com Java.

A Classe LuaState

O principal objeto da LuaJava é o LuaState. O LuaState guarda uma referencia para a máquina virtual Lua, e é a partir dele que você vai carregar arquivos de script, registrar classes, chamar funções, etc.

Para iniciar o LuaJava, você deve criar uma nova instância do objeto LuaState. Você pode também opcionalmente abrir as bibliotecas padrão do Lua. O seguinte trecho de código mostra um programa completo que abre uma nova instância da LuaJava e imprime Hello World na tela usando a função print do Lua.

package testeluajava;
import org.keplerproject.luajava.*;
public class Main {
	public static void main(String[] args) {
		LuaState l = LuaStateFactory.newLuaState();
		l.openLibs();
		l.LdoString("print \\"Hello World\\" ");
		l.close();
	}
}

Claro, não precisamos nos fixar a executar comandos com o LdoString. Podemos usar o LdoFile para executar nossos arquivos de Script:

package testeluajava;
import org.keplerproject.luajava.*;
public class Main {
	public static void main(String[] args) {
		LuaState l = LuaStateFactory.newLuaState();
		l.openLibs();
		l.LdoFile("teste.lua");
		l.close();
	}
}

//teste.lua

print "Entre com seu nome:";
local nome = io.read();
local texto = "Hello " .. nome;
print (texto);

O forte do LuaJava como dissemos anteriormente é permitir a interoperabilidade entre o ambiente Lua e o ambiente Java.

Usando classes Java em Lua.

Para usar classes escritas em Java no ambiente Lua, o LuaJava nos fornece duas funções: luajava.bindClass e luajava.new.

A função luajava.bindClass permite importar uma referencia para uma classe escrita dentro do ambiente Java, isso é feito da seguinte maneira:

//teste.lua

JFrame = luajava.bindClass("javax.swing.JFrame");

O único parâmetro que a função bindClass recebe é o nome completo (incluindo os pacotes) para uma classe Java. No exemplo acima JFrame agora é uma referencia para a nossa classe javax.swing.JFrame. Para podermos usar esta referencia para instancear um novo objeto, basta usar a função luajava.new da seguinte maneira:

//teste.lua

c = luajava.new(JFrame);

Após isso, podemos trabalhar com o objeto normalmente como se fosse uma classe nativa do Lua. O código abaixo cria uma janela com o título “Hello PDJ” com 300 x 300 pixels e que encerra a aplicação quando fechada.

//teste.lua

JFrame = luajava.bindClass("javax.swing.JFrame");
f = luajava.new(JFrame);
f:setTitle("Hello PDJ");
f:setSize(300,300);
f:setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f:setVisible(true);

Também podemos importar classes criadas por nós mesmos. Vamos considerar como exemplo a seguinte classe:

//PdjBlog.java

package testeluajava;
import java.util.ArrayList;
public class PdjBlog {
	private ArrayList<String> posts = null;
	public PdjBlog() {
		this.posts= new ArrayList();
	}
	public void newPost(String post) {
		this.posts.add(post);
	}
	public void printPosts() {
		for (int i = 0; i < this.posts.size(); i++) {
			System.out.println(this.posts.get(i));
		}
	}
}

Em Lua podemos usá-la da seguinte maneira:

//teste.lua

PdjBlog = luajava.bindClass("testeluajava.PdjBlog");
blog = luajava.new(PdjBlog);
blog:newPost("Teste Lua Java!!");
blog:newPost("Usando Lua com Java!!");
blog:newPost("Outro Teste Lua Java!!");
blog:printPosts();

Usando classes Lua em Java

Assim como é possível criar classes em Java e usá-las em Lua, também é possível fazer o contrário, definindo classes em Lua e usando-as em Java.

O processo para usar classes Lua em Java já é um pouco mais complicado. Para usar as classes você deve definir ma interface em Java que descreva a classe Lua que você deseja utilizar.

Podemos pegar como exemplo a seguinte interface:

//INpc.java

package testeluajava;
public interface INpc {
	void setNome(String nome);
	void falar();
}

Em Lua esta interface poderia ser definida como a seguinte classe:

//npc.lua

Npc = {
	Nome = "";
	setNome = function(nome)
		Nome = nome;
	end;

	falar= function()
		local texto = "Olá eu sou um npc, meu nome é " .. Nome;
		print (texto);
	end;
}

Para usar esta classe precisamos pegar sua referencia através do método getLuaObject da classe LuaState, como no código a seguir:

LuaObject obj = l.getLuaObject("Npc");

A função getLuaObject recebe um parâmetro que é o Nome do objeto no ambiente Lua, ele retornar uma referencia para esse objeto com o qual podemos trabalhar. Porém ainda não estamos aptos a usar a nossa classe Lua. O LuaObject pode ser qualquer coisa adquirida do ambiente Lua. Podemos por exemplo criar uma função no ambiente Lua e chamá-la do nosso código Java da seguinte maneira:

//teste.lua

function HelloWorld()
	print "Hello world from Lua function";
end;

//Código java

package testeluajava;
import org.keplerproject.luajava.*;
public class Main {
	public static void main(String[] args) {
		LuaState l = LuaStateFactory.newLuaState();
		l.openLibs();
		l.LdoFile("teste.lua");
		try {
			LuaObject func = l.getLuaObject("HelloWorld");
			func.call(null);
		}catch(Exception e) {
			System.out.println(e.getMessage());
		}
		l.close();
	}
}

Voltando a nossa classe npc, para podermos usá-la precisamos criar uma “proxy” para ela, ou seja, precisamos dizer ao LuaJava que a nossa Interface INpc é compatível com nossa classe npc e que podemos usá-la para manipular nosso objeto. Fazemos isso através da função createProxy, como mostrado a seguir:

INpc npc = (INpc) obj.createProxy("testeluajava.INpc");

A função createProxy recebe como parâmetro o nome da Interface que desejamos fazer a Proxy (note que novamente precisamos passar o nome do pacote junto). A função retorna um objeto o qual fazemos casting para INpc. Uma vez feito isso podemos chamar as funções da classe normalmente. Aqui vai a listagem completa do código Java.

package testeluajava;
import org.keplerproject.luajava.*;
public class Main {
	public static void main(String[] args) {
		LuaState l = LuaStateFactory.newLuaState();
		l.openLibs();
		l.LdoFile("npc.lua");
		try {
			LuaObject obj = l.getLuaObject("Npc");
			INpc npc = (INpc) obj.createProxy("testeluajava.INpc");
			npc.setNome("Supersayajin");
			npc.falar();
		}catch(Exception e) {
			System.out.println(e.getMessage());
		}
		l.close();
	}
}

Note que, como estamos lidando com código externo a nossa aplicação é sempre bom tratar possíveis exceções. A função createProxy ainda nos obriga a tratar possíveis LuaException e ClassNotFoundExceptions.

Passando objetos por parâmetro

Quando trabalhamos com proxys chamando classes Lua no ambiente Java não precisamos chamar a função luajava.bindClass para usarmos em Lua uma classe Java que estejamos passando por parâmetro para algum método, a tipagem dinâmica do Lua cuida disso para nós, altere a INpc adicionando um novo método void postarNoBlog(PdjBlog blog); e implemente essa rotina na sua classe em lua:

postarNoBlog = function(blog)
	blog:newPost("Post do Npc ".. Nome);
end;

Quando chamarmos a função postarNoBlog podemos passar para ela um objeto do tipo PdjBlog, sem precisarmos usar a função luajava.bindClass. A seguir segue todo o código fonte para esse exemplo:

//PdjBlog.Java

package testeluajava;
import java.util.ArrayList;
public class PdjBlog {
	private ArrayList<String> posts = null;
	public PdjBlog() {
		this.posts= new ArrayList();
	}
	public void newPost(String post) {
		this.posts.add(post);
	}
	public void printPosts() {
		for (int i = 0; i < this.posts.size(); i++) {
			System.out.println(this.posts.get(i));
		}
	}
}

//INpc.java

package testeluajava;
public interface INpc {
	void setNome(String nome);
	void falar();
	void postarNoBlog(PdjBlog blog);
}

//Main.java

package testeluajava;
import org.keplerproject.luajava.*;
public class Main {
	public static void main(String[] args) {
		LuaState l = LuaStateFactory.newLuaState();
		l.openLibs();
		l.LdoFile("npc.lua");
		try {
			PdjBlog blog = new PdjBlog();
			LuaObject obj = l.getLuaObject("Npc");
			INpc npc = (INpc) obj.createProxy("testeluajava.INpc");
			npc.setNome("Supersayajin");
			npc.postarNoBlog(blog);
			blog.printPosts();
		}catch(Exception e) {
			System.out.println(e.getMessage());
		}
		l.close();
	}
}

//npc.lua

Npc = {
	Nome = "";
	setNome = function(nome)
		Nome = nome;
	end;

	falar = function()
		local texto = "Olá eu sou um npc, meu nome é " .. Nome;
		print (texto);
	end;

	postarNoBlog = function(blog)
		blog:newPost("Post do Npc ".. Nome);
	end;
}

Bom pessoal, esta foi uma pequena introdução ao que é possível fazer com LuaJava. Mais detalhes e tutoriais sobre o LuaJava podem ser conseguidos no site oficial do projeto www.keplerproject.org/luajava

Espero que tenham gostado.

Abraços e até a próxima. ;)

Dando um Zoom em Imagens

Autor: Christiano Lima Santos

Boa noite!

Bem, desta vez, vamos ver como fazer um efeito de zoom para as imagens.

Em primeiro lugar, definamos três coisas:

Zoom -> Efeito de escalonamento proporcional da imagem;
Zoom In -> Efeito de aumento do tamanho da imagem;
Zoom Out -> Efeito de redução do tamanho da imagem.

Seria ridículo se vocês saíssem daqui sem saber isso, né? =)

Bem, agora sim.
Estou falando tudo isso, porque algum tempo atrás estudei os efeitos de Zoom e consegui fazer isso de um jeito bem simples.
O caso é que, dada uma imagem de tamanho largura x altura, nós queremos exibir ela alterada por um determinado fator de zoom centralizada numa outra superficie de tamanho largura x altura.

O que vamos precisar é simplesmente varrer toda a imagem destino (ImgDest) e sair verificando qual a cor do pixel correspondente na imagem origem (ImgOrg).

Agora, a dúvida é: como saber qual o pixel de onde pegar a cor da ImgOrg?

Bem, como a gente falou, a imagem deve ficar centralizada.
Logo o pixel (largura/2, altura/2) de ImgDest deve ser igual ao pixel (largura/2, altura/2) de ImgOrg.

Agora, pensemos juntos. Se eu tenho um pixel de Img que está a uma distância X do centro, ao dobrar a imagem (zoom = 2), a que distância ela estará do centro? 2X.
Do mesmo jeito, se eu reduzir à metade o tamanho da imagem (zoom = 0.5), a que distância ficará? 0.5X.

Viu só? Da ImgOrg para a ImgDest, a distância para o centro fica multiplicada pelo fator zoom.
Mas nós falamos que vamos varrer a ImgDest, ou seja, nós vamos sair de ImgDest para achar valor em ImgOrg, então a gente aplica a operação inversa: divide a distância ao centro por zoom.

Então o que nós vamos ter que fazer é achar a posição relativa de cada pixel ao centro da ImgDest, dividir pelo fator de zoom, somar então novamente o valor do ponto central e então nós teremos achado o pixel correspondente na ImgOrg!

Ae vocês me perguntam… Desse jeito, eu posso pegar um pixel fora da ImgOrg! O que fazer nesse caso?
Simples: o Delphi automaticamente estabelece cor Preta caso o pixel não exista, mas daí vocês podem tratar dentro do código, primeiro verificando se aquele pixel realmente está nos limites, se não estiver, usam uma cor qualquer para plotar na ImgDest.

Ah! E já que vamos trabalhar com divisões, zoom tem que ser diferente de zero!

Bem, o algoritmo no Delphi fica da seguinte forma…

If zoom 0.0 Then
	exit;
for x := 0 to largura-1 do
	for y := 0 to altura-1 do
		ImgDest.Canvas.Pixels[x,y] := ImgOrg.Canvas.Pixels[
											trunc((x - largura/2)/zoom + largura/2),
											trunc((y - altura/2)/zoom + altura/2)];

Viu só como é simples?

Caramba, e eu sempre achando que era bem mais complicado!

Bem, pra concluir, vejam aqui duas imagens exibindo o resultado final…

Essa é a imagem original, vamos agora aplicar a ela um fator de zoom 3 (vamos ter uma imagem resultado correspondente a esse retângulo marcado aí no meio…)

Pronto, aqui está a imagem resultado, lembrando-se que aplicamos um fator de zoom 3.

Então já fica perceptível que para valores absolutos de zoom entre 0 e 1, teremos efeito zoom out (a imagem fica reduzida) e para valores absolutos de zoom maiores que 1, zoom in.

Mas, porque eu falei em valores absolutos?

Simples, porque quando zoom é positivo, a imagem vai ficar normal, mas… quando zoom é negativo, ocorre zoom in/out, mas a imagem final fica invertida (rotacionada 180 graus). Por quê? É só lembrar que nós dividimos por zoom para encontrar o pixel correspondente, nossa origem ( 0, 0 ) é o centro da imagem e, quando for negativo o zoom, irei portanto pegar o pixel do lado oposto da imagem (tanto na horizontal quanto na vertical) .

Bem, é só isso por enquanto, espero que tenham gostado.

Um abraço e até breve!

Pixel art isométrico – Parte 1

Autor: Thiago Valle

Esse texto trata sobre como fazer desenhos isométricos no computador. É um texto bem introdutório que só contém a base de isometria em pixel art. O texto ficou com muita teoria(bem mais que os outros tutoriais encontrados por aí). Decidi fazer dessa maneira já que as pessoas que trabalham, ou querem trabalhar com jogos tem que saber o que estão fazendo e não podem se prender a uma só técnica.

Recomendo que você abra o paint e vá desenhando de acordo com o texto para uma melhor compreensão. Bom estudo :D

O que é Pixel Art isométrico?

Pixel Art como muitos já sabem é a técnica utilizada para fazer desenhos no computador, pixel-a-pixel. Isometria já é um pouco mais complicado mas estamos aqui justamente pra isso :)

Isometria nada mais é do que uma maneira de reproduzir imagens em 3 dimensões em ambientes de 2 dimensões onde os ângulos entre 2 eixos são iguais a 120º. Ok, eu falei que ia ser fácil hehehe, então aqui vai uma imagem pra ilustrar o que eu tô falando:

Um cubo :)

Ou seja, em uma imagem isométrica os 3 eixos são desenhados com os mesmos ângulos, por isso o nome isometria(iso de igual, metria de medida). Não se preocupe porque essa parte matemática de isometria é mais importante pra criaçao de tiles complexos ou outras construções diferentes, nesse texto eu vou me focar em falar da parte mais simples, sem a matemática toda, o que já é suficiente pra criação de imagens satisfatórias.

Notem na imagem, que quando uma linha sai da horizontal, ela vai subindo com 1 pixel na vertical e 2 na horizontal, dessa forma:

Como fazer uma linha

Em teoria, o angulo formado seria de 30º, mas se nós formos desenhar dessa maneira e sem anti-aliasing os pixels ficam quebrados e com uma aparência meio estranha, então adotou-se esse esquema de desenhar 2 pixels a cada subida na vertical que na verdade forma um ângulo de 26.565º. Resumindo tudo, pra desenhar um quadrado em pixel art nós podemos seguir os seguintes passos:

Como desenhar um quadrado

Os vários tipos de pixel art isométrico

Ok, agora você já sabe desenhar um quadrado que é igual a um tile, agora é só pintar dentro juntar e pronto! Você tem um lindo chão pra um cenário, mas como a vida não é bela e sempre aparece um problema, as coisas não são bem assim. Quem tentou desenhar coisas mais complexas no paint(ou o software que você preferir) enquanto lia o texto pode ter notado alguns problemas na hora de juntar os quadrados. Vou explicar aqui algumas maneiras para contornar isso e principalmente quando contornar isso.

Para quem não tentou desenhar, o problema é mais ou menos o seguinte:

Primeiro nós desenhamos três quadrados

Depois nós tentamos juntar os três como se fossem tiles

Problema… As imagens simplesmente não juntam. Reparem que para corrigir isso nós poderiamos juntar o contorno delas

Isso realmente é uma construção possivel, mas não para tiles. Só é bom juntar o contorno de dois quadrados quando eles não forem tiles, geralmente se faz isso para criar bases para desenhos maiores, por exemplo:


Nesse caso não teve problema porque os quadrados eram vazios por dentro, e em tiles isso não acontece. Quando dentro do quadrado tem uma textura ou algo pintado(ou seja, um tile), se os contornos forem juntados vai ocorrer uma “colisão” de informações do desenho e alguma coisa vai acabar sendo apagada, por exemplo:

Existem varias maneiras de se corrigir esse problema, nesse texto eu vou falar uma das maneiras, no outro texto da série eu vou explicar com detalhes como fazer tiles. Nessa maneira de corrigir, os tiles são desenhados com 4 espaços horizontais na base, pra que embaixo caibam 2 do lado esquerdo e 2 do lado direito:

Ainda vale a pena notar outro tipo de construção de pixel art isométrico que existe. Algumas pessoas em alguns tutoriais falam que quando elas vão fazer um cubo, elas desenham o cubo com 3 pixels ao invés de 2 pra poder desenhar uma linha do meio sem que tenha problema de divisão:

Quando o cubo é desenhado com 2 pixels na base fica difícil decidir onde botar a linha pra dividir o cubo, então elas acabam criando 3 linhas pra poder ter o “meio” do cubo. Vale a pena notar que isso é não é util na criação de tiles, pois quando os cubos vão ser juntados com 3 pixels em cima e embaixo acaba tendo um problema e os pixels ficam serrilhados:

Ou seja, dependendo do motivo que você está fazendo a imagem em pixel vai importar em como você vai desenhar os quadrados. Quando o desenho é só para portfolio, não tem problema em juntar os contornos ou fazer o cubo com 3 pixels, já que o que importa é o resultado final. Mas quando os desenhos são para um jogo tem que ter em mente esse tipo de construção explicado acima(tanto no desenho quanto na programação do jogo).

Considerações finais

Com essa base já é possivel desenhar algumas coisas simples como retângulos e cubos. Por incrivel que pareça essa é a base de muita coisa de desenhos isométricos(dá até pra fazer uma casa assim!). Construindo variações de cubos é possivel desenhar um quarto, esse foi um que eu fiz em meados de 2003 mas utiliza boa parte do que eu falei aqui:

Você já pode criar coisas bem simples agora! No próximo texto eu vou ensinar construções mais complexas, tiles e outros detalhes :)

A Equipe de Desenvolvimento – Parte I: Game Designer

Autor: Luis Augusto Guimarães (Brainstorming)

Fala galera,

Estou preparando um série sobre Game Design para ajudar a todos, em breve começarei a postá-la aqui. Mas para meu primeiro artigo decidi direcioná-lo aos iniciantes, completando um pouco mais o tema aberto pelo Christiano.

Então este artigo abre a série “A Equipe de Desenvolvimento”.

Serão abordadas as áreas de atuação tais como Game Design, Produção, Programação, Artes Visuais, Controle de Qualidade – QA, e Level Design. Alguns profissionais de outras áreas constumam ser utilizados, geralmente como consultores ou técnicos, mas vamos focar aqui apenas os profissionais diretamente ligados ao desenvolvimento de jogos.

Parte I – Game Designer

Assumindo que o desenvolvimento de um jogo se inicia pelo seu projeto e que os resultados de todas as etapas de produção são originados pelas decisões tomadas nesse processo, vamos iniciar aqui abordando as funções e características do Game Designer.

Em suma, o Game Designer é responsável pela experiência de jogo, ou seja pelo Gameplay. O Game Designer deve trabalhar desde o momento da idéia inicial do projeto até os últimos testes de qualidade, em alguns casos extrapolando essa linha de tempo, buscando soluções em pacotes de expansão e correção de lacunas do Gameplay.

Gameplay tem a ver com todas camadas do desenvolvimento de um jogo, incluindo cada aspecto como jogabilidade, áudio, gráficos, interface, sistema de input. Isto automaticamente significa que o Game Designer deve conhecer as noções de cada área envolvida no desenvolvimento, e ter capacidade para interagir com cada integrante da equipe. Nas palavras de Clifford Bleszinski, Lead Designer da Epic Games nos jogos Unreal Tournament e Gears of Wars, o projeto criado para o jogo não diz respeito apenas a “fazer o melhor jogo possível”, mas “fazer o melhor jogo possível com o tempo, dinheiro, quantidade e características da equipe à disposição”.

Dentre as principais tarefas desenvolvidas pelo Game Designer estão:

• Organização e coordenação de seções de brainstorming;
• Coordenação e criação de protótipos;
• Testagem de Gameplay e desenvolvimento de soluções;
• Desenvolvimento, apresentação e atualização do Game Design Document – GDD.
• Coordenação e participação na equipe de Level Design, atentando para os resultados da estrutura dos cenários para o Gameplay.

Algumas companhias não possuem um cargo explícito de Game Designer, sendo esta parte executada por outros membros da equipe. Dependendo dos objetivos definidos para o projeto, essa pode ser uma característica negativa para a equipe, pois o processo de Game Design exige tanta atenção quanto as demais áreas – ou mais, quando consideramos que Game Design não se faz apenas no horário comercial dentro do escritório, mas 24 horas por dia durante todo o período de desenvolvimento, sendo necessário que a pessoa esteja com a mente totalmente voltada para a tarefa.

O profissional focado em Game Design passa a ter uma visão diferenciada e objetiva do projeto em que trabalha. Além de encontrar rapidamente soluções para os problemas surgidos nos meados do processo de desenvolvimento, o Game Designer tende a prever esses problemas e evitar que a equipe seja pega pelo inevitável ou inesperado a todo instante. O envolvimento com os processos cognitivos e com as outras áreas de desenvolvimento gera este equilíbrio necessário entre crença e dúvida que capacita o profissional e ter de antemão a noção apurada dos resultados, e a capacidade de encontrar soluções para corrigir o percurso do projeto fazendo com que as metas previstas sejam atingidas.

É isso aí galera, as tarefas e cognições específicas para o Game Designer serão abordadas nos artigos específicos. Para as demais áreas que completam a equipe de desenvolvimento, este é um convite para que as pessoas mais focadas nas áreas específicas completem esta série… (vamos movimentar aí galera…) Espero que este material tenha sido útil e que a série auxilie os iniciantes a decidir por qual caminho deseja traçar sua carreira.

E fica por aqui…

Rastreando (e lucrando com) seus games em Flash

Autor: Strid

UPDATE: Infelizmente a companhia MochiMedia encerrou suas atividades em início de 2014 e com isso foi-se embora também o MochiBot, sendo assim, estamos mantendo este artigo aqui para fins de preservação de arquivo.

MochiBot, uma ferramenta criada pela MochiMedia para auxiliar os desenvolvedores de conteúdo em flash, é um tracker gratuito que rastreia quantidade e o local de acesso aos seus SWFs.

Por que rastrear?

Vigiando seus SWFs, você pode ter uma noção melhor da “vida útil” dos seus jogos, além de saber exatamente, onde seus jogos podem chegar quando não se faz o sitelock (não se assuste em vê-lo sendo distribuído em um site no Tailândia)

O MochiBot também traz possibilidade de implementação de um API de feedback, na qual o usuário pode dar uma nota e escrever um comentário, e então o autor tem fácil acesso a todos através do site.

A implementação do MochiBot é rápida e simples, ele atua de forma invisível – exceto quando implementada a API de feedback- os dados são atualizados todos dias e o serviço é totalmente gratuito.

-“Mas e quanto ao lucrar? Não vi o ”lucro” ainda!”

Lucrar com seus games em Flash, é possível sim, mas não tão fácil, uma outra ferramenta criada pela MochiMedia, é o MochiAds, de implementação parecida com o MochiBot, porém ao invés do rastreamento, a proposta é apresentar ads nos seus games em Flash.

O desenvolvedor recebe uma parte do lucro obtido com as visualizações de ads (sim, visualizações, e não cliques), os ads duram 10 segundos, e podem ser apresentados na abertura do game, ou entre níveis, com um intervalo mínimo de 2 minutos entre cada ad.

O eCPM (valor pago a cada 1000 impressões de ads) é baixa em comparação aos padrões, porém a grande vantagem do sistema do MochiAds é que os ads serão exibidos, e creditados em sua conta, onde quer que estejam, assim aquele seu jogo que fez sucesso na Tailândia continua a lhe trazer algum retorno.

Assim como o MochiBot, a implementação do MochiAds é rápida e fácil, normalmente seu game é analisado e aprovado em 24 horas.

Porém, não espere lucrar horrores com o sistema de ads, para conseguir alcançar o valor mínimo($100.00 USD) e então receber seu primeiro pagamento, vai lhe exigir um verdadeiro “hit”, ou então diversos games de nível intermediário. A subida é longa e a vista não é tão bonita assim, mas é algo que pode dar a motivação pra finalizar aquele seu projeto abandonado e liberá-lo na rede. Muitos iniciantes no desenvolvimento de games (como eu) adotam o flash pela sua facilidade de desenvolvimento, e também pela facilidade em distribuir e apresentar seus experimentos, portanto vejamos como incentivo adicional nesse sentido.

Indo buscar o seu

Vale lembrar que esta não é a única forma de fazer algum dinheirinho com seus games em flash. O número de portais de flash games tem crescido bastante, e novas oportunidades surgem para desenvolvedores, dentre elas as estão possibilidades de negociação com quem fará – ou já está fazendo! – dinheiro com os SEUS jogos…

Estes são os médios e grandes portais, que pagam uma quantia variável para exibir um splash na abertura do seu game, e/ou um link para o portal no menu do mesmo. Quem joga flash games já deve ter visto pelo menos algum destes: ArmorGames, CrazyMonkeyGames, ArcadeTown, FreeWorldGroup dentre outros.

Tais negociações são as famosas sponsorships, onde o desenvolvedor cede este espaço para divulgação do portal, mas continua com todos os direitos do game, podendo distribuí-lo onde quiser, limitado a apenas manter os links para o portal em todas distribuições.

Uma boa fonte de informações para sponsorships, inclusive exemplos de valores já pagos a outros flashgames, é o site FlashGameSponsorship, mantido pelo criador de Asteroids Revenge, game que alcançou o valor de $4,300 USD em um acordo de sponsorship.

Além do valor pago, também é comum negociar ad revenue, em formato de advances (após o seu game “se pagar”, atingindo o valor inicial pago pelo portal, você continua recebendo uma parcela dos lucros que o portal obtiver com o seu game)

Existem também outras possibilidades, como licenciamentos exclusivos, venda dos arquivos fonte e direitos sobre o game, ou até mesmo montar seu próprio portal. Oportunidades não faltam.

Assumindo a vanguarda

No meio de diversos portais com os mesmos games, exibindo os MochiAds e SplashScreens de seus patrocinadores, alguns se destacam pela diferença, como é o caso do Kongregate, já entitulado “Youtube dos Games”, nele os usuários podem conversar enquanto jogam, ao mesmo tempo que competem para conseguir pontos e subir de nível, tais pontos vem através da realização de tarefas específicas dentro dos games(implementadas pelos desenvolvedores em conjunto com a admnistração do site), ou enviando seus próprios jogos e alcançando boas notas perante a comunidade. O Kongregate em concordata com a MochiMedia bloqueia a exibição de MochiAds em seu site, no entanto, possui um programa próprio de ad revenue com os desenvolvedores, que inicia em 25%, podendo ser acrescido em 10% através da implementação de um API que registra os HighScores no portal, e outros 15% caso o game tenha exclusividade garantida para o portal (podendo ser desativada mais tarde).

Calma, já está acabando

Meu objetivo neste primeiro post foi o de apresentar algumas possibilidades para entusiastas em desenvolvimento de games em flash, muitas vezes subestimado como plataforma, mas que tem mostrado garantir seu espaço, e este felizmente não se limita a advergames ou serious games em geral. Será questão de tempo para que o estigma de “flashgame = jogo bobo” se desmanche.

[]”s e até a próxima

Sou Iniciante… E agora?

Autor: Christiano Lima Santos

Boa noite a todos!

Chegou a minha vez de falar um pouco. Como Edmar já deu início com um tema da categoria Programação (e foi uma excelente escolha, por sinal), não vou trazer agora um tema dessa área. Não se preocupem que traremos muito mais conceitos e técnicas, afinal, em 2005, Edmar e eu estudamos sobre como programar vários efeitos gráficos e nada melhor que estarmos passando para vocês um pouco sobre esses estudos, não?

Meu primeiro tópico, então, será mais um dos esforços da PDJ voltados a orientar os iniciantes a fim de criarmos uma boa cultura, uma boa atmosfera dentro da PDJ. Estivemos há pouco tempo discutindo sobre isso na PDJ e sei que alguns acham que deveríamos focar outros aspectos, mas não se preocupem que nós vamos fazer isso também, ok? Afinal, já somos cinco autores (o Brainstorming também entrou para a equipe, outra hora publico aqui a sua biografia e “oficializo” isso, :) ) e teremos muito o que conversar e apresentar aqui.

Uma cena que se repete muito, não somente na PDJ, mas em todas as comunidades e sites sobre desenvolvimento de jogos, é aquela (já clássica) em que alguém acabou de se inscrever no fórum, é a sua primeira mensagem, diz que já leu muito sobre criação de jogos e quer formar uma equipe para criar um MMORPG 3D de forma gratuita.

Sempre a gente encontra alguém com um novo projeto em um fórum sobre criação de jogos pedindo ajuda do pessoal para o desenvolvimento de um mega-sucesso e quando a gente começa a perguntar algo para a pessoa, a gente percebe que ela não sabe nem por onde começar e, uma ou duas semanas depois, já desistiu do projeto… Pessoal, não é por aí…

Vou então hoje gastar tempo dizendo algumas coisas que o pessoal tem que saber…

1. Descubra como realmente funciona um jogo!

Muita gente gosta deste ou daquele jogo e daí tem a grande idéia de fazer algo parecido acrescentando novos elementos. Ótimo! Mas quando se dão conta, eles não sabem como exatamente é a estrutura de um jogo, como ele deve ser desenvolvido, o porquê das coisas funcionarem de um determinado jeito. Então, como primeiro passo, estude alguns conceitos-chave. Não se preocupem, mais a frente será publicado aqui no blog algumas coisas para orientar nesse sentido, por mim ou pelos outros autores, ok?

2. Procure uma área em que se encaixe!

O desenvolvimento de um jogo já fora no passado multidisciplinar, agora está sendo transdisciplinar (agradecimentos ao prof. Henrique Nou Schneider que conseguiu me fazer entender a importância da transdisciplinaridade na informática) e como não dá para fazer tudo sozinho, o cabe a você escolher por algo que seja da sua preferência e então cuidar daquilo. Quando for procurar um curso técnico ou universitário, procure cursos que irão de alguma forma complementar seus conhecimentos naquilo com que você trabalha, ok?

3. Procure manter contato com pessoas mais experientes na área:

Sim, porque você não vai conseguir aprender tudo sozinho, ok? Então é importante que você mantenha em seu e-mail, MSN, Orkut, etc. uma lista de pessoas que você sabe que também estudam ou trabalham na área de desenvolvimento de jogos. Não precisa ser só na sua área, por exemplo, muitas vezes é bom para um artista gráfico manter contato com um programador (na verdade, sempre é bom!). Muitas vezes você precisará da ajuda deles! Procure a todos, não fique acanhado pelo fato de fulano já estar trabalhando na área e você vai estar “tomando o tempo dele”, tentar manter contato não faz mal a ninguém (agora, lembre-se disso também para não estar tomando tempo demais da pessoa com perguntas que você poderia conseguir a resposta prestando um pouco mais de atenção em apostilas, fóruns, etc).

4. Busque Ferramentas e/ou técnicas a serem usadas

Estude a maior diversidade de ferramentas que possa usar em seu trabalho e escolha as que melhor se adeqüem ao seu estilo e faça a mesma coisa para escolher as técnicas, lembrando-se sempre de levar em consideração a forma como surgiram, para que servem, em que os mais experientes a empregam, onde eles não aconselham, etc. Lembrando-se de levar em consideração o grau de complexidade de cada uma, ou seja, para aprendizado escolha ferramentas e técnicas mais simples, rudimentares. Com o tempo você vai aprendendo mais e mais e vai trocá-las por outras melhores.

5. Busque tirar dúvidas com outras pessoas:

Está tendo algum problema? Acha que não é daquela forma? Bem, em primeiro lugar: a net é ótima para se encontrar soluções, pesquise, procure. Não achou? Pergunte em algum fórum ou a alguém, busque a solução e você a encontrará. Persista, sempre!

6. Sempre teste os seus conhecimentos:

Aprendeu a desenhar de uma certa forma? Experimente desenhar então alguns personagens para testar e aperfeiçoar o seu traço. Aprendeu como imprimir na tela? Então tente imprimir diversas informações na tela, como textos, imagens, etc. Vá sempre testando e mudando um pouco de acordo com o que precisa, assim você irá gerar novos conhecimentos, os quais você poderá apresentar em fóruns, contribuindo assim com outros que estão iniciando. Não procure testar diretamente seus conhecimentos em um projeto muito grande, porque provavelmente você vai se atrasar nele, vai perder o gerenciamento do mesmo, etc. No máximo, um demo bem rudimentar, bem simples, só com as funcionalidades principais.

7. Produza alguns demos de jogos já existentes:

Pronto! Neste ponto, talvez você precise juntar-se a outras pessoas de outras áreas, para que cada qual faça uma parte e, assim, consigam ter finalmente algo que já podem dizer SEU. Mas o problema maior é que nesse ponto o pessoal ainda teima em querer fazer um super-projeto gigantesco… TOC-TOC? Tem alguém aí? É pra fazer algo bem simples! Tipo, um Space Invaders, depois um Tetris ou outro jogo de puzzle bem simples, mais tarde pode tentar fazer um jogo de nave 2D (shoot”em up) e prossegue, fazendo um jogo de plataforma 2D (like Mario), etc. Mas lembrando que o objetivo nesta fase é só desenvolver algo para testar os conhecimentos da equipe! Não é ainda fazer um projeto de jogo de acordo com como sempre é feito por aí afora, ok? Mas se vocês quiserem já deixar tudo o mais pro, e é o que vocês vão querer, para já irem treinando, então o projeto do demo deve seguir as seguintes etapas: brainstorming para decidir como será o jogo, elaboração completa do Game Design Document, análise e modelagem do jogo, implementação do mesmo, testes, divulgação e distribuição, elaboração do post mortem. Lembrando que durante todas essas etapas deve estar sendo feita a documentação de tudo o que for possível, ok? Em outra ocasião explicaremos qual a importância de cada passo.

8. Mais treinamento de equipe!

Bem, pessoal, como o nosso próximo passo já será o desenvolvimento de um projeto, devemos então intensificar o treinamento da equipe nas ferramentas que serão utilizadas a fim de que todos estejam em harmonia com as tecnologias e manter a comunicação ao máximo entre os membros. Sem contar que neste momento deve-se trazer inspiração e responsabilidade a todos para o desenvolvimento.

9. Desenvolvimento de um projeto de jogo:

Bem, se tiverem seguido tudo o que vim dizendo até aqui, com certeza o projeto de vocês será um sucesso, devendo lembrar-se de somente algumas coisas que sempre têm que ser visadas pela equipe: manter o cronograma em dia, seguir a metodologia de desenvolvimento adotada pela equipe e manter todos comprometidos com o desenvolvimento (seriedade e responsabilidade).

10. Divulgue o material produzido, contribua com a comunidade!

Bem, como a regra-base é sempre “10 mandamentos”, então, esta aqui não deve ser desconsiderada: se eu estou passando aqui tudo o que eu aprendi a vocês para que possam também desenvolver-se na arte sem terem que percorrer todos os sacrifícios do “caminho de espinhos”, não sejam tão egoístas a ponto de não ajudarem os próximos, né? Lembre-se: aquele que aprendeu com você ontem, pode ser seu parceiro em algum projeto hoje e quem sabe te ensinar algo amanhã! Sendo assim, divulgue a documentação de alguns projetos seus, post mortens, apresente algumas técnicas utilizadas no desenvolvimento, etc.

Há muitas outras coisas a se dizer. Claro que isto aqui não é tudo. É vital, por exemplo, a participação em comunidades. E não estou falando de entrar, ler e sair. Estou falando de participar MESMO! Escrever suas dúvidas, responder as de outros, etc.

Qual foi o último livro da área que você fez? E curso? E sites? Não adianta me apontar uma lista com mil sites se você não está lendo o que há neles! Eu, por exemplo, estou lendo alguns artigos do GamaSutra, e você, o que está lendo?

E por falar em ler, espero que já tenha ido até a seção “Iniciantes” da PDJ para uma boa leitura!

Bem, pessoal, por enquanto é isso, espero que eu tenha ajudado alguém hoje, até mais!