Archive for admin

Jogos eletrônicos na Educação: Um estudo da proposta dos jogos estratégicos

Resumo:

Esta monografia estuda a problemática do uso de jogos eletrônicos de estratégia no processo ensino-aprendizagem. Inicialmente faz-se uma contextualização da Educação e do jogo na sociedade. A seguir é apresentado o conjunto principal de recursos tecnológicos e respectivos fundamentos teóricos da Ciência da Computação utilizados na implementação de jogos eletrônicos.

É dada uma atenção especial à questão de usabilidade e acessibilidade das interfaces de jogos eletrônicos, baseando-se nos conceitos e princípios da Ergonomia e da Interação Humano-Computador. Adiante se discute o uso dos jogos eletrônicos estratégicos na Educação e apresenta-se a fundamentação teórica no campo pedagógico que justifica a sua utilização, apresentando exemplos que corroboram a  tese desta proposta. Finalmente são feitas as conclusões e comenta-se sobre futuras extensões vislumbradas na elaboração deste construto teórico.

Autores:

Christiano Lima Santos

Frederico Santos do Vale

Downloads:

Jogos eletrônicos na Educação: Um estudo da proposta dos jogos estratégicos – monografia (PDF)

Jogos eletrônicos na Educação: Um estudo da proposta dos jogos estratégicos – apresentação(PPT)

Share and Enjoy

  • Facebook
  • Twitter
  • Delicious
  • LinkedIn
  • StumbleUpon
  • Add to favorites
  • Email
  • RSS

Desenvolvimento de games para o mercado internacional


Palestra apresentada por Juliano Barbosa Alves, da Oniria Entertainment, na 2ª Jornada de Jogos Digitais da PUC-Minas.

Efetue o download da apresentação em formado PDF clicando no seguinte link:

Desenvolvimento de Games Para o Mercado Internacional

Share and Enjoy

  • Facebook
  • Twitter
  • Delicious
  • LinkedIn
  • StumbleUpon
  • Add to favorites
  • Email
  • RSS

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. 😉

Share and Enjoy

  • Facebook
  • Twitter
  • Delicious
  • LinkedIn
  • StumbleUpon
  • Add to favorites
  • Email
  • RSS

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!

Share and Enjoy

  • Facebook
  • Twitter
  • Delicious
  • LinkedIn
  • StumbleUpon
  • Add to favorites
  • Email
  • RSS

A equipe de desenvolvimento – parte 1: 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…

Share and Enjoy

  • Facebook
  • Twitter
  • Delicious
  • LinkedIn
  • StumbleUpon
  • Add to favorites
  • Email
  • RSS

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!

Share and Enjoy

  • Facebook
  • Twitter
  • Delicious
  • LinkedIn
  • StumbleUpon
  • Add to favorites
  • Email
  • RSS

Grayscale

Autor: Edmar Souza Jr.

O Efeito Grayscale (Escala de cinza)

O efeito escala de cinza, como o próprio nome diz, visa transformar uma imagem colorida em uma imagem com tons de cinza (:P). Este é um efeito bem interessante, pois pode ser usado de diversas maneiras, tanto criando paisagens com ares misteriosos, tanto para servir como a paleta do jogo inteiro.

Como fazer a conversão?

Bom, vou apresentar aki duas técnicas de conversão: A conversão por porcentagem, e a conversão por média. Estas são apenas duas técnicas que eu conheço, mas podem haver mais.

Conversão por média

Este é sem dúvidas o modo mais simples de se fazer, mas também o mais precário. Tudo que fazemos com ele é pegar os valores dos componentes R, G e B e obtermos sua média. Fazemos isso com cada um dos componentes.

O código é o seguinte

r := (ir + ig + ib) div 3;
g := (ir + ig + ib) div 3;
b := (ir + ig + ib) div 3;

cor:= RGB(r,g,b);

ir, ig e ib são valores pegos previamente e representam respectivamente os componentes R, G e B do pixel selecionado. Podemos pegar esses valores usando as funções GetRValue, GetGValue e GetBValue, como no exemplo a seguir:

ir := GetRValue(Origem.Picture.Bitmap.Canvas.Pixels[x, y]);
ig := GetGValue(Origem.Picture.Bitmap.Canvas.Pixels[x, y]);
ib := GetBValue(Origem.Picture.Bitmap.Canvas.Pixels[x, y]);

Nada de mais né?

Entretanto…

Imagine que temos uma imagem dividida em três partes, sendo cada uma preenchida com uma cor diferente, vermelho, verde e azul. O que acontece? Ela vai ficar totalmente cinza. Como resolver isso?

Conversão por porcentagem

Este métódo eh um pouco mais complicado, mas não tanto, tudo o que fazemos é simplesmente usarmos a porcentagem dos componentes. A porcentagem de cada componente pode variar. Vamos ver um exemplo:

r := Trunc(0.3 * ir + 0.59 * ig + 0.11 * ib);
g := Trunc(0.3 * ir + 0.59 * ig + 0.11 * ib);
b := Trunc(0.3 * ir + 0.59 * ig + 0.11 * ib);

Simples certo? Quem me passou esta escala de porcentagem foi o Christiano, de acordo com ele esta é a escala usada pelo Photoshop. Bom, sendo ou não. Ela funciona 😀 e é o que importa.

Com isso, solucionamos o problema mencionado acima, pois estamos trabalhando com a porcentagem de cada componente. E não com a média de seus valores. Note por exemplo, que o resultado da média da cor vermelha, por exemplo, será igual ao resultado da média da cor verde:

Vermelho:

(255 + 0 + 0) / 3 = 85

Verde:

(0 + 255 + 0) / 3 = 85

Essa é a falha que ocorre na primeira técnica. Já na segunda técnica:

Vermelho:

76,5 + 0 + 0 = 76,5

Verde:

0 + 150,45 + 0 = 150,45

Notaram a diferença 😀

Bom, é isso ai e tenham um ótimo dia.

😉

Share and Enjoy

  • Facebook
  • Twitter
  • Delicious
  • LinkedIn
  • StumbleUpon
  • Add to favorites
  • Email
  • RSS

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 😀

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 :)

Share and Enjoy

  • Facebook
  • Twitter
  • Delicious
  • LinkedIn
  • StumbleUpon
  • Add to favorites
  • Email
  • RSS

A evolução dos jogos eletrônicos

Todos nós convivemos com jogos já há bastante tempo, isso é fato.

Os jogos saltaram das telas dos computadores e consoles e invadiram televisores, celulares e outros dispositivos que, há 10 anos atrás, jamais imaginaríamos ser possível.

Bem, vamos agora fazer aqui um “túnel do tempo” e analisar um pouco do que aconteceu com os jogos.

O desenvolvimento de um mercado de jogos só foi realmente possível a partir do início da década de 70, graças à popularização da informática e redução dos preços dos equipamentos. Nascia assim o período áureo das “empresas de garagem”, onde jogos com capacidade gráfica e game design limitados devido às restrições na tecnologia eram desenvolvidos a nível comercial por todo tipo de profissionais, desde doutores em tecnologia a estudantes de colegial: o que valia era o resultado final e como eram poucos os jogos na época, tudo acabava sendo válido!

Com o tempo, essas empresas foram saindo das garagens e criando cada vez mais equipamentos específicos para jogos, os chamados consoles. O Odyssey foi o primeiro console, lançado em 1972. É nessa época também que os arcades, fliperamas e “máquinas de pinball” tornam-se sucesso.

Vemos aqui já melhorias devido à expansão tecnológica.

No início da década de 80 uma crise em todos os ramos da indústria do entretenimento abalou muitas empresas, fechando as portas de várias delas.

Mais tarde o lançamento dos computadores pessoais (PC) trouxe um novo grande abalo à indústria de jogos para consoles, por ser uma ferramenta com preço acessível e capaz de desempenhar várias outras tarefas além de executar jogos.

O tipo de mídia para armazenamento dos jogos mudou, sendo agora gravados em cartuchos ou CD-Roms. Consoles como Master System, Mega Drive e Super Nintendo (conhecido no Japão como Super Famicon) são lembrados ainda hoje por seus jogos.

Enquanto os jogos evoluíam, os acessórios utilizados também foram desenvolvendo-se a fim de propiciar o máximo de conforto e facilitar. Estamos falando de mouses, teclados, telas LCD sensíveis ao toque, joysticks, etc.

Como na guerra e nos jogos vale tudo, registrou-se a saída da Sega do mercado de desenvolvimento de consoles devido a fracassos financeiros de alguns projetos seus, dentre eles, o Dream Cast; hoje a Sega atua somente no desenvolvimento de jogos.

Por que estudar a História dos Jogos Eletrônicos?

Sim. Eu sei que muito provavelmente você não quer ler a respeito do passado dos jogos, afinal, você não quer fazer um jogo com a cara dos jogos dos anos 1970, não é?

Tudo bem, isso é até compreensível, mas… Por que mesmo que estudamos História nas escolas?

Quem estuda História nas escolas aprende muito a respeito das civilizações passadas, sua organização social, suas ideologias. Mas não é somente isso: aprendemos também quais erros levaram a quais conseqüências, bem como quais foram os fatores que levaram àqueles erros.

Da mesma forma, quando você estuda a História dos jogos, você não está somente olhando o “como eles eram no passado”, mas sim, estudando o momento em que eles surgiram para saber o que permitiu determinados avanços. Assim sendo, quem estuda sua evolução pode perceber mais facilmente fatores que possam levar a mudanças na indústria de jogos (surgimento de um novo gênero, uma nova tendência quanto a equipamentos ou características dos jogos, um novo público se formando, etc).

E como profissionais bem formados e informados que somos, não queremos ser guiados por outros para que possamos perceber isso, mas sim, queremos ter bagagem suficiente para que possamos fazer nossas inferências e, assim sendo, buscar nos destacar na indústria.

Sendo assim, é imprescindível um bom estudo a respeito da evolução dos jogos eletrônicos a fim de que possamos “compreender melhor o presente e o futuro a partir da análise do passado”.

Antes de começar a falar realmente sobre nosso assunto, quero comentar que, quem estiver interessado a saber mais a respeito, pode procurar por fontes como os escritos dos pesquisadores Lynn Alves e Ricardo Santos, reportagens do UOL JOGOS e a Wikipedia Inglesa, que foram o ponto de partida deste trabalho.

Além destes, se você estiver particularmente interessado na evolução dos jogos eletrônicos brasileiros, um bom ponto de partida é o GameBrasilis, um catálogo da produção nacional, confeccionado e distribuído pelo Senac-SP. Uma observação: já faz algum tempo que o Senac-SP publicou e distribuiu este catálogo, portanto, pode ser “um pouco muito difícil” conseguir encontrá-lo. Eu já tenho o meu!

Até 1950 – A Era das Sombras

Tudo bem, tudo bem, eu sei. Não foi um período tão ruim assim, mas… Não havia computadores nem vídeo games… Ora, o que eles faziam para se divertir?

Apesar de acharmos que aqui nada temos, podemos encontrar facilmente os antecessores de nossos jogos digitais, como os jogos de tabuleiro, cartas e tantos outros, sendo o mais próximo deles o Pinball.

Xadrez, Damas e Go são apenas alguns dos tantos jogos de tabuleiro que já existiam nesta época e que seriam mais tarde implementados em jogos digitais.

A característica competitiva é uma máxima dos jogos de tabuleiro dessa época, e não falamos somente dos jogos mais recentes, pois mesmo jogos pertencentes a civilizações antigas já possuíam essas características, como é perceptível no jogo Senat, pertencente à civilização egípcia, e o jogo de Ur.

Jogo Senat (à esquerda) e Jogo Real de Ur (à direita)
Jogo Senat (à esquerda) e Jogo Real de Ur (à direita)

Em 1931, David Gottlieb criou o Baffle Ball Machine, considerada a segunda máquina de Pinball, responsável não só pela popularização do mesmo, mas também pelo impulso que viria a dar na indústria de jogos eletrônicos (o Pinball é um dos responsáveis por começar a criar um público receptivo a esse tipo de diversão).

Outro fator responsável pelo surgimento da indústria dos jogos foi a evolução tecnológica capaz de reduzir as dimensões dos computadores (como o advento dos transistores) e melhorar a forma como as informações eram passadas do sistema para o usuário (como a criação de tubos de raios catódicos).

[O conteúdo aqui apresentado é parte do livro “Press Start – Uma Introdução ao Game Design”, que faz parte do nosso curso de Introdução ao Game Design]

Share and Enjoy

  • Facebook
  • Twitter
  • Delicious
  • LinkedIn
  • StumbleUpon
  • Add to favorites
  • Email
  • RSS

Por que um livro sobre Game Design?

Não se acanhe! Pode se aproximar, sentar-se em uma poltrona e sentir-se em casa, pois se você está lendo estas linhas agora é porque você tem um interesse em comum comigo: o desenvolvimento de jogos, mais especificamente a área de Game Design. E se temos algo em comum, sinta-se desde já meu amigo e convidado a conversar, discutir sobre isso (só não fale muito alto, pois alguém pode estranhar ao vê-lo falando com um livro, ok?).

Falar que no Brasil há empresas e pessoas interessadas no desenvolvimento de jogos é dizer aquilo que já é óbvio – de serious games a jogos para dispositivos móveis, temos diversas empresas atuando no ramo de entretenimento.

Claro, se há indústria, se há pessoas interessadas, deve haver algum meio dessas pessoas conseguirem acesso a informações sobre isso. No caso, se há pessoas querendo desenvolver jogos, alguém deve lhes dizer como conseguir isso!

Falamos então de cursos, livros, sites, artigos, congressos e tantas outras coisas que vêm tratando desse assunto tão produtivo. Produtivo do ponto de vista financeiro, por se tratar de uma indústria bilionária, e do ponto de vista cultural, uma vez que se trata de levar às pessoas a satisfação por meio da diversão. Esta é ou não é uma atitude nobre?

Entretanto, toda vez que eu vou a uma livraria ou um congresso e verifico o que anda acontecendo, só ouço falar de programação, técnicas de renderização, algoritmos para redes e inteligência artificial, modelagem 3D, etc. Mas… e quanto ao Game Design?

Uma área tão importante como essa, que lida com todo o projeto do jogo, envolvida diretamente com o planejamento da experiência contida em um ambiente virtual, deveria ser ao menos um pouco mais discutida, não acha?

Então acho que a pergunta certa não seria “Por que um livro sobre Game Design?”, mas sim “Por que NÃO um livro sobre Game Design?”.

A indústria brasileira de jogos está amadurecendo e acredito que está mais do que na hora de mostrar que sabemos não somente programar ou modelar – também somos capazes de projetar os jogos.

A literatura sobre Game Design no Brasil é bastante escassa. Sei que minha contribuição não será suficiente para suprir toda essa deficiência, seria arrogância demais pensar isso. Se fosse possível, áreas de estudo já bem consolidadas como programação em C++ não teriam mais novos livros sendo lançados periodicamente, como vemos ocorrer.

Espero, sim, que meu livro possa ser mais um a apresentar ao leitor esta área tão nobre e interessante.

O que você pode aprender aqui

Uma vez que muitas pessoas que estão lendo esse livro podem estar “caindo de pára-quedas” aqui, ou seja, sem muita experiência sobre como funciona o mercado de jogos e o processo de desenvolvimento, decidi trazer aqui algumas informações capazes de guiá-los para melhor compreender como funciona o mercado de jogos e cada uma das áreas que atuam no processo de desenvolvimento de um jogo.

Só isso já seria assunto bastante para um livro e não podemos esquecer que nosso objetivo aqui é discutir sobre Game Design e, sendo assim, devemos responder algumas perguntas fundamentais: O que é jogo? Por que jogos digitais? E por que as pessoas jogam?

Bem, só falar o que é jogo não basta. Não para você, interessado em Game Design e que em breve poderá estar atuando neste mercado. Você precisa conhecer cada um dos componentes de um jogo, então discutiremos sobre os princípios que há por trás de cada jogo, bem como sobre as partes que o compõem.

Espero também que, por meio da leitura desse livro, você conheça um pouco da área de Game Design, bem como algumas de suas especialidades, como Level Design e Game Interface Design. Nesse estudo temos não somente a teoria, mas também a apresentação de alguns dos artefatos gerados durante suas atividades, como o game design document – ou documento de projeto de jogo, se preferir o termo em português.

O que você não pode aprender aqui

Uma das coisas que me perguntam é se com o que discutiremos aqui se pode criar jogos. Sim e não.

Na criação de um jogo, temos várias atividades e algumas delas são reservadas para a área de Game Design, ou seja, estamos discutindo aqui principalmente sobre parte do processo, não sobre o todo.

Você não aprenderá aqui, neste livro, como programar um jogo, por exemplo. Falamos sobre artes, sons e algumas técnicas, mas não mostramos como aplicá-las em ferramentas de edição gráfica ou sonora.

O que você vai precisar

Se você pretende desenvolver algum projeto de jogo enquanto lê esse livro (e eu aconselho fortemente a fazer isso a fim de melhor fixar e compreender cada detalhe), você pode necessitar de algumas ferramentas.

Não, não vou lhe pedir para adquirir uma licença milionária de um mega-software. Vou lhe indicar o que você realmente irá empregar: qualquer software para edição de imagens (para as imagens que compõem um protótipo de interface em papel) e um processador de texto (para o game design document).

Infelizmente cobrimos muito pouco da parte de level design, trazendo somente alguns dos vários conceitos presentes na área, mas são suficientes caso você queira criar algum cenário e ver em prática como a teoria se comporta na prática. Para isso, você pode escolher trabalhar com qualquer ferramenta para modificação de jogos ou criação de mapas. Você pode conseguir isso em vários deles, como os jogos das séries Unreal, Quake, Half Life e Warcraft (por falar nisso, Dota é um mapa para Warcraft 3, uma das modificações mais jogadas atualmente, creio que perdendo somente para o Counter Strike, uma modificação de Half Life).

Estrutura do livro

Este livro encontra-se dividido em capítulos, cada qual explanando sobre um dos vários temas aqui abordados.
O primeiro capítulo, A Evolução dos Jogos Eletrônicos, retrata os principais fatos que marcaram a história da indústria de jogos eletrônicos.

O segundo capítulo, Por Dentro do Mercado de Jogos, descreve conceitos importantes para a compreensão do funcionamento da indústria de jogos, citando desde as plataformas de execução dos jogos até a organização existente no processo de desenvolvimento e distribuição de um jogo.

O terceiro capítulo, Jogando o Jogo, é um pouco mais extenso e é focado em fazer uma ampla análise que começa com a importância dos jogos na vida das pessoas e classifica os jogos digitais e seus jogadores a fim de melhor compreendê-los.

O quarto capítulo, Decompondo o Game Design, cumpre duas tarefas: descrever a atividade de Game Design, bem como sua situação no Brasil e no mundo, e estudar minuciosamente cada um dos componentes existentes em um jogo.

No quinto capítulo, Técnicas de Criação, apresento algumas das técnicas que podem ser empregadas no processo de idealização e planejamento do jogo.

No sexto capítulo, Introdução ao Level Design, nossa principal preocupação será com os diversos aspectos necessários para o bom projeto de um cenário, fundamental para uma boa compreensão acerca de Level Design.

No sétimo capítulo, A Interface Jogo-Jogador, o nosso objeto de estudo é a Interação Humano-Computador aplicada a jogos, o que nos levará a uma outra especialidade: o Game Interface Design.

O oitavo capítulo, Formalizando e Informalizando o Aprendizado, possui três preocupações distintas: apresentar o “The 400 Project”, um ousado projeto para listar 400 regras de Game Design; discutir sobre a criatividade nas atividades de Game Design; e falar um pouco a respeito da importância do fator diversão nos jogos.

E por fim, no nono capítulo, Os Jogos e a Sociedade, remetemos à importância dos jogos na sociedade, qual pode ser o impacto cultural de seu uso e como os jogos podem nos ajudar.

Nosso apêndice apresenta dois exemplos de documentos que criei em alguns dos meus projetos e quatro estudos de caso de jogos que desenvolvi a fim de analisar alguns dos jogos mais comentados. Diversão garantida! Eu acho.

[O conteúdo aqui apresentado é parte do livro “Press Start – Uma Introdução ao Game Design”, que faz parte do nosso curso de Introdução ao Game Design]

Share and Enjoy

  • Facebook
  • Twitter
  • Delicious
  • LinkedIn
  • StumbleUpon
  • Add to favorites
  • Email
  • RSS