Pdjzine 03

PDJzine – Revista Eletrônica de Distribuição Livre da Programadores e Desenvolvedores de Jogos
Quem fez a PDJzine #3

(Nomes são citados em ordem alfabética)
Membro Anderson Marcondes

Home Page http://www.pdj.com.br
Participação Contribuinte
Membro André Kishimoto

Home Page http://www.tupinihon.com
E-mail kishimoto@tupinihon.com
Participação Escritor
Membro Breno (gammer)

Membro Bruno Schifer (schifers)

Membro Christiano Lima Santos

Home Page http://www.o2games.com.br
E-mail christianolimasantos@yahoo.com.br
Participação Escritor, Organizador e Editor
Membro Jean Freitas (LoneWolf)

Membro Paulo Andrade

Home Page http://www.cgmax.com.br
Membro Rubens Garcia (linuxboy)

Membro Thiago Marques Martinez (W_Snipes)

Palavras do Editor
Isto é realmente bom. BOM??? Bom é pouco: é excelente! Deixemme explicar os motivos de minha
alegria...
Em primeiro lugar, a GPC06 foi um sucesso! A primeira GPC (em 2005, quando ainda nem mesmo
tinha esse nome oficialmente), tivera somente a participação de dois jogos, nesta edição contamos com quatro
categorias, cada uma com pelo menos dois competidores e totalizando mais de vinte jogos inscritos! É
realmente uma grande satisfação trazer nesta revista uma apresentação dos jogos competidores.
Em segundo lugar, a comunidade PDJ está reacendendo mais uma vez: novas discussões, novos
membros, novas idéias... Isso realmente ajuda-nos a novamente ter esperança e lutar por uma PDJ como
realmente queremos: um grande portal onde aspirantes, desenvolvedores independentes e empresas
desenvolvedoras de todos os portes podem se encontrar, discutir e procurar ou oferecer trabalhos e projetos.
E em último lugar, mas não menos importante, a revista PDJzine alcançou a terceira edição. O que
há de importante nisso? Eu realmente estava com medo de que, assim como a JogosPro, uma revista sobre
desenvolvimento de jogos gratuita de excelente qualidade e que veio bem antes da PDJzine, não
alcançássemos a publicação da terceira edição. Bem... Conseguimos.
Conseguimos e com esta edição fechamos o primeiro ano de PDJzine. Correção! Haverá uma edição
especial com o resultado da GPC06 que encerrará o primeiro ano de PDJzine!
Geralmente eu falo aqui um pouco sobre o que há na revista, mas, como sempre, há muita coisa boa
e fico sem saber por onde começar. Estamos falando de tutoriais da área de modelagem 3D, inteligência
artificial, programação em geral e entrevistas com pessoas que entendem realmente do assunto, além de
apresentação de trabalhos de meu atual discípulo, LoneWolf.
E então, o que estamos esperando? Vamos virar logo esta página e ver o que a PDJzine #3 nos
reserva!
Christiano Lima Santos

Editor
Sumário
Hora da Aula
Blender – Textura UV Básica 6
Blender – Interação com LogicBricks 10
Blender – Sensores de Colisão 15
Tutorial de SDL – Simple DirectMedia Layer – Parte I 20
API FMOD 30
Position Paper da Obra: The Art of Computer Game Design (de Chris Crawford) 36
Máquinas de Estados Finitos (FSM’s) 42
Guia Básico para o Desenvolvimento de Jogos 49
Esta seção da revista traz tutoriais, artigos e várias matérias sobre o mundo do
desenvolvimento de jogos.
Esta é a nossa sala de aula, tome um lugar e preste bastante atenção, para que o aprendizado
seja realmente válido!
E Com Vocês...
PDJer Destaque 57
Entrevista com Jon Shiring 63
Interview with Jon Shiring 70
Entrevistas com diversas pessoas da indústria dos jogos, contando com entrevistados
nacionais e internacionais.
EspaçoArte
Entrevista Low-Poly 77
Showcase, entrevistas e tutoriais do mundo da arte, modelagem e animação 3D.
Tome Nota
À Caça das Oportunidades – Cursos na Área de Jogos 80
Fique atento e não deixe passar as oportunidades que surgem nas empresas, universidades,
escolas e na Internet seguindo as dicas que nossos repórteres de plantão sempre buscam
trazer a você!
À Toda Prova
Game PDJ Contest 2006 (GPC06) 83
Esta seção se encarrega de trazer para você em primeira mão todas as notícias a respeito de
competições de desenvolvimento de jogos ou assuntos correlacionados promovidas dentro e
fora de nossa comunidade.
Fim da História
Uma Salva de Palmas Antes de Fechar as Cortinas 104
Uma última palavra do editor e organizador da PDJzine antes de encerrar este trabalho e
partir para a busca do próximo.
HORA DA AULA
Blender – Textura UV básica
Autor: André Kishimoto
1) Em primeiro lugar, divida a interface do Blender em duas visões (Figura 1).
Figura 1: Interface dividida em duas visões.
2) Em uma das janelas 3D, modifique o tipo de janela para UV/Image Editor (Figura 2).
Figura 2: Janela UV/Image Editor na direita.
3) Vá à janela 3D (na Figura 2, a janela à esquerda), localize o botão Mode (que provavelmente deve
estar escrito “Object Mode”) e clique nele (Figura 3).
HORA DA AULA
Figura 3: Botão Mode.
4) Escolha a opção UV Face Select. Note que o objeto selecionado na janela 3D mudou para rosa
com pontilhados no seu contorno. O retângulo cinza escuro da janela UV/Image Editor também, passando
para a cor azul com pontilhados em sua volta (Figura 4). Isso indica que agora estamos trabalhando com
seleção de faces para mapeamento de texturas do tipo UV.
Figura 4: Modo UV Face Select.
5) Você pode selecionar todas as faces ou apenas algumas, como mostra a Figura 5.
Figura 5: Todas as faces de um cubo estão selecionadas (esq.); apenas uma face selecionada (dir.).
6) Por enquanto, deixe todas as faces selecionadas (apertando a tecla de atalho A). Vá à janela
UV/Image Editor e escolha a opção Image | Open... no seu header. Uma janela para escolher o arquivo de
textura será aberta em cima da janela UV/Image Editor (Figura 6).
HORA DA AULA
Figura 6: Escolha o arquivo de textura.
7) Escolha a textura que deseja utilizar. No exemplo desse tutorial, a textura selecionada foi a Figura
3 desse tutorial. A textura selecionada é carregada na janela UV/Image Editor e automaticamente associada às
faces do objeto (Figura 7).
Figura 7: Textura carregada.
8) Caso não esteja vendo a textura aplicada nas faces do objeto, mude o tipo de exibição (botão
Viewport Shading) para Textured. O resultado é visto na Figura 8.
HORA DA AULA
Figura 8: Textura mapeada nas faces do objeto.
9) A Figura 9 demonstra uma outra visualização do mapeamento de textura depois de realizado os

oito passos anteriores.
Figura 9: Outra visualização do mapeamento de textura no Blender.

HORA DA AULA
Blender – Interação com LogicBricks
1) O Blender possui uma seção onde podemos incluir interatividade, ou seja, o usuário ou o próprio
Blender pode executar algumas ações de acordo com o que for planejado, sem que seja algo totalmente linear
(como uma animação). Para incluir interação no seu projeto, localize o contexto Logic (botão de atalho F4) na
janela de botões (o primeiro botão no conjunto de botões de contexto localizado no header). Veja a Figura 1.
Figura 1: Contexto Logic (em destaque).
2) Ao selecionar o contexto Logic, o Blender nos mostra a seguinte interface na janela de botões
(Figura 2):
Figura 2: Interface da seção de interação do Blender.
3) É nessa seção que configuramos a lógica existente nas interações do Blender. Note que existem
três colunas nessa seção (mais à direita da interface), nomeadas Sensors, Controllers e Actuators.
→ Os sensores (Sensors) atuam como sensores reais, podendo detectar colisões, simular sentidos como
tato, visão e noção de proximidade.
→ Os controladores (Controllers) atuam como o cérebro da interatividade (lógica) presente no seu
projeto, através de simples decisões, expressões simples ou scripts Python mais complexos que
podem implementar inteligência artificial, por exemplo.
→ Os atuadores (Actuators) respondem às informações dos sensores. Eles podem ser comparados com
os músculos ou glândulas de um ser vivo.
4) Como um exemplo simples, vamos configurar a interação de um cubo (nomeado Cube) de tal
forma que o usuário consiga movimentá-lo nos eixos x e y através das setas direcionais do teclado.
5) O primeiro passo para começar o exemplo é adicionar um sensor, um controlador e um atuador.

Basta clicar no botão Add ao lado do botão que contém o nome do objeto selecionado. Caso não tenha
encontrado tais botões, localize-os pela Figura 3 (nessa figura, o sensor, controlador e atuador já foram
adicionados).
HORA DA AULA
Figura 3: Botões (em destaque) para adicionar sensores, controladores e atuadores.
6) Leve o cursor ao sensor que foi adicionado e clique na seta ao lado do botão escrito Always (tal
botão define o tipo do sensor). Selecione o tipo Keyboard, como indicado na Figura 4.
Figura 4: Selecionando o sensor do tipo Keyboard.
7) Quando você selecionar o sensor do tipo Keyboard, note que o Blender muda as opções para o
sensor (Figura 5).
Figura 5: Opções para o sensor Keyboard.
8) Clique no botão ao lado da palavra Key. O Blender pede para você pressionar a tecla que deseja
utilizar na interação (note a mensagem “Press a key” na Figura 6).
Figura 6: Definindo a tecla a ser usada na interação.
9) Pressione a seta direcional esquerda nesse momento. Veja que o Blender reconhece a tecla e a
define (Leftarrow) na opção Key do sensor (Figura 7).
HORA DA AULA
Figura 7: Seta direcional esquerda foi definida no sensor.
10) A parte do sensor já está configurada. No entanto, vamos renomear o sensor, de modo que fique
mais fácil para identificá-lo posteriormente. Para renomear um sensor, basta clicar no botão ao lado do seu
tipo e digitar o novo nome do sensor. A Figura 8 mostra o sensor renomeado para SetaEsq (em destaque).
Nota: não podemos usar o mesmo nome para mais de um sensor e nem usar caracteres especiais.
Figura 8: Renomeando um sensor (em destaque).
11) Vamos agora definir qual será a resposta do atuador em relação à ativação do sensor SetaEsq.
Para isso, devemos conectar a saída do sensor com a entrada do controlador (Figura 9). A conexão é feita
clicando na bolinha da saída do sensor e arrastando a linha que surge até a bolinha da entrada do controlador.
Figura 9: Conectando o sensor ao controlador (em destaque).
12) Em seguida, ligamos a saída do controlador com a entrada do atuador, da mesma maneira que
fizemos com o sensor e controlador no passo 11.
Nota: sensores, controladores e atuadores são blocos de lógica do Blender, também chamados de
LogicBricks.
13) No atuador, deixamos seu tipo como Motion, indicando que a resposta do atuador será algum
movimento no objeto. Como queremos que o objeto se desloque no eixo x negativo (ou seja, ele vai para
esquerda), inserimos o valor –0.30 na primeira coluna da linha dLoc, como mostra a Figura 10.
HORA DA AULA
Figura 10: Resposta do atuador em relação ao sensor SetaEsq.
14) As colunas do atuador do tipo Motion referem-se aos eixos x, y e z (da esquerda para direita),
conforme a Figura 11. Force e Torque são usados quando o objeto é definido como corpo dinâmico; dLoc é a
translação (delta location); dRot é a rotação (delta rotation); linV e angV são as velocidades linear e angular
do objeto, respectivamente.
Figura 11: Colunas x, y e z do atuador Motion.
15) Caso a sua configuração tenha ficado igual à Figura 12 (pelo menos as ligações entre os
LogicBricks e os valores definidos no sensor e no atuador), o objeto que contém essa lógica está pronto para
ser controlado pelo usuário (mas apenas com a seta direcional esquerda).
Figura 12: Resultado final dos passos anteriores.
16) Agora, realize os mesmos passos (5 ao 14) para as setas direcionais direita, cima e baixo. Sua
configuração final deve conter quatro sensores, quatro controladores e quatro atuadores, como demonstrado
na Figura 13.
Figura 13: As quatro setas direcionais configuradas para o usuário interagir com o cubo.
HORA DA AULA
17) Agora que definimos todos os LogicBricks para o usuário movimentar o cubo com as setas
direcionais, resta saber o seguinte: como ativar a interatividade no Blender? Para testarmos e executarmos a
interatividade basta irmos ao menu Game | Start Game (veja a Figura 14) ou posicionarmos o cursor do
mouse na janela 3D em que queremos executar a interação e pressionar a tecla de atalho P. Da maneira que a
interação do cubo foi configurada, devemos estar na visão Top para chegar ao resultado esperado (a visão da
janela 3D influencia no resultado final).
Figura 14: Iniciando a interação do Blender.
18) Após iniciar a interação do Blender, experimente pressionar as setas direcionais para ver os
movimentos do cubo. Para parar a interação, pressione a tecla ESC.
19) Como não é viável explicar os demais sensores, controladores e atuadores nesse tutorial, você
tem disponível um pdf “Suplementar – LogicBricks” que contém breve explicações sobre para que e como
funciona cada LogicBrick.
HORA DA AULA
Blender – Sensores de colisão
Nota: este tutorial cobre os seguintes sensores: touch, collision e near.
1) A partir do tutorial “Interação com LogicBricks”, adicione quatro novos cubos no cenário, de tal
forma que o cenário fique parecido com a Figura 1. Alguns cubos estão com cores diferentes porque foram
associados materiais à eles (veremos nesse tutorial como usar materiais para interação).
Figura 1: Cenário a ser usado nesse tutorial (User view).
2) Repare, pela Figura 2, que o cubo que contém interação (que está selecionado) está posicionado
um pouco mais acima que os cubos verde e vermelho (mais precisamente, seu deslocamento no eixo z é de 5
unidades). Esse posicionamento foi feito para aplicarmos o efeito da gravidade e colisões ao objeto, algo que
o Blender já faz automático quando definimos que o objeto é um corpo dinâmico (assunto dos próximos
passos).
HORA DA AULA
Figura 2: Cubo posicionado no eixo z = 5.00.

3) Com o cubo interativo selecionado, vá ao contexto Logic do Blender. Repare no botão Actor
(Figura 3). Deixe esse botão ativado, clicando nele.
Figura 3: Botão Actor.
4) Ao ativar o botão, o Blender exibe outros dois botões, Ghost e Dynamic (Figura 4). Um objeto
definido como Ghost não sofre colisões (como um fantasma), embora possa sofrer efeitos físicos (como
gravidade), quando também é definido como Dynamic.
Figura 4: Novos botões.
5) Ative o botão Dynamic. Novamente, novas opções surgem para configurar o comportamento do
objeto (Figura 5). Vamos deixá-los com os valores-padrão. O que acabamos de fazer do passo 3 até aqui foi
dizer ao Blender que o movimento do nosso cubo sofrerá as leis da física.
Figura 5: Configuração final para o cubo.
6) Antes de continuarmos com o tutorial, experimente executar a interação do Blender e veja o que
acontece com o cubo (ele cairá até atingir o cubo vermelho). Dependendo de como os objetos estão
configurados, o cubo pode ficar quicando sem parar ou pode nem quicar no momento em que atingir o cubo
vermelho (o “chão”).
7) No caso do objeto ficar quicando sem parar, é bem provável que nenhum dos dois objetos que
colidiram tenham materiais associados. Para configurar essa parte sobre um objeto atingir outro e quicar,
devemos modificar uma propriedade no material associado ao objeto. Para associar um novo material a um
objeto, vá ao contexto Shading e Material Buttons, em destaques na Figura 6.
HORA DA AULA
Figura 6: Configuração de materiais.
8) Nessa seção do Blender, clique no botão Add New (Figura 7) para criar um novo material. Esse
novo material é automaticamente associado ao objeto selecionado.
Figura 7: Criando um novo material.
9) Para modificar a cor do material, altere os valores definidos nos campos R, G e B (em destaque na
Figura 8), desde que você trabalhe no modo RGB (botão RGB em destaque). Caso trabalhe no modo HSV,
você deve modificar os valores H, S e V, que aparecerão no lugar dos campos R, G e B.
Figura 8: Mudando a cor do material.
10) Sobre a parte dos objetos quicarem: devemos mudar o coeficiente de restituição do material
(elasticidade). Para encontrar essa propriedade, ative o botão DYN (Figura 9, em destaque) e modifique o
valor do campo Restitut. Restitut igual a 1.0 indica que o material não perde força durante uma colisão e,
portanto, o objeto com esse material sempre ficará quicando. Restitut igual a 0.0 indica que o objeto com esse
material perde toda a força durante a colisão. Valores entre 0.0 e 1.0 fazem o objeto perder força
gradativamente.
Observação: Quando dois objetos colidem, o Blender usa o menor valor dos materiais dos objetos.
Ou seja, caso um objeto tenha Restitut=0.2 e outro objeto tenha Restitut=1.0, o Blender usa o valor 0.2 para
Restitut.
Figura 9: Coeficiente de restituição (elasticidade).

HORA DA AULA
11) Associe novos materiais aos objetos da cena, modifique seus coeficientes de restituição e veja os
resultados.
12) Vamos agora inserir os sensores de colisão e verificar o funcionamento de cada um. Como o
objetivo deste tutorial é ensinar o uso dos sensores touch, collision e near, adicione cada um deles no cubo
interativo. Aproveite para adicionar também três novos controladores (Figura 10).
Figura 10: Sensores de colisão adicionados.
13) Comecemos com o sensor Near. Nesse sensor, podemos definir com quais objetos o cubo
interativo irá ativar o sensor quando chegar perto. Isso pode ser feito através do campo Property – quando
vazio, o sensor é ativado com qualquer objeto; quando inserimos um valor, o sensor só é ativado com objetos
que possuam a propriedade (o valor que inserimos). Vamos definir o valor obstaculo e Dist=1.60 e
Reset=5.00 (Figura 11).
Figura 11: Configuração do sensor Near.
14) O atuador para o sensor Near será do tipo Game, Quit this game. Assim, quando o cubo estiver
próximo do objeto com a propriedade obstaculo, a execução da interatividade será finalizada.
15) O objeto que contém a propriedade obstaculo nesse tutorial é o outro cubo. Para adicionar
propriedades em um objeto, selecione o mesmo, vá à seção dos LogicBricks e localize o botão ADD property
(em destaque na Figura 12).
Figura 12: Botão para adicionar propriedades em um objeto (em destaque).
16) Clique nesse botão para adicionar uma nova propriedade. Renomeie a propriedade para
obstaculo, no campo Name. Existem cinco tipos de propriedades no Blender, como você pode ver na Figura
13. Como a propriedade, pelo menos para esse tutorial, só servirá para o sensor Near saber qual objeto contém
a propriedade obstaculo, podemos definir qualquer tipo de propriedade (no exemplo, será Bool).
HORA DA AULA
Figura 13: Propriedade obstaculo adicionada ao segundo cubo.
17) Agora, ative a interatividade do Blender e aproxime o cubo interativo perto do cubo em que
acabamos de adicionar a propriedade obstaculo. Quando você chegar perto dele, o Blender finalizará a
interatividade.
18) Vamos passar agora para o sensor Collision. Esse sensor é ativado quando o objeto colide com
outros objetos da cena. Caso você queira que o sensor responda a objetos específicos, é preciso que você
defina a propriedade que o objeto contém, assim como no sensor Near. No entanto, o sensor Collision pode
ser ativado com objetos que possuam um determinado material. Para isso, deixe o botão M/P pressionado para
alternar entre os campos Property e Material. No campo Material, digite o nome do material que você quer
que o sensor ative quando colidir. Neste tutorial, o material é o MatParede (associado ao cubo amarelo da
Figura 1). Quando o cubo interativo colidir com a parede, o mesmo será deslocado 0.10 unidades no eixo y.
Veja a configuração final do sensor na Figura 14.
Figura 14: Configuração do sensor Collision.
19) Execute a interatividade do Blender e aproxime o cubo interativo perto da parede. Assim que
ambos colidirem, o cubo se deslocará no eixo y.
20) Por último, vamos configurar o sensor Touch. Esse sensor pode ser ativado com qualquer objeto
da cena ou com algum específico, caso um material seja definido no seu campo MA. No tutorial, o sensor
Touch responderá ao toque com objetos que contenham material do tipo MatChao2 (somente o cubo verde).
Quando o cubo interativo tocar o chão verde, ele começará a rotacionar 0.10 unidades no eixo z. A
configuração desse sensor pode ser visto na Figura 15.
Figura 15: Configuração do sensor Touch.
21) Novamente, execute a interatividade do Blender para verificar os resultados com esse novo
sensor.
22) Caso algo tenha dado errado, verifique novamente os passos e veja se não esqueceu de nenhuma
configuração. Lembre-se de ativar o botão Actor para todos os objetos do cenário.
HORA DA AULA
Tutorial de SDL – Simple Directmedia Layer – Parte I
Autor: Bruno Schifer (schifers)
Quem nunca jogou um jogo de computador ou de vídeo game? E desses que jogaram quem nunca
desejou fazer um jogo?
Quando entramos no mundo dos jogos eletrônicos, passamos para uma outra realidade. Podemos ser
quem nós quisermos, desde um simples encanador que viaja pelo mundo lutando contra as forças do mal, até
um deus que controla suas criações da forma que ele desejar. As possibilidades são enormes e rapidamente as
idéias afloram na nossa mente. É geralmente nessa hora que surge a vontade de aprender e de fazer acontecer.
Passamos a nos perguntar o que é preciso para se fazer um jogo. As respostas começam a aparecer quando
nos deparamos com páginas e páginas na Internet falando sobre este assunto. Foi pensando nisso que criei
este tutorial. Para que essa necessidade de aprender a criar jogos eletrônicos seja suprida e para que essas
pobres mentes inquietas tenham a capacidade de exercitar sua criatividade nesse maravilhoso mundo dos
jogos.
Objetivo
Agora, já iniciando o tutorial, nosso objetivo é mostrar o que precisamos para desenvolver um jogo
em SDL do início até o fim. Para um primeiro contato, precisamos de ferramentas simples e de fácil acesso,
foi por isso que escolhi a SDL e o Dev-C++. Elas são ferramentas grátis e facilmente encontradas na Internet.
Devemos também nos basear em um estilo de jogo fácil, pois o que queremos aprender, inicialmente,
é a fundamentação básica da programação de jogos. Estaremos trabalhando um jogo no estilo “arcade”. Este
estilo é, talvez, o mais básico e antigo que existe, pois os jogos mais velhos não possuíam muitos recursos por
limitações impostas pelo próprio hardware das máquinas aonde eles rodavam.
Características do “arcade”:
- Cenário estático;
- Uma única fase ou número limitado de fases;
- Dificuldade fixa ou de pouca variabilidade;
- Quantidade de sprites (imagem ou animação que se movimenta em um cenário de um jogo)
limitada.
Iremos, então, levar em conta essas características na hora de programarmos o jogo. O jogo que
estaremos criando chama-se Moskas. Trata-se de um rapaz que vive treinando para se tornar um campeão na
arte de catar moscas. Ele anda com dois pauzinhos pelos lixões de sua cidade tentando pegar o maior número
de moscas que ele puder. É um jogo bobo a princípio, mas muito divertido de se fazer.
Voltando a parte técnica, vamos ver agora onde pegar as ferramentas e como instalá-las.
Instalação
Dev-C++
HORA DA AULA
Como já foi dito, o projeto será todo desenvolvido em ferramentas de fácil acesso, ou seja,
ferramentas grátis. Por essa razão, decidi adotar o Dev-C++ como compilador do projeto. Para instalar o Dev-
C++, a primeira coisa a se fazer é buscar os arquivos de instalação da ferramenta no seguinte endereço:
http://prdownloads.sourceforge.net/dev-cpp/devcpp-4.9.9.2_setup.exe.
Execute o arquivo na sua máquina para instalar o programa. Se você tiver alguma dúvida, o melhor
lugar para ir é na página da empresa criadora do software: http://www.bloodshed.net, ou simplesmente entre
em contato comigo.
SDL
Depois de instalar o compilador, você precisará de uma biblioteca gráfica para desenvolver os jogos.
Estarei utilizando no tutorial a biblioteca SDL (Simple Directmedia Layer). Essa biblioteca foi inicialmente
criada para o Linux e posteriormente foi portada para o Windows. Assim como o Dev-C++, a biblioteca SDL
é grátis e de fácil acesso. Para pegar os arquivos da SDL vá aos seguintes endereços:
http://www.libsdl.org/release/SDL-1.2.11.zip (código fonte)
http://www.libsdl.org/release/SDL-1.2.11-win32.zip (runtime)
http://www.libsdl.org/release/SDL-devel-1.2.11-mingw32.tar.gz (biblioteca de desenvolvimento).
De posse destes arquivos, vamos começar a instalar a biblioteca.
Configuração
Para usar a SDL no Dev-C++ você precisará configurar o compilador para reconhecer os comandos
da biblioteca. Ao abrir o Dev-C++, você encontrará a seguinte tela:
Agora, você deverá buscar na barra de menu a opção “Tools” e clicar na opção “Compiler Options”.
Após fazer isso, a seguinte tela irá aparecer:
HORA DA AULA
Selecione a pasta “Directories” e logo em seguida você poderá ver quatro opções de pasta logo
abaixo: “Binaries”, “Libraries”, “C Includes” e “C++ Includes”. Selecione a opção “Libraries”:
Como você pode ver, eu selecionei a opção “Libraries” e adicionei o diretório lib da SDL que no
meu caso é “c:\SDL-1.2.11\lib”. Para isso, eu cliquei no botão de seleção de diretório, logo acima do botão
“Delete Invalid” e busquei o diretório nas pastas do meu computador. Logo em seguida, o botão “Add” ficará
disponível. Clique nele e o diretório irá fazer parte da lista de bibliotecas do Dev-C++.
HORA DA AULA
Logo em seguida, selecione a pasta “C++ Includes” ainda na opção “Tools > Compiler Options >
Directories”. Faça o mesmo procedimento que você fez no passo anterior, só que agora você irá acrescentar o
diretório include da SDL:
O próximo passo será criar um projeto para trabalhar com a SDL. Feche a janela “Compiler Options”
e agora vá para a opção “File > New > Project”. Ao clicar nessa opção, a seguinte tela irá aparecer:
HORA DA AULA
Preencha o nome do projeto “Basico1” e selecione a opção “Windows Application”. Pressione OK e

a tela para escolher o local aonde será gravado o projeto irá aparecer. Escolha o melhor local para você e siga
em frente.
A seguinte tela irá aparecer para você:
Selecione o botão de “+” ao lado do seu projeto “Basico1” e você poderá ver os arquivos que estão
no seu projeto. Nesse caso, o compilador gera um arquivo padrão para você chamado de “main.cpp”. Nós
iremos apagar esse arquivo. Clique com o botão direito em cima do arquivo e selecione “Remove File”. Após
remover o arquivo, selecione a opção “Save All” na barra de ferramentas ou na opção “File > Save All” na
barra de menu.
A seguir, iremos colocar alguns parâmetros para o “Linker” do compilador. Sem essas opções, o
compilador não conseguirá gerar o executável dos programas em SDL. Selecione a opção “Project > Project
Options” e vá para a pasta “Parameters”:
HORA DA AULA
Como você pode observar, existem alguns parâmetros na caixa de texto “Linker”. Copie esse texto
entre aspas e cole para dentro daquela caixa de texto:
“-lmingw32 -lSDLmain -lSDL -mwindows”
Pronto, você agora tem um projeto no Dev-C++ preparado para executar os comandos da SDL. O
próximo passo é gerar nosso primeiro programa. Vamos em frente!
Carregando a SDL
Vamos começar a fazer nosso primeiro programa usando a SDL. Nesta parte do tutorial, estarei
mostrando os comandos necessários para gerar uma janela usando a SDL.
As funções e estruturas da SDL que estarei usando são:
SDL_Event
SDL_Event é uma union (estrutura em C que especifica um conjunto de variáveis e, opcionalmente,

um nome para esse conjunto). Ela é a estrutura principal no gerenciamento de eventos da SDL, sendo talvez a
estrutura mais importante da SDL após a SDL_Surface. SDL_Event é a união de todas as estruturas de evento
usadas na SDL, para usá-la você só precisa saber qual membro dessa união se relaciona com qual tipo de
evento.
SDL_Init
HORA DA AULA
Inicializa a SDL. Ela deve ser chamada antes de qualquer outra função da SDL. O parâmetro dessa
função é um conjunto de flags (referência a um ou mais bits que são usados para armazenar valores binários
ou códigos que possuem um significado relevante) que especifica qual parte da SDL será inicializada.
SDL_WM_SetCaption
Especifica o título da janela e o nome do ícone do programa.
SDL_Surface
Essa é a estrutura mais importante da SDL. A SDL_Surface é uma área em memória aonde
estaremos colocando imagens, ou seja, é uma memória que permite que desenhemos nela.
SDL_PollEvent
Faz a apuração dos eventos que estão pendentes. Ela preenche um evento do tipo SDL_Event e
retorna 0 ou 1 caso existam eventos na fila.
SDL_PushEvent
Posiciona um evento na fila de eventos. Possui dois caminhos, pois pode tanto buscar um evento na
fila ou posicionar um evento. O parâmetro da função é um ponteiro para uma estrutura SDL_Event.
SDL_FillRect
Preenche o retângulo passado como parâmetro com uma determinada cor na SDL_Surface passada
também como parâmetro.
SDL_UpdateRect
Garante com que a área passada como parâmetro seja atualizada na SDL_Surface em questão.
SDL_FreeSurface
Libera os recursos utilizados por uma SDL_Surface.
SDL_Quit
Libera os recursos utilizados pela biblioteca SDL.
A seguir, temos o extrato do código que estaremos trabalhando nessa parte do nosso tutorial.
Main.cpp:
#include "sdl.h"
int main( int argc, char* argv[] )
{
SDL_Event event;
SDL_Init( SDL_INIT_VIDEO|SDL_INIT_AUDIO );
SDL_WM_SetCaption("Basico1", 0);
SDL_Surface* m_pScreen = SDL_SetVideoMode( 640, 480, 32, SDL_HWSURFACE|SDL_DOUBLEBUF );
while( 1 )
{
if( SDL_PollEvent( &event ) )
{
if( event.type == SDL_QUIT )
HORA DA AULA
break;
if( event.type == SDL_KEYDOWN )
{
if( event.key.keysym.sym == SDLK_ESCAPE || event.key.keysym.sym == SDLK_q )
{
SDL_Event quit;
quit.type = SDL_QUIT;
SDL_PushEvent( &quit );
}
}
}
SDL_FillRect( m_pScreen, NULL, SDL_MapRGB( m_pScreen->format, 0, 0, 0 ) );
SDL_UpdateRect( m_pScreen, 0, 0, 0, 0 );
}
SDL_FreeSurface(m_pScreen);
SDL_Quit();
}
A partir de agora, vamos ver o que cada um desses comandos está fazendo no nosso pequeno
programa.
#include "sdl.h"
Esse comando é uma diretiva para o nosso compilador e faz com que ele inclua em nosso código as
funções da SDL para que possamos usá-las.
int main( int argc, char* argv[] )
Essa linha é o ponto inicial de qualquer programa em SDL. Normalmente, seria também o ponto
inicial de um programa em C, porém, estamos trabalhando com a SDL.
SDL_Event event;
Aqui estamos instanciando a estrutura que guarda informações de eventos da SDL.
SDL_Init( SDL_INIT_VIDEO|SDL_INIT_AUDIO );
A função SDL_Init, como dito anteriormente, tem a função de inicializar a SDL. Nesse caso, ela está
sendo inicializada com os subsistemas de vídeo e de áudio.
SDL_WM_SetCaption("Basico1", 0);
Essa função especifica o título da janela e do ícone do programa. Estamos chamando o nosso
programa de “Basico1”.
SDL_Surface* m_pScreen = SDL_SetVideoMode( 640, 480, 32, SDL_HWSURFACE|SDL_DOUBLEBUF );
Agora, estamos instanciando a nossa estrutura SDL_Surface. A função SDL_SetVideoMode cria

essa estrutura SDL_Surface com os parâmetros passados para ela. Nesse caso, a superfície criada representará
a nossa tela. A tela possui, então, 640 pixels (menor unidade na tela do computador, representa um ponto de
luz colorido) de largura e 480 pixels de altura. Em seguida, definimos a quantidade de bits de cores por pixel,
ou seja, o “bpp”. O nosso “bpp” é 32. Por último passamos as flags de inicialização, indicando que estaremos
utilizando a memória da placa de vídeo (SDL_HWSURFACE) e estaremos utilizando o double buffering
(SDL_DOUBLEBUF – memória secundária para desenho na tela). Lembre-se que a placa de vídeo deve
possuir suporte a essas características da superfície.
while( 1 )
{
// loop principal
HORA DA AULA
Em seguida, entramos no loop principal do programa. O programa só será finalizado quando a SDL
receber um evento de saída, por isso o loop é representado por um while infinito (while(1)). O programa só
sairá desse ciclo quando encontrar o comando break.
if( SDL_PollEvent( &event ) )
Como foi dito anteriormente, a função SDL_PollEvent apura um evento e cria a referência para o
evento ocorrido. Nesse caso, a estrutura event sairá com os dados do último evento ocorrido na execução do
programa. O próximo passo será tratar os eventos.
if( event.type == SDL_QUIT )

break;
Um evento do tipo SDL_QUIT sinaliza que devemos sair da aplicação. Mais abaixo, ao tratarmos as
entradas feitas pelo teclado, estaremos criando um evento desse tipo para sairmos da execução da aplicação.
Se essa condição for verdadeira, encontramos o comando break que fará com que deixemos o loop principal
do jogo.
if( event.type == SDL_KEYDOWN )
Um evento do tipo SDL_KEYDOWN sinaliza que o usuário pressionou uma tecla do teclado. Iremos
logo em seguida, tratar as entradas do teclado.
if( event.key.keysym.sym == SDLK_ESCAPE || event.key.keysym.sym == SDLK_q )
Inicialmente, estaremos tratando o pressionamento da tecla “ESC” ou da tecla “q”. Ambas as teclas
irão gerar um evento de saída do loop principal. Para entender melhor o funcionamento da estrutura
SDL_Event da SDL, sugiro que você busque a documentação de referência na própria página da SDL ou
entre em contato comigo, pois para não complicar o objetivo do tutorial, estarei me abstendo de explicar ela
por inteiro.
SDL_Event quit;
quit.type = SDL_QUIT;
SDL_PushEvent( &quit );
As 3 linhas de código acima geram um evento do tipo quit. Na primeira linha eu instancio uma
estrutura SDL_Event. Na segunda linha, eu defino que a propriedade “type” deste evento é do tipo “quit”. Por
último, eu coloco o evento na fila de eventos da SDL para ser tratado quando for o caso (ele será tratado
quando a SDL_PollEvent retornar este evento em questão).
SDL_FillRect( m_pScreen, NULL, SDL_MapRGB( m_pScreen->format, 0, 0, 0 ) );
Ainda dentro do loop, eu limpo a superfície preenchendo toda ela com a cor preta. A função
SDL_FillRect preenche uma região retangular com uma determinada cor. A função SDL_MapRGB mapeia
uma determinada cor sob a perspectiva de um determinado formato. No caso, estamos passando o formato da
nossa tela e escolhendo a cor preta para preenchimento.
SDL_UpdateRect( m_pScreen, 0, 0, 0, 0 );
Como foi dito anteriormente, essa função garante com que minha estrutura SDL_Surface chamada de
m_pScreen seja atualizada toda vez que houver a execução de um frame.
SDL_FreeSurface(m_pScreen);
HORA DA AULA
SDL_Quit();
Por último, já fora do loop, eu libero a memória da estrutura m_pScreen e libero a memória usada
pela SDL com o comando SDL_Quit.
Conclusão
Com isso terminamos essa primeira parte do nosso tutorial. Espero que vocês tenham gostado. À
medida que formos trabalhando com esse jogo as coisas deverão se tornar mais complexas e a necessidade de
estar em sintonia com o que foi exposto aqui será muito importante. Tente baixar as ferramentas necessárias e
tente compilar o código apresentado. Além disso, tente entender o código também.
Essa parte não apresenta um resultado visual muito atraente, pois na verdade ainda trata-se de uma
tela preta, mas posteriormente estaremos ampliando nossa capacidade e teremos um jogo completo com várias
funcionalidades.
Lembre-se ainda que o importante aqui é criar os fundamentos básicos da programação de jogos na
cabeça de vocês, portanto não esperem encontrar um super jogo ao final do nosso ciclo de programação. Por
último, agradeço a atenção e o tempo despendido para ler este tutorial. Espero nos encontrarmos de novo na
segunda parte! Obrigado a todos! Fui!
HORA DA AULA
API FMOD
Autor: Rubens Garcia (linuxboy)
Olá, pessoal, tudo bem com vocês? Espero que sim!
Bem nesse artigo vou falar sobre a API FMOD que trabalha com arquivos de áudio entre samples e
mods. Os samples são os arquivos de áudio populares e comuns (WAV, MP3, OGG e entre outros), os mods
são outros tipos de arquivos de áudio como o XM , S3M e muitos outros. O FMOD também é usado em
consoles modernos ( PS2, XBOX, Game Cube, PS3, XBOX 360, Wii e PSP). É possível usar este API em
Linux(32bits/64bits) , Mac(OS8/9/10/x86) e Windows(todas versões 32 bits/64bits/CE) e programar em
C/C++, VB e Delphi.
Vamos fazer o download do FMOD
Windows (32/64 bits)

http://www.fmod.org/files/fmodapi375win.zip
Linux(32/64bits)
http://www.fmod.org/files/fmodapi375linux.tar.gz
Vou explicar como instalar o FMOD no MSVC e no GCC
Descompacte o arquivo entre na pasta criada, logo após entre na pasta API e depois na pasta include
copie todo o conteúdo da pasta para a pasta include de seu compilador .
Novamente entre na pasta API do FMOD e entre agora na pasta lib copie todo seu conteúdo para a
pasta lib de seu compilador.
Bom abaixo segue dois códigos de C++ usando as API allegro e SDL em conjunto com o FMOD
MSVC
Criando um projeto
File/New/Projects/Windows 32 console aplication(no caso do allegro)

Se for SDL
File/New/Projects/Windows 32 windows aplication
De um nome ao projeto e depois adicione um C++ source files em
Files/New/Files/ C++ source files
Agora com o projeto criado vamos configura-lo
No allegro vamos fazer assim
Project/Settings/Link/object&librariesmodule
Você vai adicionar estas duas libs
alleg.lib e fmodvc.lib e de ok
HORA DA AULA
No SDL vamos fazer assim
Project/Settings/ C/C++
Em category mude o valor para code generation

Em Use run time library coloque Multithreaded DLL e clique em ok
Project/Settings/Link/object&librariesmodule
Adicionar estas duas libs
SDL.lib SDLmain.lib e clique em ok
No GCC
Para compilar SDL+FMOD basta fazer

gcc -o arquivo_destino arquivo_fonte.c –lSDL - lfmod-versaodofmod
Para compilar ALLEGRO+FMOD use

gcc allegro-example.c -o example `allegro-config --libs` - lfmod-
versaodofmod
Finalmente os códigos exemplos ambos feito no MSVC
CÓDIGO FONTE EM SDL
#include <SDL.h>
#include <fmod.h>
#include <fmod_errors.h>
#include <iostream.h>
int main( int argc, char* args[] )

{
SDL_Surface *tela = NULL; //ponteiro para tela
FSOUND_SAMPLE *samp1 = 0; //cria um ponteiro para armazenar o som em memória
if (FSOUND_GetVersion() < FMOD_VERSION) // verificação da versão do fmod caso a

versão do FSOUND for menor que a do FMOD retorna uma mensagem de erro
{
cout<< "Error : Você está usando uma DLL antiga em comparação a versão do
fmod"<<endl<<FMOD_VERSION<<endl;
return 1;
}
/*
Seleciona a saída de áudio
*/
HORA DA AULA
FSOUND_SetOutput(FSOUND_OUTPUT_DSOUND);
/*
Seleção do driver
*/
FSOUND_GetOutput(); // indentifica o tipo de saída

FSOUND_GetMixer(); // indentifica o mixer
FSOUND_SetDriver(0); // seta o driver de som que vai ser usado
if (SDL_Init(SDL_INIT_VIDEO) < 0){
// Caso não consiga inicializar o vídeo SDL, faça:
// Escreva na tela uma mensagem de erro
cout << "Erro ao inicializar vídeo SDL: " << SDL_GetError() << endl;
return false; // Retorne com valor falso
tela= SDL_SetVideoMode(800, 600, 16, SDL_SWSURFACE);
if (tela == NULL){
// Caso não consiga mudar a configuração do vídeo SDL, faça:
// Escreva na tela uma mensagem de erro
cout << "Erro ao mudar a configuração de vídeo SDL: "
<< SDL_GetError() << endl;
return false; // Retorne com valor falso
if (!FSOUND_Init(44100, 32, FSOUND_INIT_GLOBALFOCUS)) // se o valor do

FSOUND_Init for 0 execute o tratamento de erro
{
cout<<"Erro"<<endl<<FMOD_ErrorString(FSOUND_GetError());
return 1;
}
/*
Carregando o Sample
HORA DA AULA
*/
/* PCM,44,100 Hz, 32 Bit, Mono ou uma mp3 ou outros formatos suportados pelo
fmod*/
samp1 = FSOUND_Sample_Load(FSOUND_UNMANAGED, "Simple Plain - I'm
addicted to you.mp3", FSOUND_NORMAL | FSOUND_HW2D, 0, 0); /* hardware? why not, just to show
it can be done */
if (!samp1)
{
return 1;
}
// aqui fala qual maneira o sample ira tocar caso falhe execute o tratamento de erro
if(!FSOUND_Sample_SetMode(samp1, FSOUND_LOOP_OFF))// o loop normal
toca a musica continuamente até o programa fechar
{
return 1;
}
// aqui será tocado o sample ,caso falhe, execute o tratamento de erro
if(!FSOUND_PlaySound(FSOUND_FREE, samp1))
{
return 1;
}
SDL_Delay(240000); return true;
/*
limpando a memória e fechando o fmod
*/
FSOUND_Sample_Free(samp1); // limpa a memória utilizada pelo ponteiro do sample
FSOUND_Close(); // encerra a API FMOD
SDL_FreeSurface(tela);
return 0;
}
CÓDIGO FONTE EM ALLEGRO
//colocação das bibliotecas básicas e extras

#include <stdio.h> #include <stdlib.h>
#include <fmod.h>
#include <fmod_errors.h>
#include <allegro.h>
HORA DA AULA
#include <stdlib.h>
#include <winalleg.h>
int main(int argc, char *argv[])
{
allegro_init(); // inicia o allegro
set_color_depth(32); // inicia a tela com a profundidade de cor em 32 bits
int res = set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0); // detecta a placa de
vídeo e inicializa a tela com a dimensão de 640*480
FSOUND_SAMPLE *samp1 = 0; //cria um ponteiro para armazenar o som em memória
if (FSOUND_GetVersion() < FMOD_VERSION) // verificação da versão do fmod caso a versão

do FSOUND for menor que a do FMOD retorna uma mensagem de erro
{
printf("Error : You are using the wrong DLL version! You should be using FMOD %.02f\n",
FMOD_VERSION);
return 1;
}
/*
Seleciona a saída de áudio
*/
FSOUND_SetOutput(FSOUND_OUTPUT_DSOUND);
/*
Seleção do driver
*/
FSOUND_GetOutput(); // indentifica o tipo de saída

FSOUND_GetMixer(); // indentifica o mixer
FSOUND_SetDriver(0); // seta o driver de som que vai ser usado
/*
Inicializando o FMOD
*/
if (!FSOUND_Init(44100, 32, FSOUND_INIT_GLOBALFOCUS)) // se o valor do FSOUND_Init
for 0 execute o tratamento de erro
{
printf("Error!\n");
printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
return 1;
}
/*
Carregando o Sample
*/
/* PCM,44,100 Hz, 32 Bit, Mono ou uma mp3 ou outros formatos suportados pelo fmod*/
samp1 = FSOUND_Sample_Load(FSOUND_UNMANAGED, "01 - blink-182 - Anthem Part
Two.mp3", FSOUND_NORMAL | FSOUND_HW2D, 0, 0); /* hardware? why not, just to show it can be
done */
if (!samp1)
HORA DA AULA
HORA
{
printf("Error!\n");
return 1;
}
// aqui fala qual maneira o sample irá tocar caso falhe execute o tratamento de erro
if(!FSOUND_Sample_SetMode(samp1, FSOUND_LOOP_OFF))// o loop normal toca a música
continuamente até o programa fechar
{
printf("Error!\n");
}
// aqui será tocado o sample ,caso falhe, execute o tratamento de erro
if(!FSOUND_PlaySound(FSOUND_FREE, samp1))
{
printf("Error!\n");
}
Sleep(60000); // executa o programa durante 60 segundos
/*
limpando a memória e fechando o fmod
*/
FSOUND_Sample_Free(samp1); // limpa a memória utilizada pelo ponteiro do sample
FSOUND_Close(); // encerra a API FMOD
return 0;
}
END_OF_MAIN();
É isso galera até a próxima !!!!

HORA DA AULA
O trabalho a seguir trata-se de um position paper (resenha sobre obra acompanhada de um

posicionamento crítico do observador) escrito por Jean Freitas sob orientação de Christiano Lima Santos.
A leitura deste trabalho sob hipótese alguma substitui a leitura da obra original, bem como não
busca ser a última palavra sobre o assunto.
Position Paper da obra: The Art of Computer Game Design (de

Chris Crawford)
Autor: Jean Freitas (LoneWolf)
Sobre a Obra:
Este livro foi escrito originalmente pelo game designer (quem cria o projeto do jogo) Chris
Crawford, que aceitou sua publicação eletrônica para ajudar outras pessoas. A premissa central desse livro é
que os jogos de computador constituem uma nova e ainda fraca forma de arte que guarda uma grande
promessa para os Game Designers. Arte seria algo projetado para evocar emoções através da imaginação. Até
o momento, os jogos de computador não são uma forma de arte expressiva por ainda não estarem nas mãos
dos artistas.
Antes de entendermos os jogos e o projeto dos mesmos, devemos estabelecer uma
orientação fundamental. Jogos fazem parte da existência humana, mas mesmo assim existem duas barreiras
para o entendimento deles. Uma é o uso liberal dos termos dos jogos sem conhecimento prévio e a outra é a
falta de padrões.
Os jogos podem ser divididos em cinco modelos:
Os Board Games consistem em superfícies divididas em setores onde os jogadores usam um grupo
de peças móveis com alguma finalidade. Para isso usam análise da superfície jogável (tabuleiro).
Card Games utilizam cartas com 13 valores e 4 naipes, em que a preocupação principal do jogador é
a análise de combinações das cartas.
Nos Athletic Games a principal preocupação é o uso habilidoso do corpo. Não podemos confundir
esse tipo de jogo com as competições de atletismo. A diferença está na interação, em que os jogos possuem e
as competições, teoricamente, não.
Já nos Children’s Games a preocupação primária do jogador é o uso das habilidades sociais para
acender o papel fundamental do grupo na vida humana.
E por fim os Computer Games, em que o computador age como oponente e árbitro ao mesmo
tempo e também ordena os gráficos, na maioria deles. A área mais comum de Computer Games é a de skill
and action (“S&A”) game1, onde, de certa forma, todas as outras áreas estão incluídas.
Apesar da necessidade de separação desses tipos, eles possuem algumas características em comum.
Primeiro, a Representação é um ponto forte nesses jogos, onde o jogador usa sua imaginação para produzir
um jogo psicologicamente real. E é nesse ponto que os jogos diferem das simulações, pois representam um
fenômeno de forma simplificada e artística, tendo como princípio a clareza e como objetivo a atenção do
jogador. Já nas simulações tentam representar de forma precisa um fenômeno real. A Interação também é
bastante importante e permite que o jogador interaja com o mundo do jogo da forma que bem entender
criando sua própria história. Nesses jogos não há uma seqüência imutável de fatos como nas histórias
convencionais. Porém na interação dos Computer Games falta um elemento social, porque geralmente o
oponente é programado. O grau de interatividade fornece um indicador de jogabilidade. Outro ponto
importante aqui é o Conflito que nasce naturalmente de uma interação no jogo. Quando algum obstáculo
bloqueia a tentativa do jogador atingir um objetivo, o conflito é inevitável e fundamental. É possível incluir
elementos cooperativos no jogo, mas deve ter em algum momento o conflito. A Violência não é essencial nos
jogos, mas é muito comum nos mesmos, por ser a forma mais óbvia e natural de conflito. A Segurança é a
1
Tradução: jogo de habilidade e ação
HORA DA AULA
última característica fundamental. Esta nasce no conflito, pois o conflito implica perigo; perigo significa risco
de dano; dano é indesejável. Esses jogos são um caminho seguro para experimentar a realidade.
A motivação principal dos jogos é o aprendizado, mas existem outras motivações. Como por
exemplo a Imaginação/Exploração (onde o jogador usa sua imaginação para explorar de forma divertida o
mundo virtual), a Liberdade sem preocupação (cuja função é fornecer uma forma livre para usar a
imaginação sem se preocupar com as conseqüências), a Superação de Limites (que permite a demonstração
de coragem), a Socialização (entre os jogadores), o Exercício (seja mental, físico ou uma combinação de
ambos) e a Necessidade de reconhecimento (não somente existencial, mas de nossas personalidades).
Um jogo pode não ser divertido se seus fatores não satisfazem as motivações do jogador. Dois
fatores de divertimento são importantes: jogabilidade e prazer sensorial. Jogabilidade é um elemento de
grande importância no sucesso do jogo e vem da combinação de ritmo e raciocínio. O Prazer sensorial é
alcançado através de bons gráficos, cores, animações e sons bem desenvolvidos que ajudam no fortalecimento
da imaginação do jogador.
Cada pessoa possui um gosto diferente, assim torna-se necessário estudar as características
da personalidade de cada pessoa e de cada jogo para atingir o público-alvo. Outra preocupação é com a
evolução das pessoas e conseqüentemente de suas preferências. Mas uma coisa é certa, S&A Games são o
ponto de entrada para qualquer outro.
Ainda não há uma classificação única dos Computer Games, pelo fato do campo ainda ser
recente e termos poucas variações de jogos, poucas amostras. Será proposta uma divisão em duas grandes
categorias e cada uma com muitas subcategorias. S&A Games é a maior classe e mais popular, caracterizada
pelos jogos em tempo real, com grande ênfase em gráficos e som, e o uso do joystick no lugar do teclado. As
habilidades principais exigidas do jogador são a coordenação dos olhos e da mão e a reação rápida. Essa
categoria é subdividida em mais seis: Combat Games, Maze, Sports, Paddle (estilo PONG e pinball), Race e
Miscellaneous. Os Combat Games apresentam confronto violento e direto. O jogador deve atirar e destruir os
inimigos controlados pelo computador evitando ser atingido. Há muitas variações nesse tipo de jogo, em que
geralmente muda a visão do jogador (primeira ou terceira pessoa) e o armamento dos oponentes. Maze
Games são caracterizados por conter um labirinto de caminhos que o jogador deve se mover. Além disso, em
alguns jogos, possuem inimigos que perseguem o jogador ao longo do labirinto e em alguns outros, o objetivo
é alcançar a saída. Nesses jogos é perceptível nitidamente a estrutura de ramificações onde cada ponto de
ramificação representa a decisão tomada pelo jogador. Sports Games modelam esportes populares. Pessoas
sem idéias originais recorrem a eles como modelos para criarem um jogo. Todos esses jogos tiram a liberdade
do jogador para alcançar uma boa jogabilidade. Esse tipo de jogo não atrairá muita atenção para projetos no
futuro. Nos Paddle Games o jogador, normalmente, manipula uma espécie de “raquete” para rebater bolas. O
sistema desse jogo é muito simples e provavelmente não há muito desenvolvimento pela frente. Race Games
envolvem corrida direta, tendo que evitar alguns obstáculos posicionados ao longo do percurso e a pontuação
do jogar está baseada no seu tempo para completar o mesmo. Alguns desses jogos não possuem uma interação
real entre o jogador e o oponente. Miscellaneous Games são caracterizados por uma mesclagem de
características.
Outra grande classe é a de Strategy Games, que enfatizam mais o raciocínio do que habilidades
motoras, como nos S&A Games e levam mais tempo para jogar. De fato, Strategy Games em tempo real são
raros, mas isso está mudando. Dentro dessa classe, há os Adventures, onde o jogador deve se mover através
do mundo, acumulando ferramentas para superar cada obstáculo até atingir seu objetivo. Os Adventures estão
mais próximos aos quebra-cabeças do que aos jogos, pois após o jogador ter ultrapassado um obstáculo, o
jogo não fornece mais desafios. Alguns até se aproximam de jogos quando incorporam obstáculos tais como
dragões que de alguma forma reagem ao jogador. Outra subcategoria são os D&D (Dungeons & Dragons)
Games. Jogo de representação de papéis foi criado por Gary Gygax com Dungeons and Dragons, um
complexo jogo não-computadorizado de exploração, cooperação e conflito em um mundo de fantasia, em que
as pessoas se reúnem ao redor de uma mesa e jogam. Alguns problemas surgiram: primeiro, era necessário um
grupo de jogadores e um “árbitro”, então era impossível jogar sozinho. Segundo, o jogo às vezes se tornava
tedioso quando era preciso fazer cálculos longos e jogar dados. A implantação desse estilo nos computadores
se tornou necessária. Alguns jogos usam fundamentos do D&D e do Adventure, surgindo uma nova classe de
jogos, a FRP ( Fantasy Role-Playing). Wargames é também uma subclasse muito importante. Eram bastante
jogados em tabuleiros e muito complicado de se implementar em computadores. Os Wargames disponíveis
em computador estão dentro de dois grupos distintos: o primeiro é composto pelas conversões diretas do jogo
de tabuleiro convencional, apresentando as mesmas inconveniências, lento e desajeitado. O segundo grupo é
menos submisso, apresentando gráficos, mas ainda em fase de testes, portanto mais fracassos do que acertos.
HORA DA AULA
Os Games of Chance (Jogos de azar) são jogados há muito tempo. São fáceis de programar, mas pouco
populares nos computadores, porque lá perdem algumas vantagens das tecnologias originais e não usam os
pontos fortes do computador. Embora todos os jogos de alguma forma sejam educativos, alguns outros são
criados com essa única intenção. Pedagogos estão dando conta do poder motivacional dos Educational and
Children’s Games em relação ao potencial educacional. E por fim, os Interpersonal Games, que foca as
relações entre indivíduos ou grupos. Embora essa categoria seja pouco desenvolvida, possui um fator
importante, estimula a imaginação das pessoas. A classificação é casual, mas é importante para sugerir
algumas observações a respeito do estado do Game Design. O jogo-referência de cada categoria tem tido
muitos sucessores, o que leva, geralmente, a um aperfeiçoamento contínuo. As categorias dos Strategy Games
ainda são confusas o que facilita processos criativos. Com o tempo essa classificação se tornará inadequada,
sendo necessário mudanças.
O computador oferece possibilidades especiais e impõe barreiras ao Game Designer. Cartas são uma
tecnologia simples. Como toda tecnologia, possui pontos positivos e negativos, por exemplo, Games of
Chance são facilmente implementados por essa tecnologia, entretanto utilizá-la nos S&A Games e nos
Athletic Games é muito difícil. Board Games (jogos de tabuleiro) é outra tecnologia, muito mais flexível.
Usa-se na maioria das vezes os dados para os processos de sorteio. Wargames usando essa tecnologia é o
projeto mais ambicioso. Nessa tecnologia não há informação secreta, pois todo o jogo está representado no
tabuleiro, os jogos são bastante demorados e qualquer descuido, pode-se arruinar o jogo, derrubando as peças.
Ou seja, cada tecnologia possui pontos fortes e fracos e cabe ao Game Designer conhecê-las bem e usar a
criatividade.
A característica mais importante do computador no contexto do jogo é a compreensão. O
computador responde às ações do jogador de várias formas e compreende mudanças no comportamento do
jogo (como aumento de nível de dificuldade e outras opções) perfeitamente. A segunda característica do
computador é a habilidade de ser o “árbitro” do jogo, deixando o jogador exclusivamente jogando. Isso
permite uma outra vantagem, o computador pode implementar cálculos e regras lógicas complexas. A terceira
vantagem é o jogo em tempo real no computador. Outras tecnologias de jogo possuem pausas e algumas
demoras enquanto assuntos administrativos são resolvidos e no computador isso é calculado tão rapidamente
que nem se nota. O quarto ponto forte do computador é a inteligência do oponente, todas as outras tecnologias
necessitam de oponente humano. A quinta é a habilidade do computador limitar as informações dadas ao
jogador, o que favorece a suposição e a imaginação. O sexto ponto forte é a capacidade de suportar muitos
jogadores através de linhas telefônicas. Como em todas as tecnologias, há os pontos fortes, como já citado, e
os pontos fracos que serão citados agora. A primeira fraqueza do computador é a capacidade limitada da I/O2
(entrada e saída) da maioria dos computadores e é essa I/O que gera a comunicação entre o computador e o
jogador. A maioria das saídas é através de gráficos e sons e das entradas através de teclados, joysticks. Os
gráficos ainda são fracos, mas o fato de ter animações os torna um pouco mais sofisticados em relação aos
Board Games. O uso de controles e teclados limita um pouco o jogador a usar somente aqueles botões. Outro
ponto fraco do computador é a orientação de single-player. Se duas pessoas forem jogar, elas terão que trocar
os assentos, um procedimento ruim. Com os controles, o problema diminuiu um pouco. Já os Board Games
geralmente são jogados por um grupo de pessoas ao redor de uma mesa, algo mais sociável. A última
fraqueza do computador é o grande empenho exigido ao Game Designer para se ter um jogo plausível. Assim,
um Game Design bom é um grande desafio.
Algumas regras são sugeridas e podem ser seguidas para um bom Game Design.
Primeiramente, vá com calma, porque o computador possui limitações e o Game Designer precisa conhecê-las
e trabalhar em cima disso. Segunda regra: não converta. Alguns jogos são mais proveitosos em outras
tecnologias, não havendo necessidade de converter para computadores. De alguma forma, todo jogo
convertido perde algo no processo. Pode até ganhar algo, mas sempre perde também, pois os jogos são
aperfeiçoados em cima da tecnologia usada. A terceira regra gira em torno da I/O. Como o uso de I/O nos
Computer Games é ainda uma fraqueza e o bom uso delas é indispensável para interatividade entre o
computador e o jogador, a atenção deve estar nesse quesito para o sucesso do jogo. Regra quatro: seja claro,
crie regras que sejam universalmente aplicáveis, abrangendo todas as atitudes do jogador para ser
desnecessário o uso de patches3. Assim o jogo se torna mais claro. Quinta regra: armazene menos e processe
mais. O computador é principalmente um dispositivo de processamento e não de armazenamento. Por ser
mais fácil trabalhar com o armazenamento, muitos Game Designers seguem este caminho. Use sempre
2
Input/Output: Entrada e Saída de dados
3
Pacotes de atualização para correção de erros
HORA DA AULA
códigos eficientes para evitar o desperdício de memória. Um programa que usa maior processamento é
dinâmico, flexível, compreende melhor e interativo. A qualidade das redes de opções que o jogo apresenta só
é alcançada através do uso intensivo de processamento. Finalmente, a sexta regra diz que é preciso combinar a
habilidade de projetar jogos com a de programar. Os Game Designers devem reconhecer os limites dos
programadores e vice-versa, para assim, alcançarem uma unidade no projeto e o sucesso do jogo.
A criação de um jogo é um processo artístico e técnico. Sendo assim, é preciso combinar
esses dois processos de forma razoável. Algumas sugestões de procedimentos são sugeridas: primeiramente, é
importante criar uma meta com uma intenção definida. Posteriormente, é preciso escolher um assunto para
expressar essa meta. O ambiente no qual será jogado. Com a meta e o assunto na cabeça, leia tudo que puder a
respeito dos mesmos. Isso é importante para se ter um jogo mais realista. Nessa fase não escreva nenhuma
linha de código, somente estude. Agora com a idéia clara, seu principal objetivo é criar um esboço de três
estruturas interdependentes: a estrutura I/O (comunicação entre o computador e o jogador), estrutura do jogo
(arquitetura das relações causais dos obstáculos que o jogador deverá enfrentar) e a estrutura do programa (a
organização do código).
A estrutura I/O é a mais importante e mais complicada das três. Output (saída): use os gráficos e o
som para criar uma comunicação com o jogador. Storyboard (seqüência de cenas desenhadas) é uma
ferramenta de projeto de gráficos, mas não é apropriada aos jogos por ser seqüencial. Input (entrada): projete
uma estrutura de entrada clara (de preferência evite o uso do teclado e privilegie joysticks), que permita
muitas opções ao jogador. O problema central em criar a estrutura do jogo é compreender como inserir a
imaginação da meta e do assunto em um sistema executável. A estrutura do jogo deve ser bastante
manipulável para que o jogador tenha amplas opções e fomente sua imaginação. A estrutura do programa é a
tradução das estruturas I/O e do jogo em um produto real. Usar a memória adequadamente é um ponto
importante aqui. Concentre maior memória para funções primárias do jogo. Confira se o projeto satisfaz a
meta proposta, se a intenção do jogo está sendo realmente alcançada. Analise a estabilidade da estrutura do
jogo, ela deve abranger todas as atitudes do jogador. Se o Game Designer não se sente motivado pelo jogo e
não vê probabilidade de sucesso, não hesite em encerrar o projeto.
Na fase de pré-programação, defina a estrutura I/O e a estrutura interna do jogo. Nessa fase
deve enfatizar a experiência do jogador ao invés de considerações técnicas. A fase de programação é a mais
fácil. É um trabalho direto e tedioso, mas requer muita atenção em detalhes e muito empenho. Na fase de
testes, obtêm-se informações usadas para refinar o projeto. Freqüentemente é necessário corrigir alguns erros
de programação. Uma falha fatal surge de um conflito fundamental entre dois elementos importantes do jogo
cuja incompatibilidade não foi prevista. Escolha outras pessoas (que tenham experiência com jogos) para
testar o jogo, pois será de grande valia para a correção dos bugs4. Depois faça entrevista com cada uma dessas
pessoas e procure as possíveis falhas. Crie um manual para minimizar as limitações do computador, para
fomentar elementos da imaginação com quadros, histórias e para responder as possíveis dúvidas a respeito do
jogo. Após a distribuição do seu jogo para o mercado, cuidado com os críticos. Se as críticas forem
construtivas, atente a elas, caso contrário, despreze-as. O público precisa comprar o jogo para gerar lucros e
para transmitir a mensagem do mesmo. Se considerar que atingiu sua meta, não se preocupe com os críticos e
o público.
Todo artista desenvolve suas próprias técnicas e ideais para a execução de sua arte e com o
Game Designer não é diferente. Por isso, segue algumas orientações para o Game Design:
O equilíbrio dos “single-games” é muito importante, pois esse tipo de game coloca o jogador contra
o computador. Excetuando nos jogos de cálculos, em que o jogador sempre teria vantagem. Então como criar
jogos que desafie o jogador? Use números grandes de oponentes com inteligência fraca ou pequenas
quantidades mais poderosos que o jogador. Em ambos os casos, o jogador tem a vantagem de sua inteligência,
criando um certo equilíbrio. Essa técnica gera conflito entre o jogador e o computador e também é mais fácil
de se implementar. Primeira exigência é produzir um comportamento pelo menos razoável do oponente
computador. O melhor método (e mais complicado) é criar um algoritmo mais geral que evite movimentos
absurdos do computador. A segunda exigência é a imprevisibilidade das ações do oponente controlado pelo
computador se atentando à interatividade e jogabilidade. Pra se ter uma inteligência artificial considerável é
preciso testar o jogo constantemente. Crie um sistema de pontuação para facilitar a inteligência dos
movimentos, faça análise de campo sempre para a decisão do melhor movimento e se algo estiver complicado
de se implementar, simplesmente não o faça ou o apague. Outra forma de compensar a falta de inteligência do
4
Sugestão de tradução: Erros
HORA DA AULA
computador é limitar a quantidade de informações disponíveis ao jogador. Com isso excita a imaginação
sugerindo algo sem confirmar.
O ritmo também é uma forma de equilibrar o jogo, pois sendo o computador muito mais rápido que o
jogador, é preciso implementar algo para haver um equilíbrio.
Todo jogo deve estabelecer uma boa relação entre os oponentes para se tornar mais interessante. As
Relações Simétricas é a arquitetura mais simples e todos os jogadores possuem as mesmas propriedades, as
mesmas forças e fraquezas. Por isso são mais fáceis de programar, entretanto sua simplicidade se torna um
ponto falho, às vezes. Já nas Relações Assimétricas, cada jogador possui uma combinação diferente de
vantagens e desvantagens e cabe ao Game Designer equilibrar essas diferenças para que cada um tenha a
mesma chance de ganhar. O modo mais simples de fazer isto é com a assimetria flexível, no qual o jogador,
antes de mais nada, seleciona suas próprias características, sendo impossível reclamar sua inferioridade
perante o oponente, pois ele mesmo quem escolheu. Single-games normalmente usam relações assimétricas
de fato para compensar a falta de inteligência do computador. A vantagem de jogos assimétricos está na
habilidade de construir relações não-transitivas ou triangulares. Por exemplo, no jogo Pedra, Papel e Tesoura,
o fato da pedra ganhar da tesoura, da tesoura ganhar do papel não implica que a pedra vença o papel. Uma
relação triangular permite a cada jogador, métodos indiretos de interatividade. Alguns jogos criam atores
(NPCs) controlados pelo computador para criar relações indiretas e não mais aproximações diretas entre
oponentes. O aprendizado durante o jogo deve ser uma progressão contínua e estável para que todos os
jogadores consigam acompanhar o ritmo. Geralmente, o jogador escolhe o nível de dificuldade que deseja. O
jogo deve passar uma sensação de vitória a todos. O jogador deve acreditar que os fracassos sejam causados
por erros próprios para então enxergar o jogo como possível de se vencer e se esforçar para ganhar.
O futuro dos computadores ainda é bastante incerto e há muitas divergências e argumentos
nessa área. Muitos ainda discutem se são passageiros ou vieram para ficar, mas como os jogos são uma forma
de diversão, certamente possuem um futuro luminoso. O futuro dos jogos geralmente está relacionado às
melhorias dos computadores. É preciso analisar se as limitações tecnológicas são barreiras para o Game
Designer e fazer desenvolver tanto a parte tecnológica como a artística para se obter avanços significativos
nos jogos. Normalmente existem quatro fases em uma revolução tecnológica: abertura do caminho, a
conquista, transformação da sociedade pela tecnologia e transformação da tecnologia através da sociedade. O
mesmo ocorre com os computadores que se encontra no intermédio da primeira fase com a segunda. Como os
jogos, possivelmente se tornarão itens do mercado de massa, os que obtiverem sucesso serão largamente
copiados. Entretanto espera-se que o mercado exiba um maior grau de variedades e que o Game Designer seja
considerado um artista de fato.
Posicionamento Crítico do Observador:

A revolução tecnológica na área dos computadores proporcionou uma ferramenta eficiente para a
criação de games. Assim, os Game Designs se tornaram mais complexos, mais refinados, exigindo muito
empenho do Game Designer. E é esse refinamento que gera esse maravilhoso mundo virtual que a cada dia se
torna mais bonito graficamente e mais interativo.
A obra “The Art of Computer Game Design” de Chris Crawford foi escrita originalmente na
data de 1982, então devemos ir com calma nas críticas. Por ter sido escrito em meio ao processo de evolução
dos computadores e conseqüentemente dos jogos, assume uma importância histórica e documental muito
grande. Podemos analisar o pensamento da época, as expectativas, as potencialidades do momento. E para que
nós possamos manter uma progressão ascendente no ramo da Computação, devemos analisar o passado e
evitar repetidos erros.
Com a leitura atenta do livro, notamos o fundamental papel do Game Designer no projeto de
um jogo. Em todas as fases de desenvolvimento, ele assume um controle e uma atividade muito vasta. Sendo
assim, devemos nos atentar na escolha e na formação (acadêmica e intelectual) do Game Designer. Como
citado no livro, o profissional mencionado precisa ser considerado um artista, primeiramente. O trabalho que
ele exerce é essencial e arrisco a dizer que sem ele, o sucesso dos jogos não seria tanto. Até os tempos
presentes, essa consideração artística ainda não está firmada. Muitos ainda não enxergam o Game Design
como um projeto realmente sério. Da mesma forma que o artista plástico modela, manipula o barro para criar
sua arte, o Game Designer manipula suas ferramentas para criar a sua (o jogo).
Algumas observações considero relevante nas palavras de Chris Crawford. Primeiramente
quando disse que Sports Games não atrairiam atenções no futuro e que esse tipo de jogo tira a liberdade do
jogador, não é isso que observamos de fato. Winning Eleven, Fifa Soccer, “Managers”, entre outros, servem
HORA DA AULA
como contra-exemplo. Especificamente o jogo Winning Eleven, é recordista de vendas em todo o mundo com
sua jogabilidade perfeita. Esse game nos dá uma liberdade muito grande, mas claro que dentro do propósito
do mesmo, sendo um jogo de futebol. Outra análise é considerar como fraqueza do computador o fato de que
jogos para essa tecnologia exigem um empenho muito grande dos Game Designers. Eu vejo de outra forma.
Essa exigência, na verdade, funciona como uma espécie de seleção natural, onde evita que aventureiros, sem
intenção de contribuir na evolução dos games, prejudiquem o andamento do processo. Porém, mesmo assim,
surgem títulos medíocres e alguns até mesmo péssimos. Outra nota importante é a da unidade do projeto. Eu
acredito que para um projeto (seja ele de qualquer área) dar certo, é preciso que seus integrantes tenham uma
relação harmoniosa, tenha o conhecimento das limitações dos outros. Game Designers devem criar jogos que
realmente sejam possíveis de se programar. Acredito que para isso, torna-se necessário reuniões para
discussão do andamento e dos caminhos a seguir. É preciso que haja uma interatividade não só no jogo, como
também dentro do projeto. E é nesse ponto que entra o bom convívio entre os membros.
A principal mudança no desenvolvimento de um jogo é a liberdade que os Game Designers têm hoje.
Podem mesclar muitos jogos, testar muitas variedades, o que deve deixar o autor contente, pois ele esperava
uma variedade no mercado de jogos. Crawford considera que para se obter uma boa inteligência artificial, é
preciso que se teste o jogo a todo momento e é isso que vemos atualmente. Liberam Games-Beta com uma
certa freqüência para que jogadores imparciais testem, opinem. Isso é uma boa saída para se corrigir erros de
programação, de lógica e não distribuir o jogo defeituoso, o que seria muito danoso.
Como previsto pelo autor, a classificação dos jogos mudaria e mudou bastante,
evidenciando seu real conhecimento e sua preocupação com o bom desenvolvimento da área de games.
Atualmente existem os RPGs (“Role Playing Game”, no livro: FRP), FPS (First Person Shooters), MMORPG
(Massively-Multiplayer Online Role-Playing Game), RTS (Real Time Strategy) e outros. Utilizando a
classificação feita por Crawford, na data do livro, praticamente todos os jogos se incluíam em S&A Games,
hoje porém, analiso uma mudança, onde praticamente todos os jogos se incluem em Miscellaneous Games.
Os jogos do presente possuem uma mesclagem muito grande de características, fazendo o bom uso dos pontos
fortes de cada tipo.
Portanto, a evolução é nítida e a boa leitura do livro de Crawford nos dá uma visão mais
ampla do que vinha a ser jogos na época, o que a população achava dos mesmos, como eles enxergavam o
futuro e comparar com as conquistas e fracassos de hoje. Sendo essa área muito dinâmica, a classificação dos
jogos de hoje pode e deverá sofrer muitas mudanças ao longo do tempo e os jogos do futuro serão cada vez
mais mesclados.
HORA DA AULA
Nota: Este artigo foi extraído do tópico sobre FSM’s do capítulo de Inteligência Artificial do meu
próximo livro – ainda sem título e data de lançamento, cobrindo algoritmos para Programação de Jogos e
Computação Gráfica. Para esta versão, alguns assuntos foram omitidos, estando disponíveis somente na
versão final do livro.
O código-fonte do exemplo, que também foi alterado para este artigo, encontra-se disponível para
download no portal PDJ.
Copyright © 2006, André Kishimoto. Todos os direitos reservados.
Máquinas de estados finitos (FSM’s)
Uma máquina de estados finitos (finite state machine, ou FSM) é uma máquina abstrata que possui
diversos estados e diversas transições entre esses estados. Em um dado momento, a máquina pode estar
somente em um único estado. Através do processamento de uma entrada na máquina, o estado atual define o
comportamento da máquina e quais ações devem ser tomadas pela mesma (incluindo se há a necessidade de
mudar de estado). Cada transição define de qual estado para qual estado a máquina deve mudar.
FSM’s são muito utilizadas em jogos, pois elas são simples e rápidas de serem implementadas, fáceis
de depurarem, não necessitam de muito processamento da CPU e são flexíveis (novos estados e transições
podem ser adicionados às FSM’s).
Vamos imaginar que temos um NPC vivendo em uma casa virtual. Sua principal ação é ficar
assistindo TV o dia inteiro. Ele pára de assistir TV somente quando estiver cansado, com fome ou apertado.
Quando estiver cansado, ele vai dormir até descansar completamente (depois disso, acorda e volta a assistir
TV). Quando estiver com fome, o NPC vai até a cozinha comer algo. E, se depois de comer muito, ficar
apertado, ele vai até o banheiro fazer suas necessidades. Depois de aliviado, volta a assistir TV. A Figura 1
contém a representação dos estados e transições da FSM desse exemplo.
Figura 1: Exemplo de FSM.
Note que as transições de estado foram feitas apenas entre “Assistir TV” e as demais. Nada
impediria, no entanto, de que tivéssemos transições entre outros estados (por exemplo, enquanto dorme, o
NPC pode sentir fome e ir para a cozinha comer algo, assim como, enquanto está comendo, o NPC pode se
sentir apertado e precisar ir ao banheiro). Aliás, essa FSM ficaria muito melhor (e mais real) com o acréscimo
de transições entre todos os estados, desde que plausíveis.
HORA DA AULA
Implementação de FSM’s
A FSM do exemplo descrito acima pode ser implementada através de uma série de if’s ou dentro de
um switch, como mostra a Listagem 1. Note que a implementação foi feita parcialmente e as funções e
manipulações de dados foram omitidas, dando ênfase na transição de estados.
// Enumera os estados e define estado atual como “Assistir TV”

enum FSM_Estados { AssistirTV, Comer, Dormir, IrAoBanheiro };
int estadoAtual = AssistirTV;
// Verifica o estado atual da FSM e faz transições de acordo com as

// situações apresentadas
switch(estadoAtual)
{
case AssistirTV:
{
// A cada ciclo de máquina, incrementa fome, cansaço, etc...
if(comFome())
{
estadoAtual = Comer;
}
if(cansado())
{
estadoAtual = Dormir;
}
if(apertado())
{
estadoAtual = IrAoBanheiro;
}
} break;
case Comer:
{
if(satisfeito())
{
estadoAtual = AssistirTV;
}
} break;
// outros estados da FSM...
}
Listagem 1: Implementação parcial da FSM da Figura 1.
Embora seja uma solução aparentemente simples e aceitável (e que muitos programadores costumam
utilizar), implementar uma FSM dessa maneira pode resultar em desastres e dor-de-cabeça. Talvez o
problema não tenha ficado muito claro porque mostrei apenas parte da FSM implementada, mas sugiro que
você tente implementar todos os estados e transições.
Ainda não descobriu nada de errado? Então, crie mais estados e faça mais transições entre os estados.
Após um certo tempo, o código se tornará difícil de ser compreendido e depurado, resultando na tal dor-de-
cabeça mencionada, uma vez que você pode ficar perdido entre os diversos estados e transições.
Em jogos mais sofisticados, podemos encontrar agentes onde cada um contém dezenas de estados e
transições entre todos os estados... Imagine como a implementação da FSM ficaria num caso desses!
Nota: Na área de programação, um código contendo muitos if-else’s e switch’s aninhados

costuma receber o nome de spaghetti code; afinal, códigos com esse tipo de estrutura tendem a ficar uma
bagunça!
Implementação de FSM’s através de funções
Além do “spaghetti code” encontrado na implementação de FSM’s no tópico anterior, talvez seja
necessário que um determinado código seja executado no momento em que a máquina saia de um estado,
HORA DA AULA
assim como possa existir a necessidade de executar outro código no momento em que a máquina entre em um
estado. Isso pode ser feito com o método da Listagem 1, mas não é a melhor solução para o problema.
Vamos continuar com o exemplo do NPC que vive em uma casa virtual. Quando o NPC sai do
estado “Assistir TV”, podemos definir uma ação em que ele desliga a TV para economizar energia elétrica
enquanto não está na sala. No momento em que o NPC entra no estado “Assistir TV”, definimos uma outra
ação; dessa vez, o NPC liga a TV quando entra na sala.
No método anterior, seria necessário definir novos estados, tais como “Saindo da sala” e “Entrando
na sala”, bagunçando ainda mais o código. Uma solução mais elaborada para esse problema é implementar a
FSM através de funções.
Com o uso de funções, nós eliminamos tais problemas, tornando o código mais compreensível,
flexível e expansível, além de permitir a execução de códigos durante os momentos em que um agente entra e
sai de um estado.
Nota: O método de FSM’s via funções que apresento nesse tópico foi adaptado do padrão de projeto
conhecido por State. Padrões de projeto (design patterns) são padrões utilizados para resolver determinados
problemas de engenharia de software, e são voltados para programação orientada a objetos.
Para cada estado da FSM, vamos definir três funções: enterState(), executeState() e
exitState(). Acredito que essas funções sejam auto-explicativas. No entanto, surge uma pergunta: quando
cada uma dessas funções deve ser chamada no jogo?
Antes de responder essa pergunta, vamos definir uma estrutura que armazene um estado da FSM:
typedef struct
{
unsigned int state; // Índice do estado. Poderia ser declarado como
// sendo do tipo enum: FSM_Estados state;
void (*enter)(void); // Ponteiro p/ função chamada quando entra no estado
void (*execute)(void); // Ponteiro p/ função que processa o estado
void (*exit)(void); // Ponteiro p/ função chamada quando sai do estado
} STATE, *LPSTATE;
Nessa estrutura STATE, além do índice do estado, foram definidos três ponteiros para as funções
citadas anteriormente.
Os estados da FSM
Para exemplificar como usar a estrutura STATE, vamos criar o estado “Assistir TV” da FSM do nosso
NPC. Como estamos querendo aprender a usar a estrutura STATE, as funções do estado mostrarão apenas uma
mensagem no console. Veja a Listagem 2.
// Função chamada quando o NPC entra no estado

void npcEnterTV(void)
{
printf(“Indo para a sala ligar a TV...\n”);
}
// Função que processa o comportamento do NPC no estado

void npcExecuteTV(void)
{
printf(“Assistindo TV...\n”);
}
// Função chamada quando o NPC sai do estado

void npcExitTV(void)
HORA DA AULA
{
printf(“Desligando a TV e saindo da sala...\n”);
}

{
STATE stateTV; // Estado “Assistir TV”
// Define o estado e suas funções enterState, executeState e exitState.

stateTV.state = AssistirTV; // Veja Listagem 1
stateTV.enter = npcEnterTV;
stateTV.execute = npcExecuteTV;
stateTV.exit = npcExitTV;
// Nota: também podemos criar um estado com a seguinte linha:

// STATE stateTV = { AssistirTV, npcEnterTV, npcExecuteTV, npcExitTV };
return(0);
}
Listagem 2: Definindo um estado da FSM.
O código da Listagem 2 não faz muito a não ser criar um novo estado e configurá-lo. Porém, algo
importante é mostrado nesse trecho de código: nós criamos três funções (npcEnterTV(), npcExecuteTV() e
npcExitTV()) que realizam todo o trabalho de processar os eventos do estado. Bom, se nós criamos essas
funções, nem precisaríamos ter criado a estrutura STATE, certo? Afinal, a estrutura armazena um índice do
estado e ponteiros para as três funções. Já temos as funções, basta criar uma variável int (ou enum) que
armazena o índice do estado.
Isso é verdade. A implementação dessa idéia funciona. Mas da maneira que iremos implementar a
FSM, é mais conveniente utilizar a estrutura STATE, como veremos a seguir.
Transição de estados
Vamos agora responder a pergunta de quando chamar cada uma das funções do estado. O raciocínio
para chegar a resposta é a seguinte: Em um certo momento, o nosso NPC está no estado “Assistir TV”. De
repente, ele sente fome e resolve ir até a cozinha. O que acontece durante a transição do estado “Assistir TV”
para o estado “Comer”? A primeira ação do NPC nessa transição é desligar a TV e sair da sala (ou seja, o
NPC saiu do estado “Assistir TV”). Em seguida, ele vai até a cozinha preparar um lanche (entrou no estado
“Comer”). Uma vez na cozinha, ele permanece lá até ficar satisfeito.
Vamos imaginar agora que o NPC já comeu o lanche, ficou satisfeito e quer continuar assistindo TV.
Encontramos outra transição de estados. Nessa situação, a primeira coisa que o NPC faz é sair da cozinha
(saiu do estado “Comer”). Depois, ele entra na sala, liga a TV (entrou no estado “Assistir TV”) e continua
assistindo aos programas até que resolva fazer outra coisa.
Observe as seqüências de ações tomadas pelo NPC. Há um padrão a ser seguido em todas as
transições: sair do estado atual, entrar no novo estado e permanecer nele até ocorrer outra transição. Tendo
conhecimento dessa seqüência, podemos escrever uma função changeState(), como na Listagem 3.
STATE curState; // Armazena o estado atual da FSM
//--------------------------------------------------------------------------
// changeState() -> Faz transição de estados de uma FSM
//
// in: STATE newState -> Estado que a FSM estará entrando
// out: <nenhum valor>
//--------------------------------------------------------------------------
void changeState(STATE newState)
{
// Sai do estado atual (se função exit() estiver definida)
if(curState.exit)
curState.exit();
// Estado atual recebe propriedades do novo estado
HORA DA AULA
curState.state = newState.state;
curState.enter = newState.enter;
curState.execute = newState.execute;
curState.exit = newState.exit;
// Entra no novo estado
if(curState.enter)
curState.enter();
}
Listagem 3: Transição de estados.
O código acima é válido somente para um agente, uma vez que a função utiliza a variável global
curState.Para usar a função com qualquer agente, poderíamos passar um outro parâmetro (o estado atual de
um agente) para a função. Assim, o protótipo da nova função seria declarado da seguinte maneira: void
changeState(STATE &curState, STATE newState).
Essa solução é válida, mas quero mostrar uma outra solução possível, que é utilizada nos programas-
exemplos do livro. Minha solução envolve o uso de outra estrutura de dados:
typedef struct
{
STATE curState; // Estado atual da FSM
//------------------------------------------------------------------------
// changeState() -> Faz transição de estados de uma FSM
//
// in: STATE newState -> Estado que a FSM estará entrando
//------------------------------------------------------------------------
void changeState(STATE newState)
{
// O código desta função é o mesmo código da função changeState()
// da Listagem 3.
}
} FSM, *LPFSM;
Essa estrutura FSM é muito estranha, não é? Afinal, quando aprendemos a programar em linguagem
C, as pessoas nos ensinam que uma estrutura possui somente tipos de dados, não podendo conter nenhuma
função dentro dela. Mas aqui, estamos declarando uma função dentro da estrutura! Como isso é possível?
Na verdade, isso não é possível. Aliás, isso é errado! Na linguagem C, uma função não pode ser
membro de uma estrutura. O que ocorre nesse caso é que o código foi compilado usando um compilador C++,
e quando esse tipo de estrutura é criado, o compilador interpreta a estrutura como sendo uma classe em C++.
Compiladores “C-only” irão reclamar dessa estrutura!
Nota: Resolvi levantar essa questão porque certa vez estava estudando alguns algoritmos e me
deparei com esse tipo de estrutura. Fiquei confuso, pois aprendi que funções não podiam fazer parte de uma
estrutura. E realmente não podem. Comecei a pesquisar sobre funções dentro de estruturas, e descobri esse
fato interessante, de que compiladores C++ interpretam tal estrutura como uma classe. Essa descoberta me
fez lembrar das vezes em que ouvi (já até perdi a conta disso) programadores C++ explicando, grosso modo,
que uma classe pode ser imaginada como uma estrutura que contém funções. Eu mesmo digo isso quando
programadores C me pedem para definir o que é uma classe. Lógico que uma classe não é só uma estrutura
que contém funções, mas essa explicação parece funcionar com muita gente. Aqui está então a tal estrutura
com funções!
Agora que possuímos a função changeState(), vamos ver como podemos utilizá-la nos jogos. Para
isso, acompanhe a Listagem 4, que codifica a transição entre dois estados do nosso NPC de exemplo.
// Nota: Assumimos que as funções npcEnter*() e npcExit*() já foram

// declaradas e codificadas, assim como o índice (tipo enum) dos estados e
// o estado STATE stateMorto e suas funções.
// Função que processa o comportamento do NPC no estado “Assistir TV”

HORA DA AULA
void npcExecuteTV(void)
{
printf(“Assistindo TV...\n”);
// Se o NPC estiver com fome, muda o estado para “Comer”

if(comFome())
fsm.changeState(stateComer);
// Diminui tempo de vida do NPC e verifica se morreu

envelhecerNPC();
if(morto())
fsm.changeState(stateMorto);
}
// Função que processa o comportamento do NPC no estado “Comer”

void npcExecuteComer(void)
{
printf(“Comendo um lanchinho...\n”);
// Se o NPC estiver satisfeito, muda o estado para “Assistir TV”

if(satisfeito())
fsm.changeState(stateTV);
// Diminui tempo de vida do NPC e verifica se morreu

envelhecerNPC();
if(morto())
fsm.changeState(stateMorto);
}
// Define dois estados do NPC, “Assistir TV” e “Comer”.

STATE stateTV = { AssistirTV, npcEnterTV, npcExecuteTV, npcExitTV };
STATE stateComer = { Comer, npcEnterComer, npcExecuteComer, npcExitComer };

{
// FSM para fazer transição entre os estados
FSM fsm;
while(fsm.curState != Morto) // Definimos um novo estado “Morto”, para que

{ // seja possível finalizar o programa.
if(fsm.execute)
fsm.execute(); // Chama a função execute do estado atual
}
return(0);
}
Listagem 4: Realizando transições de estados.
Podemos verificar que a transição entre estados é simples de ser realizada. Também podemos
verificar como a função “execute” de cada estado da FSM é chamada, dentro da main(). Repare como não há
necessidade de chamar funções de nomes diferentes para cada estado da FSM, pois o ponteiro para função
elimina esse inconveniente.
Observe agora o código das funções npcExecuteTV() e npcExecuteComer(). Temos uma repetição
de código, que é a chamada à função envelhecerNPC() e a verificação se o NPC está morto. O trecho de
código é idêntico, e seria melhor se pudéssemos codificar tal trecho apenas uma vez.
Para situações que possam ocorrer em qualquer estado da FSM (como o envelhecimento e morte do
NPC), ao invés de repetir o código em cada estado, podemos criar um estado global, que é executado junto
com o estado atual da FSM. Assim, a estrutura FSM recebe um novo membro globalState e uma nova função
update(), que deve ser chamada no lugar da execute() (Listagem 5).
// A estrutura FSM possui esse novo membro e nova função:

STATE globalState;
//--------------------------------------------------------------------------
// update() -> Atualiza/processa comportamento da FSM
//
HORA DA AULA
// in: <nenhum valor>

//--------------------------------------------------------------------------
void update(void)
{
// Se existe um estado global na FSM, processa o mesmo
if(globalState.execute)
globalState.execute();
// Se existe um estado atual na FSM, processa o mesmo

if(curState.execute)
curState.execute();
}

{
fsm.globalState = stateGlobal; // Assumindo que stateGlobal foi declarado
while(fsm.curState != Morto)
fsm.update(); // Chama a função execute do estado global e do atual
return(0);
}
Listagem 5: Estado global de uma FSM.
Para melhorar a nossa FSM, podemos acrescentar um novo estado prevState à estrutura FSM, que
salva o estado anterior da FSM. Assim, é possível retornar ao estado que estava em processamento antes da
última transição de estados.
Nota: Chegamos ao final do artigo. Para aqueles que ficaram interessados ou curiosos sobre o que
mais é abordado no livro, em relação à FSM e IA: explicação sobre ponteiros de funções (usados neste
artigo), acrescentar o novo estado à estrutura FSM, uso de mensagens nas FSM’s (temporização e conversa
entre NPC’s e objetos), exemplos visuais (não somente modo console), movimentação de agentes, line-of-
sight, algoritmos de busca (DFS, BFS, Dijkstra, A*), grafos e path-following.
HORA DA AULA
Guia básico para o desenvolvimento de jogos
Autor: Jean Freitas (LoneWolf)
Introdução
O mundo dos jogos eletrônicos tem crescido bastante juntamente com as evoluções tecnológicas.
Assim, aumenta também o interesse de iniciantes e profissionais nessa área, tornando conveniente a criação
de um guia para nortear os primeiros passos no desenvolvimento de jogos, abordando alguns assuntos
relacionados.
Para efeitos de motivação (aos iniciantes estudiosos) e de desmotivação (aos aventureiros), é
importante dizer que o mercado brasileiro ainda está aprendendo a andar, com falta de profissionais realmente
especializados e dedicados. É uma área que exige muita disciplina e paciência, pois o retorno geralmente não
será imediato e profissionais razoáveis não possuem espaço. Veja alguns dados abaixo:
As empresas brasileiras (55 no total) focam no mercado de PC (63%), mais tradicional. Em segundo
lugar, vem o de celulares (22%). A dificuldade em obter as licenças dos kits de desenvolvimento para os
grandes consoles ainda é muito grande, o que visivelmente impede uma penetração das desenvolvedoras
brasileiras nesse nicho. Sem distribuição oficial, também não existem suporte e incentivo aos desenvolvedores
locais. Um dos empecilhos para que esse cenário mude é a pirataria.
Em 2003, o mercado mundial de jogos teve um faturamento próximo de US$ 22,3 bilhões, isso sem
levar em conta o comércio de acessórios. A previsão é que uma taxa de 20,1% de crescimento seja mantida no
período de 2004 a 2008, atingindo assim cerca de US$ 55,6 bilhões em 2008. Já o Brasil tem um faturamento
de aproximadamente 18 milhões de reais1. Apesar das empresas brasileiras de jogos ainda não poderem
competir com as cifras dos grandes centros de desenvolvimento do mundo, as desenvolvedoras nacionais têm-
se desenvolvido num ritmo extremamente competitivo.
Tendo em vista os dados acima, esse documento é voltado para pessoas com pouca ou nenhuma
experiência no desenvolvimento de jogos, mas que saibam da longa e árdua jornada a ser percorrida. O foco
estará principalmente na programação e aspectos de projeto do desenvolvimento de jogos. Por ser um guia, só
será mostrado, de fato, como iniciar no mundo dos jogos.
Primeiros passos
Primeiramente, é preciso que responda 5 perguntas iniciais, são elas:
• Qual setor no desenvolvimento de um jogo trabalhará?
• Qual linguagem/ferramenta utilizará?
• Que tipo de jogo?
• Qual plataforma?
• Qual a intenção do projeto?
Para conseguir respondê-las, leia atentamente o que se segue:
1. Alguns setores no desenvolvimento de um jogo
1
Esta estimativa refere-se, apenas, ao faturamento das desenvolvedoras. O mercado como um todo
(incluindo distribuição, embalagem, marketing, publicidade, etc.) é estimado em algo próximo a 100
milhões de reais, mesmo com os elevados índices de pirataria (Segundo estudo da IDG Consulting,
realizado em 2004, a pirataria de jogos no Brasil é de 94%, prejuízo calculado em aproximadamente
210 milhões de dólares – fonte: Plano Diretor da Abragames).
HORA DA AULA
Para se criar um jogo realmente bom, é preciso que se planeje detalhadamente cada setor do projeto.
Antes de qualquer coisa, tenha a idéia do jogo. Depois disso pegue papéis e rabisque esboços de ambientes,
personagens, possibilidades etc. Com isso pronto, crie o roteiro, explicando detalhadamente cada fase, cada
personagem, cada nível, ou seja, a história. Faça a arte conceitual (desenhos em 2d detalhados de
personagens, cenários), passe para o 3D, programe as funções do jogo, teste-o e comercialize-o. Tudo isso é
muito trabalhoso para uma pessoa só, então no desenvolvimento de um projeto de jogo grande, é necessária
uma equipe (no Brasil, geralmente, as empresas possuem 15 integrantes) dividindo-a da seguinte forma:
Game Designer: imagina o jogo, define como ele funcionará, descreve os elementos que criam um
jogo e transmite tudo isso para o resto da equipe. “Em tese, o papel do designer de games é projetar jogos para
PC, consoles, celulares, internet (e outros). Assim como um arquiteto projeta uma casa, um designer de games
projeta um jogo. Nem sempre é esse profissional que vai desenvolvê-lo, mas, se levarmos em consideração a
realidade do mercado de trabalho, esse profissional com certeza terá de pôr a mão na massa e entrar no
processo de desenvolvimento também”, afirmou Delmar Galisi, coordenador do curso de designer de games
da Anhembi Morumbi (universidade de São Paulo que oferece curso de graduação em desenvolvimento de
jogos). É o profissional mais difícil de encontrar no mercado.
Desenhista Conceitual: responsável pela criação de esboços de ambientes e personagens dos games
usando técnicas 2D. O game é feito em cima desses desenhos, que agilizam a correção de erros e mostram
como serão as seqüências de animação que entram nos jogos.
Desenhista: responsável pela criação de ambientes e personagens dos games usando técnicas 2D que
serão empregados no jogo.
Modelador/Animador 3D: transforma a arte conceitual em desenho 3D. Faz a modelagem dos
personagens, cenários e animação dos jogos. Este profissional pensa no ambiente e nos personagens do jogo
assim como um arquiteto imagina o ambiente de uma casa. O trabalho também envolve criar noções de
espaço, profundidade, iluminação e dimensões do ambiente do game.
Texturizador: emprega conhecimentos em técnicas 2D para a geração de texturas para os modelos
3D. Às vezes uma mesma pessoa se encarrega de modelar e texturizar.
Programador: é a pessoa que programa o jogo através de alguma linguagem de programação (será
mostrado abaixo), inserindo todos os elementos criados pelos outros profissionais. É o programador que fará o
jogo jogável, fará o personagem responder aos controles do teclado e/ou mouse, fará a inteligência dos
inimigos e assim por diante.
Beta Tester: testa os jogos à procura de “bugs” (falhas / erros de programação). Cria todas as
possíveis situações geradas por um jogador e analisa o “comportamento” do game.
Logicamente, existem outros setores como: Gerente de projetos (responsável pelo andamento do
projeto), Administrador (gerencia a empresa, analisa os gastos e ganhos), Gerente de Marketing
(responsável pela publicidade do jogo). Porém esse guia tem a intenção de somente abrir as portas para o
iniciante e não explicar a fundo como é dividida uma empresa.
Com esse tópico, você poderá responder a primeira pergunta proposta.
2. Linguagens / Ferramentas existentes
2.1. Desenho conceitual
Para seguir nesse setor no desenvolvimento de jogos, as ferramentas podem ser bem simples ou
bastante sofisticadas. Um papel, lápis e borracha podem servir muito bem, inicialmente, para esse ramo. Com
eles em mãos poderá usar sua criatividade e conhecimento para criar inúmeros desenhos conceituais de
personagens e cenários para os games.
Alguns softwares estão disponíveis para facilitar a vida do desenhista na colorização dos desenhos e
na digitalização dos mesmos. Exemplos de alguns:
Adobe Photoshop: padrão profissional em edição de imagens e líder no mercado de geração de
imagens digitais. Ferramentas criativas e inovadoras ajudam você a obter resultados extraordinários na
digitalização da arte conceitual. É pago.
GIMP: acrônimo de GNU Image Manipulation Program, é um software gratuito de retoque,
composição e criação de imagens. É útil para fazer desde uma simples pintura até um retoque profissional de
imagens. O programa permite também que por meio de plug-ins e extensões, sejam agregadas a ele inúmeras
HORA DA AULA
ferramentas, tornando-o ainda mais poderoso e versátil. Film GIMP é a mais famosa das extensões. Agora
chamada de Cine Paint, é utilizada na edição de filmes e criação de efeitos especiais.
Corel Photo-Paint: é um programa de pintura que possibilita o tratamento de fotografias ou a
construção de imagens partindo de pontos individuais. Mesmo que não seja um artista, com este programa
conseguirá facilmente criar ilustrações através de imagens recolhidas de uma câmara digital, ou simplesmente
utilizando os inúmeros cliparts que a Corel coloca ao seu dispor. É pago.
Adobe Illustrator: o Adobe Illustrator, o software gráfico vetorial padrão do setor, é uma
ferramenta essencial para aqueles que precisam expressar suas idéias visualmente por meio da impressão, da
Web ou por qualquer outra mídia. Com novos e poderosos recursos de 3D, controles tipográficos avançados,
integração fácil com o Adobe PDF e opções de impressão e desempenho melhorados, esta indispensável
ferramenta de design o ajuda a explorar sua criatividade visual e a publicar seus trabalhos de maneira eficiente
em qualquer lugar. É pago.
Macromedia FreeHand: é a solução para design de multi-publicação para o conceito e design de
ilustrações visualmente ricas. Uma rica coleção de ferramentas de ilustração e desenho permite que designers
realizem suas maiores visões criativas, enquanto extensivas funções de edição, layout e publicação fornecem
um fluxo de trabalho aberto e consolidado para a criação de ilustrações, fazendo o layout de storyboards2. É
pago.
Corel Painter: é um aplicativo de esboço e pintura digital, altamente realista. Compatível com o
Adobe Photoshop, ele deixa você combinar capacidades avançadas de pintura, com edição de foto para
expandir a criatividade do seu trabalho. O Corel Painter foi projetado para artistas digitais, ilustradores e
fotógrafos que desejam imitar e experimentar as tradicionais ferramentas de pintura e desenho tais como
aquarelas, tintas, pintura à óleo, lápis-de-cor, penas, gizes e pastéis; sem sujar as mãos. É pago.
Existem muitas outras ferramentas de boa qualidade disponíveis, entretanto não serão descritas aqui
para não cansar a leitura.
2.2. Modelagem / Animação 3D
Aqui é indispensável o uso de softwares e os existentes são bastante poderosos. Segue alguns
exemplos:
3D Studio Max: permite a modelagem, texturização, animação e renderização3 3D. Bastante
completo e muito utilizado comercialmente, sendo usado em produção de filmes de animação, vinhetas e
comerciais para TV, maquetes eletrônicas e na criação de qualquer mundo virtual. Existem inúmeros tutoriais
disponíveis na web e muitos deles em português. É pago.
Cinema 4D: capaz de fazer as mesmas coisas que o 3Ds Max. A interface intuitiva e o fluxo de
trabalho lógico do Cinema 4D permite que até mesmo profissionais novatos ao universo de arte digital 3D
possam mergulhar neste universo e produzirem em pouco tempo excelente trabalhos. Há tutoriais na web, mas
a maioria em inglês e outras línguas. Vastamente usado na Europa e é pago.
Softimage XSI: o Softimage tem demonstrado ser a melhor relação custo/beneficio, contendo todos
os processos necessários para o desenvolvimento de uma produção 3D, sendo uma solução cada vez mais
perto do nosso bolso, incentivando profissionais a trabalharem com qualificação e dentro da lei. Pago.
Lightwave 3D: ainda pouco divulgado, é tão poderoso quantos os anteriores. Por isso, seu preço
acaba saindo menor que os demais, mas são poucos os tutoriais em português na internet.
Blender 3D: esse software grátis tem crescido muito no mercado. A comunidade 3D tem se
surprendido com o poder desse programa e pelo fato dele ser gratuito. Com isso tem aumentado também o
número de materiais disponíveis para o aprendizado.
Wings 3D: ótimo para iniciantes por dois motivos: muito intuitivo e gratuito. É um software de
modelagem 3D, mas é possível adaptá-lo com outros programas para gerar renders excelentes e/ou exportar
seus trabalhos para continuar o processo em softwares distintos.
2.3. Programação
Para facilitar a leitura, será explicado de forma compacta a definição de linguagens de alto nível e
baixo nível.
2
Sequência de cenas muito utilizada em games e filmes.
3
É o processo pelo qual se podem obter imagens digitais.
HORA DA AULA
Linguagem de alto nível é uma linguagem que se aproxima mais da linguagem utilizada pelo ser
humano. Exemplos típicos são C/C++, Pascal, etc.
Linguagem de baixo nível é o código que o computador executa diretamente. É composta de 0´s e
1´s e conhecida como linguagem binária.
Caso escolha seguir o ramo da programação, a primeira coisa que precisará fazer é escolher a
linguagem de programação. O leque é bastante vasto, incluindo Basic, Pascal, C, C++, Java, etc., e há uma
grande discussão sobre qual linguagem é a melhor para iniciantes. Assim sendo, torna-se importante citar
algumas características de diferentes linguagens:
C:
Vantagens: Boa para escrever programas rápidos e pequenos. Fácil integração com linguagem
Assembly. Muito padronizada, então versões em outras plataformas são semelhantes.
Desvantagens: Não suporta facilmente técnicas de orientação a objetos e a sintaxe pode ser difícil.
Portabilidade: O centro da linguagem e as chamadas de funções são portáveis, mas C é limitada na
administração de memória e manipulação simples de arquivos. Requer uma especificação da plataforma, o
que significa que você precisa escrever o código de interface do usuário duas vezes. Entretanto, algumas
bibliotecas tornam o processo um pouco mais fácil.
C++:
Vantagens: Muito melhor que C para organizar programas maiores. Suporta bem orientação a
objetos. Muitas bibliotecas, o que evita muito ter que lidar com detalhes de baixo nível.
Desvantagens: Extremamente grande e complicado. Como C, a sintaxe é complicada. Pode ser mais
lento que C. Poucos compiladores implementam corretamente a linguagem inteira.
Portabilidade: Melhor do que C, mas ainda não muito boa. As inúmeras bibliotecas para C++
melhoram um pouco.
Assembly:
Vantagens: É a linguagem menor e mais rápida. Um programador talentoso de Assembly pode
escrever programas que sejam mais rápidos que qualquer outro escrito em outra linguagem. Além do mais,
poderá tirar proveito das mais recentes características dos processadores, porque o usará diretamente.
Desvantagens: Difícil de aprender, sintaxe complicada e gasta bastante código pra fazer algo.
Portabilidade: Por ser implementada diretamente no processador, se torna bastante específica, o que
tira sua portabilidade.
Pascal:
Vantagens: Fácil de aprender. A implementação de programas para plataforma específica é boa.
Desvantagens: Orientação a objetos não obteve êxito
Portabilidade: As características da linguagem mudam de plataforma para plataforma e não há
nenhuma ferramenta de portabilidade para melhorar isso.
Visual Basic:
Vantagens: Muito boa IDE4. Fácil de aprender. Possuem muitos Add-Ons5 disponíveis. A
compilação instantânea a torna bastante rápida.
Desvantagens: Os aplicativos feitos em Visual Basic são grandes e requerem muitos DLL’s6 para
rodar. Tem orientação a objetos, mas não é muito completa.
Portabilidade: Por ser da Microsoft, você não tem escolha a não ser usar o Windows, mas existem
algumas ferramentas que convertem aplicativos em VB (Visual Basic) para Java.
4
Integrated Development Environment (Ambiente Integrado de Desenvolvimento) - são programas que
possuem compiladores, editores, entre outros visando uma maior facilidade na programação e/ou criação de programas.
5
São programas que adicionam novas funções à linguagem.
6
Dinamically Loaded Library (Biblioteca Carregada Dinamicamente) - são arquivos que fazem com que
determinados programas funcionem.
HORA DA AULA
Java
Vantagens: Os aplicativos podem rodar na web. A biblioteca de classe incluída é razoavelmente
unificada e extremamente robusta. Alocação automática nas variáveis, retirando o lixo delas. Muitos
exemplos de códigos na internet.
Desvantagens: Usa uma “máquina virtual” para rodar o código ao invés de código nativo da
máquina. Com isso, os aplicativos se tornam mais lentos. Há algumas tecnologias que melhoram a velocidade
de Java, mas sempre será mais lento que código de máquina. Por ser uma linguagem de nível bem alto, torna-
se muito complicado o uso de procedimentos com máquina de baixo nível.
Portabilidade: Melhor de todos, mas ainda não como deveria ser. O código de baixo nível é muito
portátil, mas algumas características novas da linguagem são instáveis em algumas plataformas.
Pela linguagem C++ ser amplamente utilizada atualmente, encontrará muitos documentos na internet
e muita ajuda. Então essa linguagem acaba sendo a indicada inicialmente. De fato, não importa se começará
com C++ ou outra qualquer, porque uma vez que você aprenda uma linguagem, aprender uma outra se torna
algo mais fácil. Se optar por começar com C++, comece pela parte de programação estruturada7 antes de
orientação a objetos, ou seja, não tente aprender Classe sem antes saber programar sem ela. Caso considere
iniciar em C++ uma tarefa difícil, nada lhe impede de aprender linguagens mais simples, como Basic e Pascal.
Entretanto, com a imensa quantidade de tutoriais, fóruns disponíveis, começar com C++ não é muito
complicado.
Como aprender uma linguagem? Os cursos são a melhor opção, mas tendo algum instrutor para
responder suas perguntas e fornecer tarefas para a prática, já basta. Caso não tenha acesso a opção anterior,
outra ótima forma é por meio de livros. Não existe um livro perfeito, então procure um que você entenda e
que realmente lhe ensine algo. Na internet há inúmeros livros e materiais, e alguns deles gratuitos. Mas não se
esqueça, se realmente quer se profissionalizar nesse ramo, será preciso um investimento prévio.
2.3.1. Escolhendo o compilador certo
Esse tópico será comentado usando a linguagem C++ para simplificar a leitura, mas tudo isso abaixo
se aplica à outras linguagens.
Os programas que você escreve, ou código fonte, são armazenados como um arquivo de texto, e você
pode usar até mesmo o Notepad para escrever um programa em C++. Mas é preciso que aquele código fonte
seja convertido em um arquivo executável. No caso de C++, quem executa essa tarefa é o compilador.
Há um número muito grande de compiladores disponíveis, inclusive gratuitos. É importante que
escolha um compilador que lhe dê conforto e os gratuitos têm a vantagem de poder testá-los e analisá-los.
Porém, os compiladores gratuitos não possuem uma assistência técnica completa, na maioria das vezes.
Felizmente, a maioria dos compiladores comerciais distribui versões introdutórias ou acadêmicas, que custam
muito menos e têm praticamente as mesmas ferramentas, só limitando a distribuição dos programas
compilados por eles.
Resumindo, o compilador que será escolhido dependerá do quanto poderá gastar e qual o sistema
operacional e plataforma para as quais estará desenvolvendo. Se o sistema for o Windows, uma forte sugestão
é o Microsoft Visual C++. Tem um ambiente de desenvolvimento poderoso que tornará muitas coisas mais
fáceis para você. Se você for estudante, poderá obter uma cópia por um preço significativamente reduzido.
Caso vai programar em DOS, uma boa opção é o DJGPP que é grátis.
Com todas as informações acima, responda a segunda pergunta.
3. Tipos de jogos
Adventure: tem a enredo voltado para solucionar enigmas para seguir com seu curso, usa mais o
cérebro e menos a destreza e os reflexos.
Ação: São os jogos em tempo real, onde o jogador deve responder com velocidade ao que está
ocorrendo na tela, exigindo reflexos. Geralmente são os famosos FPS (first person shooter).
7
É uma forma de programação de computadores que proconiza que todos os programas possíveis podem ser
reduzidos a apenas três estruturas: sequência, decisão, iteração (repetição).
HORA DA AULA
RPG (Role Playing Game): o jogador dirige um grupo de personagens em alguma missão, ele pode
controlar o sistema de evolução, distribuindo os pontos em habilidades específicas, por exemplo: agilidade,
força, vitalidade; permite também a escolha dos equipamentos e armas do personagem.
Estratégia: gerenciamento de recursos para atingir um determinado objetivo, esses recursos são
usados para construir unidades de combate, onde cada elemento tem seu custo/beneficio. Ele é baseado em
dois tipos:
Turn-based: baseado em turnos, o jogador faz sua jogada e passa a vez para o adversário;
RTS (real time strategy): o gerenciamento ocorre em tempo real exigindo agilidade e
estratégia ao mesmo tempo.
Simuladores: jogos que simulam condições do mundo real, por exemplo, simuladores de aviões.
Esportes: jogos que representam os esportes “reais”, ele reproduz todas as regras e peculiaridade do
esporte.
Luta: jogos onde dois jogadores controlam personagens que usam combinações de movimentos de
ataque e defesa para derrotar o oponente.
Casuais: são adaptações dos jogos tradicionais como xadrez, paciências ou jogos dos shows de TV,
sua interface é simples e com baixa curva de aprendizagem.
“God games”: jogos que não possuem um real objetivo além do passatempo, geralmente não há
critérios de vitória ou derrota, ou de erros e acertos.
Educacionais: jogo cujo objetivo é ensinar enquanto se diverte jogando, geralmente voltado para o
público infantil.
Puzzle: jogo voltado para desafio intelectual na solução de problemas.
MMO (massive multiplayer online): ele pode ser de qualquer tipo, mas ele deve ser
obrigatoriamente jogado pela Internet onde comunidades inteiras surgem em torno destes jogos.
MOD: é um jogo feito com base em um jogo pré-existente e que usa todas as capacidades desse jogo
pré-existente para criar novas possibilidades aos jogadores. O mais famoso dos MODs é o Counter Strike
(CS) que usa o engine do Half Life (HL).
MUD (Multi-user Dungeons): jogos principalmente no estilo Adventure/RPG em modo texto,
jogado pela rede ou Internet. O jogo expõe um cenário por meio de texto e espera por uma resposta do usuário
via linha de comando para, então, processar a entrada e ir para o próximo cenário.
Existem também jogos do tipo Serious Games (jogos com intuito de treinamento de pessoal) e os
Advergames (jogos desenvolvidos para publicidade de alguma marca), mas esses dois tipos podem e devem
conter alguns dos tipos supracitados. Com a leitura acima terá bases para responder a terceira pergunta.
4. Escolhendo a plataforma – alvo
Embora, provavelmente, você desenvolverá jogos para várias plataformas, é preciso que escolha
uma para aprender. No caso do programador, enquanto aprende a linguagem, e antes de entrar em
qualquer programação que envolva gráficos, você certamente usará sistemas operacionais non-GUI (sem
interface gráfica), do tipo DOS e UNIX, onde você focará somente no aprendizado da linguagem.
Uma vez pronto para iniciar o desenvolvimento de games, seria importante analisar e escolher uma
plataforma alvo. Algumas sugestões:
Windows: Se você quer trabalhar profissionalmente na indústria de jogos, ou se quer que muitas
pessoas possam jogar seu jogo, então esta é a plataforma a escolher. A maioria das pessoas usa o Windows, e
provavelmente isso não mudará em breve. A grande maioria dos jogos é feita para Windows, que usa uma
tecnologia chamada DirectX. DirectX é uma biblioteca que lhe permite ter acesso direto ao hardware,
significando a possibilidade de desenvolver jogos de desempenho alto.
DOS: era a plataforma dominante para jogos, mas isso é passado. Embora alguns, por hobby, ainda
fazem jogos para DOS, nenhum jogo comercial está sendo feito nele. Se você estiver começando a fazer
jogos, não escolha o DOS, ou se fizer, não perca muito tempo com ele. Existem muitos livros que ensinam a
programar jogos no DOS, mas o material referente a Windows tem crescido muito.
Linux: é uma variante de UNIX que ficou popular ultimamente por várias razões, inclusive
estabilidade, preço, e sentimento anti-Microsoft. Embora o número de usuários de Linux ainda é
relativamente pequeno, o entusiasmo que se tem em torno dele e o crescimento do potencial de mercado,
torna o Linux uma escolha viável.
HORA DA AULA
Macintosh: o Mac possui um número considerável de seguidores e a maioria deles deseja mais jogos
e jogos melhores para essa plataforma. Ferramentas para o desenvolvimento de games no Mac não são muito
comuns, mas elas existem. Então essa pode ser uma opção válida também.
Consoles: o mercado de jogos de consoles (isto é, Playstation 3, Xbox 360, Wii, etc.) é enorme e seu
futuro é ainda mais promissor. Porém, o desenvolvimento de jogos de console pelos iniciantes ou sem fins
lucrativos não é algo comum pelo desenvolvimento para console ser fechado (requer aprovação da própria
fabricante). Depois de aprovado, deve-se comprar o kit de desenvolvimento do console SDK (Software
Development Kit) e antes de ser lançado no mercado o jogo deve ser aprovado pelo fabricante. E mais, como
os consoles não são oficiais no Brasil, conseguir esse licença é algo muito complicado.
Web: A velocidade com que se pode desenvolver jogos em Flash e Director (duas das mais
populares ferramentas encontradas) permite que se aborde assuntos que poderiam se tornar esquecidos ou
menos pertinentes após o (longo) tempo necessário para o desenvolvimento de jogos para PC e consoles.
Webgames podem explorar forma e conteúdo, servindo com um laboratório onde os resultados podem ser
rapidamente avaliados. Os custos dos Webgames são menores, permitindo muitas vezes que se corra riscos
maiores.
Dispositivos móveis: Com a popularização dos dispositivos móveis e o aumento da capacidade de
processamento, os dispositivos móveis têm atraído o interesse dos desenvolvedores de jogos que vem dele
uma opção de plataforma. Apesar dos avanços dos dispositivos móveis, eles ainda apresentam baixa
capacidade de processamento e capacidade de armazenamento comparando com os computadores, por esse
motivos os jogos para esses dispositivos devem ser simples e curtos por causa das especificações técnicas.
Outro problema encontrado é a diversidade de aparelhos, conteúdo e os serviços dependem da operadora.
TV Digital: Com a TV digital, um novo mercado começa a se abrir para os desenvolvedores de
jogos. Os profissionais conhecidos pela habilidade e criatividade na elaboração de jogos para celular e
videogames poderão investir em uma nova tecnologia, a de jogos que rodarão nos aparelhos receptores de TV
digital. A interatividade é um dos recursos mais celebrados da TV digital. Na prática, as emissoras poderão
enviar junto com a programação, jogos e outros aplicativos. Antes de entrar nos pormenores técnicos, é
preciso pensar que o desenvolvimento para TV digital deve respeitar alguns critérios comportamentais.
Embora possa ter uma tela tão grande ou maior que a de um computador, a TV não possui teclado – o que
significa que os comandos estão restritos aos botões de um controle remoto.
Fazendo uma leitura atenta do tópico acima, terá noções das plataformas existentes e poderá
responder a quarta pergunta.
5.Tipos de projetos
Todo o processo do projeto vai depender do objetivo do mesmo. Sendo assim, antes de começar a
produzir o jogo, é preciso que se pense a respeito da intenção do projeto. Existem dois tipos de projetos:
Aprendizado: é quando uma pessoa ou equipe passa por todas as fases de um projeto, mas sem uma
rigidez formal. O objetivo principal desse tipo de projeto é o aprendizado, é aumentar o conhecimento e a
prática no desenvolvimento de jogos. Aqui, pode-se pular algumas fases, como estudo de mercado e outras.
Comercial: é preciso que se tenha uma estrutura organizacional sólida e investimentos. Aqui todas
as fases do projeto devem ser analisadas cuidadosamente e sempre pensando no mercado e no público-alvo.
Os integrantes da equipe devem ter uma boa experiência no ramo de desenvolvimento de jogos.
Sabendo que esse guia é voltado para iniciantes, a quinta pergunta se torna óbvia, que o projeto será
para aprendizado. Assim, será discutido abaixo como iniciar os estudos no desenvolvimento de games.
Primeiramente, antes até mesmo do início do desenvolvimento, é preciso que se tenha um bom
conhecimento do assunto. Independente do setor (programação, modelagem 3d, etc) que escolher em um
desenvolvimento, é preciso que se estude com calma, assimilando primeiramente assuntos básicos e ir
aumentando o nível aos poucos.
Esse documento não tem como objetivo ensinar tudo a respeito da criação de jogos e sim dar uma
direção. Então, será proposto um roteiro básico:
• Leia um ou mais livros: para iniciantes no desenvolvimento de jogos, Amazon, Submarino, etc. são
ótimos lugares para começar. Além disso, há um grande número de outros bons livros disponíveis na
internet. Leia-os, analisando todos os exemplos e se caso não tenha entendido algo, releia-os.
HORA DA AULA
• Acrescente a sua leitura com tutoriais: além de clarear alguns pontos, também cobrem tópicos não
abordados em livros.
• Peça ajuda aos mais experientes: se não encontrar respostas para algumas perguntas nos livros e
tutorias, procure pessoas experientes no assunto para o ajudar.
Esses passos precisam ser seguidos contínuas vezes e não uma única vez e não basta somente leitura,
é preciso que pratique o que aprendeu. Comece com um jogo simples e vá subindo o nível de forma gradativa.
No início, tente trabalhar sozinho. Não se apresse em montar uma equipe, porque os outros membros
podem não estar tão animados quanto você. Uma vez desenvolvidos alguns jogos, ganha-se experiência e a
contribuição será muito maior a uma futura equipe. Não leia somente livros específicos no setor no qual você
escolheu, pois para se criar um jogo, terá que pesquisar muitos outros assuntos, como por exemplo: gráficos,
inteligência artificial, redes, física, matemática e muitos outros. No caso da programação, alguns cursos, como
Ciência da Computação dão essa visão mais ampla.
Dicas importantes
• Não acumule conhecimento, aplique-o: só saberá ou aprenderá algo, praticando. Faça pequenas
demos de programa, modelagens, desenhos, etc que use coisas que aprendeu. Exercite sempre!
• Jogue muitos jogos: isso lhe dará idéias e ajudará no desenvolvimento de um jogo excelente. E
também será um descanso do trabalho e/ou estudo.
• Ajude os outros: com isso, estará ensinando outras pessoas e ao mesmo tempo, fixando seus
conhecimentos.
• Termine o que comece: não entre na armadilha de pensar que “eu sei que posso terminar este jogo,
mas tenho uma idéia para um jogo melhor, então passarei para esse”. Aprende-se mais quando há
conclusão dos projetos iniciados e servirá como prova que já desenvolveu algum jogo. Para não
ocorrer isso, não tente fazer jogos muito grandes e complexos até que tenha um nível bom de
experiência. Com anos de trabalho duro, saberá que caminho tomar e onde procurar mais
informações para desenvolver jogos melhores.
Bibliografia
ABRAGAMES. A Indústria de Desenvolvimento de Jogos Eletrônicos no Brasil, 2005.
ABRAGAMES. A carreira de Design de Games, 2006.
ASTLE, Dave. Game Programming Beginners Guide, _____.
SANTOS, Christiano. Jogos Eletrônicos na Educacão: Um Estudo da Proposta dos Jogos Estratégicos,
2006.
RAHAL, Fernando. Desenvolvimento de Jogos Eletrônicos, 2006.
GAMEDEV. What Language Do I Use?, ______.

Disponível em: http://www.gamedev.net/reference/design/features/whatlang/
Acessado dia 28/12/2006.
FÓRUM PDJ (Programadores e Desenvolvedores de Jogos).

Seção Iniciantes e Game Design.
E COM VOCÊS...
PDJer Destaque
Entrevistador Christiano Lima Santos

Entrevistado André Kishimoto
Home Page http://www.tupinihon.com
A cada edição vamos trazer uma entrevista com um dos membros da comunidade PDJ.
Nesta edição o escolhido foi André Kishimoto. Membro da atual PDJ desde 28 de Abril de 2003,
possui vários trabalhos publicados nas diversas edições da PDJzine, bem como em nosso portal. Atua
principalmente na área de programação, modelagem 3D e game design e é um dos instrutores da Alpha
Channel, escola especializada em Computação Gráfica. Além disso, escreveu o livro Programação Windows:
C e Win32 API com ênfase em Multimídia, cujos detalhes sobre o mesmo se encontram no link abaixo:
http://www.tupinihon.com/progw32api/index.html
Para maiores informações sobre ele, acesse seu website:

http://www.tupinihon.com/
Bem, sem mais demoras, vamos conversar um pouco com Kishimoto e compreender por que ele foi
o escolhido para esta edição!
PDJ: Bom dia, Kishimoto. Quem convive na PDJ conosco sabe um pouco sobre sua história e
experiência na área, mas mesmo assim vou lhe pedir para que se apresente, já que sempre há novatos caindo
de pára-quedas na área e com certeza saber um pouco dos seus passos irá auxiliá-los a traçarem os seus.
Sendo assim, explique-nos um pouco sobre sua história em desenvolvimento de jogos: quando começou o
interesse, o que o fez perceber a viabilidade da área, quais foram seus esforços para conseguir adentrar nesta
área?
André Kishimoto: Bom dia, pessoal da PDJ. Antes de tudo, agradeço o convite para a entrevista
desta edição. Vamos lá... Meu interesse por jogos, bem, não me lembro detalhadamente como foi, mas me
interessei no momento em que liguei o meu primeiro console. Ver e controlar o Alex Kidd foi fantástico! Na
época eu era muito pequeno, nem sabia escrever e ler direito, mas já tinha, de certa forma, previsto meu
futuro. Só depois de uns 5, 6 anos, com um grande esforço dos meus pais, é que tive acesso a um computador.
Não entendia nada e aprendi a usá-lo na base da tentativa-e-erro. Quando descobri que o MS-DOS tinha um
programinha chamado “Basic”... pára tudo! Eu ficava horas e horas tentando entender como tudo aquilo
funcionava. Foi aí que percebi que podia criar meus próprios programas (e, futuramente, jogos).
Depois, com aqueles modems maravilhosos de 14kbps, comecei a acessar BBS’s e aprendi como
funcionava a linguagem PPL (PCBoard Programming Language). Quando vi o jogo Nibbles (jogo da
cobrinha) em PPL, aí sim as coisas começaram a se encaixar. Comecei a aprender outras linguagens
(Pascal, por exemplo, só consultando o help do Turbo Pascal 7) e tentei algo também na área visual 3D.
Nesta época, me dei melhor com programação e resolvi partir para esta área. A parte visual ficou parada
por um tempo, fiz colégio técnico em Processamento de Dados e depois bacharel em Ciência da Computação.
Antes de entrar na faculdade, já tinha começado a estudar a linguagem C e o funcionamento do
DirectX. Talvez por sempre ter corrido atrás e estudado por conta, não compreendia várias coisas do que
estudava. A faculdade realmente me forneceu a base que precisava para continuar. E foi na faculdade que
conheci outras pessoas interessadas em desenvolvimento de jogos. Formamos uma equipe de
desenvolvimento e a partir de então que tudo ficou mais claro: jogo não é só programação, nem só gráfico ou
diversão. Comecei a pesquisar vários assuntos relacionados à área e continuo a pesquisar. Não falo de
esforços no pretérito, pois ainda tenho muito o que aprender, ensinar e aplicar. Mas, de forma resumida, os
esforços até hoje foram: muito estudo, dedicação, investimento (tempo e dinheiro) e prática.
E COM VOCÊS...
Ah, e, inicialmente, não me preocupava com a viabilidade do negócio. Hoje, meu pensamento
mudou: note que usei a palavra “negócio” para me referir à área.
PDJ: Poderia agora nos falar um pouco sobre as experiências que você já teve na área de jogos e em
áreas correlacionadas, tais como programação, modelagem 3D e animação? Em quais projetos você
participou?
Kishimoto: Na programação, área que mais atuei até o momento, comecei por hobby (como já
explicado), passando a desenvolver sistemas comerciais para pequenas empresas para então focar em
técnicas real-time. Modelagem e animação, apesar de brincar no 3D Studio R4 for DOS em 95, só comecei os
estudos e prática pra valer em 2005. Apesar disso, participei como artista 2D em projetos experimentais que
nunca foram lançados, infelizmente. Falando em projetos não-lançados, a maioria foi pessoal ou com a
equipe da faculdade, os quais tive chance de atuar como programador, designer e/ou artista (visual e
sonoro). Também acabei preparando material didático, aulas e cursos sobre estes assuntos. Meu último
projeto foi como consultor/colaborador do jogo “Cozinheiro das Almas” (“Cook of Souls”) produzido na
ECA-USP e exibido numa exposição do ZKM (Alemanha). Fiquei responsável pela interação (programação),
alguns detalhes técnicos e fechamento/envio do projeto.
PDJ: Uma das principais preocupações de quem acaba de chegar e não sabe nem por onde começar é
quanto a quais as ferramentas a serem adotadas. Quais as ferramentas que você utiliza em seus projetos?
Quais você recomendaria a quem está começando e a quem já está a mais tempo na área? Fale sobre as
ferramentas que você geralmente utiliza nas áreas de programação, modelagem 3D, arte gráfica e game
design.
Kishimoto: Essa resposta vai causar polêmica... mas a ferramenta indispensável para todas essas
áreas, na minha opinião, é o lápis e papel. Sim, isso mesmo – lápis e papel. Quando preciso entender e
resolver um problema de lógica, por exemplo, acho muito mais fácil me afastar um pouco do computador e
buscar a solução no papel. Encontro erros de maneira mais fácil do que ficar vendo código-fonte. Artes, nem
preciso falar... um estudo à mão (ou com fotos... ou melhor, referências!) é sempre bom antes de partir para
o trabalho real.
Mas falando de ferramentas dentro do computador... varia muito. Na parte de programação, o MS-
VC++ é a minha escolha de C/C++. No caso de Java, prefiro usar o Eclipse+JDK. Webgames, apesar de
não me aprofundar muito, nem preciso falar que é o Flash. Na parte visual, uso o Blender para
modelagem/animação, Adobe Photoshop, Painter e tablet Wacom. Se você for partir para o visual, invista
numa Wacom; um excelente investimento que você não se arrependerá! Recentemente comecei a usar um
software chamado GraphicsGale para a criação de pixel art. Em 3D, também estou analisando o
Softimage|XSI e o ZBrush. Ambos são ótimos!
Audacity, Cakewalk, microfones, mesa de som e guitarra para a parte sonora. Não podemos
esquecer também do MS-Office para documentação e planejamento. Uma ferramenta que estou querendo
aprender (já deveria ter aprendido) é o MS-Project.
A engine que estou usando atualmente é o 3D Game Studio. Sei que há muitas opiniões negativas a
respeito deste software, mas eu o estudei melhor, me familiarizei e ele está suprindo minhas necessidades
neste momento. Ainda não tive um tempo suficiente, mas também pretendo aprender o funcionamento da
Torque.
Para não gerar discussões desnecessárias, sempre falo que a melhor ferramenta vai da sua
necessidade e familiaridade. A ferramenta XYZ faz o que você precisa no momento? Ótimo, use-a! Mas todo
mundo fala que a ferramenta ABC é mais profissional e a melhor. Você sabe usá-la? Não precisa no
momento? Não pode adquirir sua licença oficial? Então continue com a outra ferramenta. Lembrando
sempre que ferramentas vão e vem facilmente. Você precisa se adaptar ao que está disponível para você.
Lógico, não dispenso o lápis e papel.
PDJ: Todos os que ultimamente vêm buscando a área e procuram por aprender C têm ouvido de nós
da PDJ a mesma resposta: André Kishimoto escreveu o livro Programação Windows: C e Win32 API com
ênfase em Multimídia, que possui um conteúdo muito bom para quem está procurando por este tipo de
informação na área. Seu livro trata muito bem sobre o estudo de desenvolvimento de aplicações em C para o
ambiente Windows levando-se em consideração a API Win32, algo muito importante para quem anseia
E COM VOCÊS...
programar jogos em DirectX, por exemplo. Gostaria de falar um pouco sobre sua obra? Quem é o seu
público-alvo? Como a pessoa que o adquiriu pode estudá-lo para que tenha um melhor desempenho?
Kishimoto: Tem uma explicação sobre o porquê que escrevi este material na Introdução do e-book.
Mas, resumindo: este tipo de informação é quase nulo em português e muitos alunos, profissionais e/ou
entusiastas da Computação não têm o conhecimento desta (ou qualquer outra) API gráfica. Meu objetivo é de
disponibilizar um material em português e de fácil acesso. E de boa qualidade, espero.
Escrevi tendo em mente que o leitor já saiba programar o básico em linguagem C. Logo, quem sabe
a linguagem pode aproveitar melhor o conteúdo. No entanto, pessoas que programam em VB ou Delphi, por
exemplo, também podem estar utilizando o conhecimento adquirido no e-book, uma vez que explico a API
nativa do Windows. Com algumas mudanças, é possível aplicar tudo usando VB/Delphi. Eu mesmo já criei
programas em Delphi com chamadas às funções da Win32 API. Minha recomendação é estudar e colocar
tudo em prática. Melhorar os exemplos do livro ou criar outros do zero. Quem sabe criar um tópico na PDJ
com sugestões do que programar usando a Win32 API? Mostrar executáveis, screen-shots e disponibilizar
código-fonte para todos estudarem!
PDJ: Ainda falando sobre seu livro, poderia nos explicar melhor o seu conteúdo? O que o aprendiz
irá conhecer em cada parte do mesmo?
Kishimoto: Como o próprio titulo diz, o livro foca no uso de funções multimídia da Api nativa do
Windows. Ou seja, vemos a parte de imagem e áudio. Há também um “bônus” sobre manipulação do registro
do Windows e textos. O que acho interessante nesta API é que o programa final fica extremamente leve
(comparado com programas feitos em VB, Delphi, C++ Builder) e você tem um controle maior sobre sua
aplicação. Mais fácil do que explicar aqui, é ver o sumário e os exemplos (executáveis) que estão disponíveis
no site do livro (link no início da entrevista). Os exemplos são bem simples, servem mais como aprendizado.
Mas é possível fazer muito mais com o que você aprender no livro.
PDJ: Ficamos sabendo (por você mesmo, durante a SBGames2006) que já está trabalhando em
alguns outros livros, um deles sendo da área de Inteligência Artificial (conversas por e-mail para a PDJzine,
neste caso). Qual o seu objetivo com esta obra? Apresentar IA de forma geral ou focada no seu emprego em
um jogo? Quais os assuntos mais abordados e estudados neste seu futuro livro? Há previsão de quando será
publicado?
Kishimoto: Ops... talvez a informação tenha sido passada de maneira errada! Na verdade, meu
próximo livro é meio que uma continuação do primeiro. Isto é, uso a Win32 API para exemplificar técnicas e
algoritmos usados em jogos e Computação Gráfica (nada impede, no entanto, de você usar Allegro, SDL, Qt,
etc.). Inteligência Artificial é um dos assuntos do livro. No capítulo de IA, o leitor irá estudar FSM’s (uma
prévia editada está inclusa nesta edição da PDJzine), movimentação de agentes e algoritmos de busca. Há
capítulos sobre bitmaps e animações, input, física (Newton, AABB, etc.), matemática 3D e Computação
Gráfica 3D. A parte 3D será apresentada usando Win32 API com OpenGL.
Infelizmente, não há previsão de lançamento. Já deveria ter finalizado o conteúdo, mas
compromissos e imprevistos me impediram. Por exemplo, entre 2005 e 2006, produzi quatro apostilas sobre
jogos e lógica (totalizando mais de 300 páginas) para terceiros e tive que deixar o livro em off. No entanto, já
retomei a escrita e, se tudo der certo, em 2007 teremos este livro (que está com cerca de 350 páginas – a
seção 2D toda finalizada e a metade final da 3D em andamento). Como é um projeto pessoal feito nas horas
vagas, vocês sabem que leva um tempo maior para finalizá-lo, ainda mais que crio código-fonte
exemplificando o conteúdo e realizo testes para verificar se há erros nos exemplos. Mas ele será lançado sem
dúvida alguma. Desistir depois de tudo isso seria besteira.
Eu quero compartilhar esse tipo de conhecimento com todos os interessados. E achei no livro uma
forma viável e interessante para isso. Aliás, após este livro, outros virão. Não pretendo parar de criar e
publicar este tipo de material. O Brasil está carente neste setor (e em muitos outros, mas não vamos desviar
do assunto) e espero fazer bem a minha parte.
PDJ: Todos nós estamos sempre intrigados com o quanto você já aprendeu e com suas obras, então
vamos revelar seu segredo a todos: suas fontes de estudos. Quais os livros que você acha imprescindível na
E COM VOCÊS...
formação de um desenvolvedor de jogos em geral? E do programador? E quanto ao modelador 3D? E no caso

do game designer?
Kishimoto: Outra resposta “polêmica”. Digo isso porque sei que a maioria espera que eu indique
determinadas obras, quando na verdade indicarei outras que alguns nunca esperariam ouvir. Para quem leu
meu artigo na PDJzine #2, sabe que não existe um único livro para qualquer área (neste artigo, cito os que
achei mais interessantes até então). Mas o que eu acho imprescindíveis são:
- Oxford Dictionary Advanced Learners, ou qualquer outro dicionário decente da língua inglesa.
Dicionários técnicos também entram aqui. Believe me, you will need it!
- Design of Everyday Things (Donald Norman), recentemente traduzido para o português. É possível
aplicar as explicações do autor em nossos jogos. E ver o mundo com outros olhos.
- Real-Time Rendering, 2nd Edition (Akenine-Möller e Haines), é voltado mais para a programação,
mas recomendo para todos os desenvolvedores (programadores ou não). Do meu ponto de vista, todos
deveriam saber um pouco sobre a parte técnica do real-time. Assim, não veríamos mais artistas criando
modelos de silhueta simples com milhares de polígonos para rodar (travar) em um jogo.
- Better Game Character by Design (Katherine Isbister), psicologia em jogos. Conhecimento
necessário para game designers, artistas, programadores e todos os desenvolvedores que levem a profissão a
sério.
- Animator’s Survival Kit (Richard Williams), a bíblia da animação. Compre-o que você não se
arrependerá.
Bom, na verdade, são muitos os livros que acho indispensáveis. E falar que um livro é bom ou ruim
vai do leitor, tanto do interesse como da situação atual (área, conhecimento, etc.). Por exemplo, conheço
pessoas que acham o livro do Norman dispensável. Quem está iniciando na área e ainda está aprendendo a
programar pode ter essa mesma opinião. Recomendo a lista da PDJzine #2.
PDJ: Além dos livros, que outras fontes de estudos você gostaria de citar?
Kishimoto: artigos, científicos (ACM, IEEE) ou não (Game Developer Magazine, Develop
Magazine, Dr Dobb’s, Computer Graphics World, Devmedia, PDJZine, etc.). Cursos que possam aprimorar
ou acrescentar novos conhecimentos. Vá a congressos e eventos da área! Assista palestras, tutoriais e
aumente sua rede de contatos (não estou falando de Orkut). Talvez seja impressão minha, mas tem muita
gente que nem liga para esses eventos. Tantos brasileiros registrados em sites de gamedev no Brasil e no
mundo, mas cadê a maioria na SBGames, o evento oficial da SBC? Não espere também encontrar tudo
documentado em livros, artigos ou sites... Ou que você aprenda a criar um jogo (comercial ou não, simples
ou complexo) somente assistindo uma palestra! Quebrar a cabeça também é fonte de estudo!
PDJ: Em quais projetos de jogos você está participando atualmente? Quem é a sua equipe? Quais as
principais dificuldades que vocês estão tendo e como estão ultrapassando esses obstáculos?
Kishimoto: Atualmente, além do livro, estou trabalhando em dois jogos independentes. Um jogo é
voltado para o mercado mobile e está sendo desenvolvido por três pessoas (estou encarregado do design e
eventualmente a parte sonora). O outro é um jogo 3D para PC que conta com seis profissionais (arquitetos,
programadores, artistas), na qual estou como level designer, programador (scripts) e uma espécie de
produtor. A equipe inteira é responsável pelo design do jogo.
No final do ano passado, uma outra equipe indie que está se formando me chamou para ajudá-los,
mas estarei apenas como orientador/consultor. Não foi possível me dedicar tanto com este pessoal, mas os
ajudarei como puder.
A maior dificuldade, pelo fato das equipes serem indie, é o tempo disponível para se dedicar ao
projeto. Por exemplo, alguns membros são chefes de família e precisam sustentar esposa e filho. Além do
trabalho do ganha-pão diário, temos outras responsabilidades. Conciliar tudo isso com o projeto (não-
remunerado) é a maior dificuldade. Como estamos superando isso? Não estamos. Ou melhor, temos força de
vontade, determinação e objetivo de terminar o projeto, mesmo que leve um tempo a mais que o esperado ou
que seja necessário realizar modificações.
E COM VOCÊS...
PDJ: Muitas são as suas contribuições na área de modelagem 3D, sendo assim, quais os conselhos
que você gostaria de dar a todos aqueles que estão começando a modelar e já estão enlouquecendo com o Box
Modelling, alguma palavra de encorajamento? Alguma dica?
Kishimoto: Use referências, sempre! Se você acha difícil desenhar uma mão do nada (sem usar sua
própria mão como referência, por exemplo), por que acharia que modelar e animar uma mão do zero seria
mais fácil? Lembre-se que referência também é inspiração!
Apesar de muita gente falar que não é necessário saber desenhar para modelar, o conhecimento em
artes ajuda bastante. Portanto, ao mesmo tempo em que você estuda
modelagem/animação/iluminação/renderização, estude artes. Estude fotografia. Cinema. Tente fazer uma
escultura em argila/massa de modelar enquanto aprende a esculpir no ZBrush. Se na vida real não temos
CTRL+Z, também não conseguimos recuperar o tempo que já passou de nossas vidas. Então, quanto antes
você tiver essas oportunidades, aproveite-as!
PDJ: Uma prática nossa é pedir aos nossos entrevistados que deixem registradas conosco as suas
“regras de ouro”, ou seja, os mandamentos que todo bom desenvolvedor deve seguir, em sua concepção, a fim
de não somente firmar-se no mercado, mas também produzir jogos de alta qualidade. Quais são as “regras de
ouro de Kishimoto”?
Kishimoto: Hum... essa vai ser difícil de responder hein! Mas vamos tentar... “As regras de ouro de
Kishimoto”.
1 – Equipe. Na sua vida profissional (e pessoal), você nunca estará sozinho. Portanto, saiba
trabalhar com outras pessoas, inclusive aquelas bem diferentes de você.
2 – Respeito ao próximo. É resultado do saber trabalhar em equipe. Todo profissional tem que saber
respeitar para ser respeitado.
3 – Saiba escutar. Quem não dá ouvidos aos outros acaba preso no seu próprio mundo e deixa de
progredir. Lógico, você deve filtrar opiniões e comentários (principalmente os não-construtitvos), mas nunca
deixe de ouví-los.
4 – Humildade. Conheci muitas pessoas que perderam oportunidades ou atrapalharam projetos por
não serem humildes. Por melhor que você seja ou tenha destaque entre as pessoas, não pise nos outros.
Humildade acima de tudo!
Nada contra programadores (afinal, ainda sou um), mas nesta área percebi muito este tipo de
problema. Ser programador não é ser Deus! Já vi gente xingando dono de empresa por não saber programar
e falando que era muito mais competente que o dono. Mas se não fosse este dono supostamente incompetente,
o programador não teria emprego. Numa equipe ou empresa, todos são importantes, até o faxineiro!
5 – União entre programadores, artistas, designers, marketing. E todas as outras áreas. Quem
nunca presenciou rixas entre os vários departamentos de uma desenvolvedora de jogos? Procure aprender
um pouco de cada área, além da sua especialidade, para ao menos compreender a importância de todos. Não
seja bitolado!
6 – Auto-didatismo. Nem preciso explicar... Ou você acha que sempre vai ter alguém que pegará
você pelas mãos e o guiará? Se você pensa assim, comece a procurar outra área... Ou melhor, comece a
mudar de atitude.
7 – Flexibilidade e organização. É o que o mercado pede. É o que o profissional deve ter.
Creio que essas são as minhas regras de ouro. Porque de nada adianta você ser o máximo na sua
área se você for um bitolado ignorante que se isola na frente do computador e não sabe se comunicar com as
pessoas ao seu redor.
PDJ: Algum conselho mais que gostaria de dar a todos os que estão acompanhando nossa conversa
neste momento?
Kishimoto: Um conselho final pra entrevista? Que tal revermos alguns de nossos conceitos? São
tópicos comuns que vejo na Internet e ouço em conversas... Vou terminar todas as frases com “reveja seus
conceitos” e não vou comentar sobre tais frases... deixo para o leitor pensar no assunto.
E COM VOCÊS...
- Você entra em sites e fóruns atrás daquela receita de bolo mágica sobre como criar seu próprio
Ragnarök? Reveja seus conceitos.
- Você acabou de aprender a programar e já quer criar seu jogo triple-A? Reveja seus conceitos.
- Você já está confiante em uma linguagem de programação e já quer criar seu jogo triple-A?
Reveja seus conceitos.
- Você acha que criar um jogo é como jogar um jogo? Reveja seus conceitos.
- Você acha que programação é tudo que um jogo precisa? Reveja seus conceitos.
- Você acha que visual é tudo em um jogo? Reveja seus conceitos.
- Você acha que criar um Pong como seu primeiro jogo é perda de tempo e quer partir para algo
mais difícil? Reveja seus conceitos.
- Quer programar um jogo ou quer programar uma engine? Reveja seus conceitos.
- R$1.000,00. Muito dinheiro para se investir na criação de um jogo? Reveja seus conceitos.
- R$1.000.000,00. Muito dinheiro para se investir na criação de um jogo? Reveja seus conceitos.
- Projeto concluído. Jogo em mãos. Acabou? Reveja seus conceitos.
- O 2D morreu? Reveja seus conceitos.
- Você não considera webgames como jogos? Reveja seus conceitos.
- Jogos são coisas de criança? Reveja seus conceitos.
- Jogos não ensinam nada? Reveja seus conceitos.
- Jogos de última geração são os únicos jogos que vendem? Reveja seus conceitos.
- Mulheres e pessoas de mais idade não jogam? Reveja seus conceitos.
- Inglês pra quê? Reveja seus conceitos.
- Matemática pra quê? Reveja seus conceitos.
- Física pra quê? Reveja seus conceitos.
- Psicologia pra quê? Reveja seus conceitos.
- Sociologia pra quê? Reveja seus conceitos.
- Marketing pra quê? Reveja seus conceitos.
- Contratos pra quê? Reveja seus conceitos.
Enfim... são muitos os assuntos que poderia listar aqui... Mas acho que já está bom pra começarmos,
não?
Bem, Kishimoto, tenho certeza de que posso agradecer por todos da PDJ por sua participação e
contribuição com a PDJ por todos esses anos e torço para que possamos estar juntos nessa empreitada durante
todo o ano de 2007 e nos anos seguintes também. Um abraço, amigo, e até mais!
Um forte abraço, muita sorte, jogos e realizações para todos nós!

E COM VOCÊS...
A pedidos do entrevistado, esta entrevista está publicada aqui em duas versões: em português e em inglês.
Segue abaixo a versão em português e, a seguir, a versão em inglês.
Entrevista com Jon Shiring
Entrevistador e Paulo Marcos Figueiredo de Andrade

Tradutor
Entrevistado Jon Shiring
• Jon, fale-nos um pouco sobre você. Quem é Jon Shiring ?
Olá!. Deixe eu começar logo com algumas informações básicas: Tenho 28 anos, vivo em Los
Angeles, sou programador na Infinity Ward , e não sou casado. Agora, um pouco sobre meu passado: me
graduei pela Virginia Tech em 2000, com o título de Bacharel em Ciências da Computação. Naquela época,
os negócios .com (bolha da web) eram enormes, logo, eu trabalhei com isso durante cerca de um ano. Depois
eu consegui um trabalho na S2, onde eu trabalhava remotamente, na Virgínia. Então, eles (S2) me
convenceram de me mudar para Califórnia, onde nós terminamos Savage . Desde então, venho trabalhando
para Nanco e agora, Infinity Ward, lançando Call of Duty 2 para PC e XBOX 360 no outono de 2005.
Telas do jogo Savage
• Quando e porque você decidiu aprender a programar ?
No passado, quando meu mundo era nada mais que LEGO, Capsella e outros brinquedos deste tipo,
um amigo me mostrou King's Quest 3, em 1988. Quando eu vi o jogo, eu implorei para meus pais comprarem
um computador. Quando eles cederam eu entrei no mundo dos Jogos da Sierra e sonhava em escrever o meu
próprio.
Assim que consegui um modem, fiquei fascinado por ele e comecei a fazer mods para um programa
de BBS chamado WWIV. Isso foi legal pois eu pode trabalhar em um código funcional, logo, eu pude fazer
E COM VOCÊS...
testes e ter certeza que não tinha estragado nada, e era fácil fazer pequenas mudanças e ver a diferença visual.
É uma boa forma de aprender.
• Qual foi a primeira linguagem de programação que você aprendeu?
Eu comecei a estudar Pascal e escrever programas com a linguagem quando tinha cerca de 11 anos.
Eventualmente eu pequei C e o resto é história. C é ainda minha linguagem preferida para programar.
• Quando você decidiu trabalhar para a indústria de jogos ? Foi algo que você planejou durante
sua graduação ou antes ?
Quando eu me graduei no College (segundo grau no Brasil), eu não sonhava que eu poderia
conseguir um emprego na Indústria de Jogos. Parecia que ninguém sabia como entrar nesta indústria, logo,
muitas pessoas competentes nunca tentam (ou não sabem como). Hoje em dia é um pouco melhor que a
alguns anos atrás, uma vez que todos os estúdios tem várias ofertas de trabalho que eles estão tentando
preencher.
• Fale-me sobre o primeiro jogo que você criou.
Savage é realmente o primeiro jogo que eu criei. Ele é realmente uma interessante mistura de
Estratégia em Tempo Real (RTS) e Jogo de Tiro em primeira/terceira pessoa (1st/3rd Person Shooter). Existe
um comandante em cada time e o resto do time são jogadores de verdade. Nós arriscamos e colocamos
algumas idéias bem novas no jogo.
Nos eramos basicamente uma sala com caras, todos falando sobre como nós gostaríamos que o jogo
fosse, e então, nós fomos lá e fizemos. Nós tinhamos um proprietário que cuidava de tudo, porém, fora isso,
nós criamos nossa própria distribuidora e não tinhamos ninguém a quem responder. Foi muito diferente do
que a maioria dos desenvolvedores experimentam na indústria.
• Você começou trabalhando como um Programador de Jogos e Designer para a S2 Games.

Como você conseguiu este trabalho ?
Eu tenho um amigo que faz arte 3D e me falou que tinha conseguido um trabalho em uma empresa
de jogos chamada S2 Games. Quando eu perguntei se eles precisavam de um programador com nenhuma
experiência em Games, aconteceu que eles precisavam. Assim, eu comecei trabalhando da minha casa, na
Virgínia. Esta foi uma transição bem louca, saindo do mercado .com que eu odiava, para me tornar um
desenvolvedor de jogos que trabalhava de casa em um jogo realmente entusiasmante. Eu estava tão feliz em
conseguir o emprego e eu adorei a galera da S2.
• Por que S2 Games decidiu desenvolver sua própria Engine de Jogos (Silverback Engine), ao
invés de usar uma engine comercial ?
Bem, para um time de jovens e energéticos programadores, não parecia ser tão difícil assim. Assim,
nós escrevemos nossa própria, e eu estou realmente feliz por ter tido esta experiência. O Programador Líder,
Sam MacGrath, é um programador incrível que sempre criava ótimo código. Hoje em dia ele é o Programador
Líder em Project Offset e ele continua escrevendo engines realmente impressionantes. Trabalhar com ele me
ensinou muito.
• Como foi a experiência em trabalhar para S2 Games ? Muitas horas trabalhando até tarde ?
S2 foi uma experiência incrível. Todo dia nós discutíamos sobre algum aspecto do jogo, e realmente
fritávamos uns aos outros até que, eventualmente, nós chegávamos a um consenso do que funcionaria melhor.
Algumas vezes, nós apenas concordávamos, implementávamos e via como funcionava.
Nós todos trabalhamos longas horas - Sam MacGrath vinha trabalhar próximo da hora do jantar e ia
para casa lá para as 10 da manhã por um tempo, e um artista, que trabalhava em horário oposto passou dias
sem ver ele. Era divertido chegar no trabalho e ver todas as mudanças fechadas entre 4 e 7 da manhã.
E COM VOCÊS...
• Por que você decidiu ir para a Namco Hometek?
Quando Savage foi lançado - o que foi um feito fantástico para um time tão pequeno - e acabou tendo
sucesso online, eu senti que tínhamos derrotado obstáculos inacreditáveis. Pequena empresa independente de
jogos, com nenhum distribuidor real simplesmente não tem sucesso. E durante os 3 anos que eu trabalhei lá
foi uma montanha russa de emoções para mim - eu estava escrevendo para websites e tentando conseguir que
eles escrevessem artigos sobre Savage, postando em fórums - tudo o que eu pudesse pensar para tornar o jogo
conhecido. A idéia de passar por isso de novo e tentar superar as barreiras de novo era desanimadora. Assim,
eu decidi que deveria olhar o que tinha por ai - além disso, existiam outros jogos interessantes nos quais eu
poderia trabalhar !
Sabendo que Savage perdeu muito dinheiro foi uma grande decepção para mim, e eu estava
determinado a fazer dinheiro para minha empresa no meu próximo jogo, por que eu amo o meu trabalho e eu
coloco muita energia nele. Se você não está lançando jogos que fazem dinheiro, você não consegue se manter
fazendo jogos por muito tempo, e eu quero ficar na indústria de jogos por muito tempo.
Eu fui entrevistado em várias empresas e existiam realmente poucas grandes empresas para as quais
eu realmente gostaria de trabalhar. Eu não tive tanta sorte com alguns dos grandes nomes, mas eu estava
tendo alguma sorte. O dia em que fui entrevistado na Namco Hometek, eles na verdade me ligaram para me
fazer uma oferta enquanto eu dirigia para casa. Isso realmente significou muito para mim e eu gostei muito do
time, logo, eu aceitei. Falar para o pessoal da S2 foi duro e foi um choque total para eles. Nós ainda nos
falamos, e entre Savage 2 e Project Offset, é ótimo ver que todos envolvidos continuam fazendo jogos
maravilhosos.
• O quão diferente é trabalhar para empresas como Namco e Infinity Ward, quando comparado
com S2 Games
A transição da S2 para a Namco Hometek foi grande para mim. Namco Hometek faz pesquisas com
clientes, realiza testes focados e todas estas coisas. Eu aprendi lá o que faz com que jogos se tornem uma
porcaria. Departamentos de marketing dirigindo o design de jogos, jogos modificados para atingir um
determinado valor de orçamento, e existem camadas de burocracia que simplesmente parecem desnecessárias.
Por outro lado, eles lançam jogos nos prazos e os jogos deles fazem dinheiro.
Infelizmente, depois de 6 meses na Namco Hometek, percebi que suas questões gerenciais eram
muito maiores do que qualquer coisa que eu pudesse afetar e, de novo, que decidi sair. Com um currículo
mais impressionável, acreditei que tendo trabalhado em um jogo de console na Namco Hometek fosse o
suficiente para chamar a atenção da Infinity Ward (uma vez que eu já estava fissurado por Call of Duty
quando Savage foi lançado), assim sendo eu me candidatei apenas para eles. Por sorte, eu fui contratado e me
mudei para Los Angeles para trabalhar no meu jogo favorito. Infelizmente, alguns meses depois, Namco
Hometek despediu o resto do time com o qual eu tinha trabalhado lá e todos os meus companheiros de
trabalho tiveram que se virar para achar novos empregos.
Infinity Ward é o que eu esperava em termos de como grandes companhias devessem ser. A gerência
é ótima. Temos grande orgulho dos nossos próprios jogos bem como o grande número de boas notas nas
análises que recebemos dos nossos jogos, e o trabalho é sempre um desafio e posso fazer de fato diferença.
Pessoalmente eu amo os jogos que fazemos e isto é extremamente satisfatório.
E COM VOCÊS...
Imagens de Call of Duty 2
• Como é o seu dia a dia de trabalho na Infinity Ward?
Vou trabalhar por volta das 10:00 da manhã. Verifico o meu email e qualquer bug que tenha sido
reportado. Temos orgulho de termos um baixo índice de bugs, portanto bugs são uma prioridade para mim. A
partir daí eu somente programo e tento consertar qualquer emergência que apareça durante o dia. Em alguns
dias tudo corre bem e realmente posso pegar pesado na programação; outros dias, bem, eu tenho que corrigir
vários problemas.
Eu diria que a maior parte de noites que vou para casa entre 7:00 e 8:00 da noite (a maior parte da
companhia vai para casa em volta das 7:00 pm). Em algumas noites eu acabo trabalhando até um pouco mais
tarde. Realmente nunca trabalho nos fins de semana. Temos um ambiente de trabalho excepcionalmente
saudável e a nossa gerência sabe que jornadas longas só conseguirão desgastar boas pessoas. Uma vez que
você trabalha na indústria por um tempo, você percebe que longas horas não são um efeito colateral da
indústria de jogos, mas sim, um efeito colateral de decisões gerenciais. Sim, há alguns períodos de trabalho
pesado, mas a maior parte de dias eu vou para casa, como o jantar, vejo a minha namorada e tenho uma vida
(bem, para ser franco, eu jogo jogos e saio com meus amigos do trabalho depois do trabalho para que
possamos falar mais sobre jogos). Mas planejamos as coisas e reavaliamos os recursos do jogo para não
furarmos os prazos finais e não desperdiçamos o tempo em recursos que não ajudarão o produto final. O
resultado final é eu adoro ir trabalhar todos os dias e mantenho minha sanidade.
• Você vem trabalhando muito na parte multijogador dos jogos. Quais são os grandes desafios na
programação multijogador (multiplayer)?
Cada seção do jogo é cheia de desafios. A programação multijogador é complicada uma vez que
você quase nunca é capaz de bolar uma forma fácil de reproduzir de forma confiável um bug que envolva
muita gente jogando o jogo em conjunto e fazendo todas as coisas loucas que fazem durante uma partida,
portanto, você tem de aprender a corrigir bugs que você não é capaz de reproduzir. Adicionalmente, você tem
de tentar constantemente descobrir como enviar o menor número de dados pela rede. Além disso, você
sempre está trabalhando para ocultar a latência e fazer com que o jogo responda rapidamente às ações. O
montante do trabalho necessário para fazer que você não perceba que está fazendo uma viagem de 250ms de
ida e volta a um servidor é grande. Portanto, muito esforço é gasto em coisas que as pessoas nunca notarão.
Em cima disto há todas as características padrão de jogabilidade que você quer em um jogo de multijogador.
• Programar para o XBOX 360 é muito diferente de programar para o PC?
É diferente de alguns modos, e muito semelhante em outros. A maior parte das diferenças têm mais a
ver com o ambiente de como você joga um jogo em um console. Por exemplo, em um console as pessoas
querem que matchmaking seja uma experiência social, que seja bem rápido, e que ajude a tomar boas decisões
sobre a que partida on-line se juntar. PC gamers tendem a querer mais controle – eles preferem selecionar a
que jogo vão juntar-se. Outro exemplo fácil está em como as pessoas se comunicam - a diferença entre
conversa de texto e voz é uma grande diferença sobre o ponto de vista de programação. Dados de voz são
muito maiores que texto e muito menos tolerantes a latência.
• O salário médio de um programador de jogos é maior do que o salário médio de outros tipos de
trabalho em Tecnologia da Informação?
EU não tenho bastante informação para responder a esta pergunta. Um recurso realmente bom para
isto são as pesquisas anuais de salário que revistas de desenvolvimento de jogos publicam.
• Se você tivesse um irmão (ou irmã) mais novo, que quisesse trabalhar na indústria de jogos, o
que você aconselharia a ele fazer (estudar, aprender, etc) para adquirir um emprego rápido na
E COM VOCÊS...
indústria de jogos?
Ok, então o objetivo é adquirir um emprego tão rápido quanto possível? Neste caso, creio que uma
educação formal não é realmente uma opção. Eu recomendaria definitivamente obter uma graduação se você
não está com tanta pressa. Você descobrirá que a maior parte dos programadores têm graduação em Ciências
da Computação (CS degree), e a maior parte dos artistas com os que trabalhei são graduados também.
Designers não são tão exigidos em graduação, mas eu definitivamente acredito que um terceiro grau vale a
pena se ter, não importa em quê.
Primeiro, uma nota. Muitos coders têm a mentalidade "de tenho que ser tão bom quanto Carmack."
Francamente, isto não é verdade. Há centenas de posições em companhias de jogos atualmente, e a habilidade
mais importante é que você escreve o código sólido e resolve problemas bem. Você não tem de inventar um
novo modo de renderizar ou revolucionar o mundo da IA para conseguir um emprego, você somente tem de
mostrar que você pode escrever código para eles que não quebrará as coisas e que irá melhorar o jogo deles.
Ok, na caça de emprego. Para programadores, eu lhes diria para visar companhias específicas em que
eles querem trabalhar e para trabalhar em mods das engines de jogos existentes que são pertinentes àquelas
companhias. Se você puder mostrar a uma companhia que você é já familiar com sua engine (até uma versão
mais velha) e você escreve o código sólido, as companhias notarão.
Ter algo para mostrar é muito importante, e geralmente eu aconselharia contra escrever a sua própria
Engine. Quando você escreve a sua própria engien você tem de reinventar a roda um bocado e, em vez de
impressionar alguém com o seu novo gameplay assombroso, você está tentando impressioná-los com o seu
código de skinning muito básico (que eles provavelmente já têm algo mais avançado). Os empregadores são
compreensivelmente mais interessados em pessoas que trabalham em coisas que eles ainda não têm.
Mods estão bons também porque eles tem maior probabilidade de se parecer com um produto final, e
isto é também muito importante para companhias de jogos. Qualidade realmente importa.
Para artistas e animadores penso que é de fato mais fácil. Somente trabalhe em um grande portifólio -
a qualidade é mais importante do que a quantidade - e distribua-o. Se for de informação pública, saiba que
programas 3D eles usam (Max ou Maya) e se você for familiarizado com eles, mencione. Muitas companhias
de jogos têm estágios disponíveis, assim, mesmo que você não seja perito, você ainda pode conseguir que eles
te mostrem o que você não aprendeu ainda.
Para Designers, às vezes pode ser um grande desafio conseguir um emprego de designer. Um de
meus amigos teve que construir um script de um nível inteiro um único jogador para conseguir um emprego
de designer em uma companhia, e ele passou aproximadamente um mês trabalhando nele todo dia. Depende
de como a companhia trabalha - algumas companhias de jogos estão ainda nos dias de design de lápis e papel,
alguns exigem que seus designers modelem e texturizem, e algumas (como a Infinity Ward) gostariam que
designers sejam capazes de programas em script.
• O desenvolvimento de um jogo Indie (independente) é algo que pode ajudar a adquirir um

emprego em Estúdios de Jogos?
Definitivamente ter algo para mostrar é uma enorme vantagem. Tendo lançado um jogo, até um jogo
indy que nunca teve um publisher de verdade, mas que teve centenas de downloads é impressionante em si
próprio. Mas se você de fato consegue "terminar" um jogo e tê-lo em um estado apresentável, isto é mais do
que bom para a maior parte de empregadores.
• Qual é a sua opinião sobre engines de jogos enfocados no desenvolvedor independente, como a
Torque e o 3DGame Estúdio? Aprender a desenvolver um jogo nestes motores pode ajudar a
conseguir um emprego na indústria de jogos?
E COM VOCÊS...
Companhias de jogos são bastante familiarizadas com motores comerciais, portanto é mais fácil para
nós perceber que trabalho você fez. Se você fizer um mod para a Toque ou outro motor com o qual não
estamos muito familiarizados, é mais difícil perceber exatamente o que você fez e o que já estava lá. Por essa
razão, eu recomendaria contra estes motores se o seu objetivo é adquirir um emprego na indústria (embora eu
tenha certeza eles são motores muito bons).
Se a sua área do interesse está no núcleo de um motor, você poderia querer ver algo como Quake 3 que é
disponível para download sob a licença GPL. Se você está mais para gameplay ou IA, você pode fazer um
mod para Half Life 2 ou a Unreal Engine sem precisar mexer no código do núcleo da engine. Mas se nenhuma
destas opções lhe agrada, fazer algo em motores para desenvolvedores independentes não é ruim. Como eu
disse, ter algo polido e pronto para mostrar é a coisa mais importante que posso recomendar.
• Qual é a sua opinião sobre o XNA Game Studio Express, a ferramenta de desenvolvimento de
jogos gratuito de Microsoft?
Experimentei-a recentemente para ver como a programção C# funcionaria para jogos.

Definitivamente não passei muito tempo com ela ainda, mas tenho sensações difusas em relação a C#. Poucas
companhias de jogos estão procurando atualmente alguém que é um perito em C# , logo, esta parte não é de
grande ajuda (talvez isso mude, quem sabe). Penso que fazer pequenos jogos onde o divertimento é mais
importante do que a tecnologia é uma mentalidade realmente boa, portanto aprecio coisas como XNA e gente
iniciante que faz pequenos jogos do tipo Live Arcade.
Para os desenvolvedores atualmente iniciantes, que desejam fazer jogos, eu acho fantástico. O bonus
que você pode mostrar por ai um jogo tipo Live Arcade quase completo para Microsoft é realmente fantástico.
• Você acredita que os video games da próxima geração (depois do XBOX360 e PS3) serão
máquinas de rede apenas, de forma que os jogos serão baixados pela internet ao invés de
comprados em lojas ?
Agora mesmo estamos na etapa de tentar apenas conseguir que as pessoas liguem seus consoles à
rede e penso que há uma enorme gap entre a multidão que está pronta para comprar os seus jogos digitalmente
e a multidão que não tem nenhuma idéia do por quê eles gostariam de fazer isso. MP3 começou ficar
realmente popular na rede a partir de 1997, mais ou menos, e até hoje as vendas de CD são muito maiores que
vendas do iTunes (aproximadamente uma década depois). Considerando que os jogos são muito maiores que
um álbum de CD em MP3, eu diria que ainda temos um longo tempo até o mercado estar preparado para um
mundo de jogos totalmente em download.
Assumindo que os números de banda larga continuem ficando drasticamente melhores no mundo
todo, conseguir que as pessoas conectem seus consoles à net será uma batalha. De acordo com os números da
Microsoft, cerca de 60% dos usuários do XBOX360 já conectaram seus consoles à rede (o que eles festejam
como uma grande conquista). Porém, olhe para o outro lado da moeda – Se pelo menos 40% dos jogadores
hardcore que compraram o XBOX 360 logo no lançamento nunca ligaram seus consoles em rede, estamos
falando de uma grande quantidade de vendas perdidas. Além disso, 60% não nos dá informação o suficiente
sobre se as pessoas voltaram ou não a usar seus consoles em rede.
Assuming broadband numbers continue to get drastically better worldwide, getting people to hook
their console up to the network is an ongoing battle. According to Microsoft's numbers, around 60% of 360
owners have ever connected their consoles to the network (which they should be commended on, that's quite
an accomplishment). But look at the flip side - if at least 40% of the hardcore early adopters have never even
plugged in their console to the net, you're talking about a lot of sales to walk away from. Plus that 60%
doesn't give us enough information about people who plugged it in once and never again. Ao todo, você está
falando sobre muitas vendas perdidas considerando o mercado atual. Talvez o mundo mude drasticamente nos
próximos 5 anos no que diz respeito a redes de banda larga para residências, mas não sou muito otimista.
• Você ainda tem tempo para jogar jogos? Quais são os seus jogos favoritos?
E COM VOCÊS...
Absolutamente. Tento olhar pelo menos um pouco de cada jogo principal que sai. A Infinity Ward
compra cópias da maioria dos jogos que saem, e nos reunimos em volta e olhamos alguém jogar um pouco se
o jogo estiver fazendo algo novo e interessante. Quanto a o que estou jogando, acabei de terminar Titan
Quest, eu jogo multiplayer Guitar Hero com amigos, tento um pouco de Dead Rising and Chromehounds, e
agora estou jogando Saints Row e gostando um bocado, e também me interessando por Company of Heroess.
Também jogo no meu DS – atualmente Brain Training e Fenix Wright. Sempre estou jogando algo, quando
deixo de jogar um jogo há uma dor aguda no meu lado que me diz tenho de encontrar que um novo jogo para
jogar.
Jon Shiring curtindo suas férias

E COM VOCÊS...
Interview with Jon Shiring
• Jon, tell me about yourself. Who is Jon Shiring ?
Hello! Let's get some basics out of the way: I'm 28, I live in Los Angeles, I'm a programmer at
Infinity Ward, and I'm not married. Now for some back story: I graduated from Virginia Tech in 2000 with a
Bachelor of Science degree in Computer Science. At the time, the dot com craze was huge, so I did that for
about a year. After that I got a job at S2 where I was working remotely from Virginia. Then they convinced
me to move out to California where we finished Savage. Since then I've worked for Namco and now Infinity
Ward, shipping Call of Duty 2 for PC and Xbox 360 in the fall of 2005.
Screenshots of game Savage
• When and why you decided to learn to program ?
Back when my world was nothing but LEGOs, Capsella, and other such toys, my friend showed me
King's Quest 3 back in 1988. When I saw that I begged my parents to buy a computer. When they caved I
got into Sierra games and dreamed of writing my own.
Once I got a modem, I was fascinated by that and started doing mods for a BBS software called
WWIV. That was nice because I got to work on a functional codebase, so I could do tests to make sure I
hadn't broken anything, and it was easy to do small changes and see a visual difference. It was a nice way to
learn.
• What was the first programming language you learned ?
I started learning Pascal when I was around 11 and writing programs in that. Eventually I picked up
C and the rest is history. C is still my preferred language to program in.
• When you decided to work in the game industry ? Was It something that you have planned
during your graduation or before?
E COM VOCÊS...
When I graduated from college I never dreamed that I could get a job in the game industry. It seems
like nobody knows how to get into the industry so a lot of good people never try (or don't know how to).
These days it's a bit better than a few years ago, since all studios have many job openings they are trying to
fill.
• Tell me about the first game you created.
Savage was really the first game I made. It was a really neat mix of Real Time Strategy and a 1st/3rd
Person Shooter. There was a commander on each team and the rest of the team were actual players. We
really took a lot of chances and came up with some really new ideas in the game.
We were basically a room of guys all talking about what we wanted the game to be like and then
we'd go and do it. We had an owner that we had to run everything by, but other than that we created our own
publisher and had no one else to answer to. It was very different from what most developers experience in the
industry.
• You started working as a Game Programmer and Designer for S2 Games. How did you get a
job in S2 Games ?
I had a friend who did 3d art and he told me he had gotten a job at a game company called S2
Games. When I asked if they needed a programmer with no game experience, it turned out they did. So I
started working from my house in Virginia. That was a pretty crazy transition, going from a dot com that I
hated to being a game programmer who works from home on a really exciting game. I was so happy to have
the job, and I loved the gang at S2.
• Why S2 Games decided to develop their own Game Engine (Silverback Engine), instead of
using a commercial engine?
Well, to a team of young energetic coders it doesn't seem like it should be too hard. So we wrote our
own, and I'm definitely glad I got to have that experience. The lead programmer, Sam McGrath, is an
amazing programmer who just cranked out great code. These days he's the lead programmer on Project
Offset and he's continuing to write really impressive engines. Working with him taught me a lot.
• How was the experience of working for S2 Games ? Many late hours work ?
S2 was just an amazing experience. Every day we'd argue about what some aspect of the game, and
really grill each other and eventually we'd have a consensus of what would work best. Sometimes we'd just
agree to go implement it and we'd see how it plays.
We all worked odd hours - Sam McGrath came into work around dinner time and went home around
10am for awhile, and one artist who worked opposite hours went days without seeing him. It was funny to
come into work and see all these changes checked in at 4-7am.
• Why you decided to move to Namco Hometek ?
When Savage shipped - which itself was an amazing feat for such a small team - and went on to have
success online, I felt like we had beaten unbelievable odds. Small indy game companies with no real
publisher just don't succeed. And the whole 3 years I worked there was a constant rollercoaster emotionally
for me - I was emailing websites and trying to get them to write articles about Savage, posting on forums -
everything I could think of to get the game out there. The prospect of going through that again and trying to
beat the odds a second time was daunting. So I decided I should see what else was out there - besides, there
were other interesting games that I could work on!
Knowing that Savage lost a lot of money was a real disappointment for me, and I was determined to
make my company money on my next game, because I love my job and I put a lot of energy into my work. If
E COM VOCÊS...
you're not shipping games that make money, you don't get to keep making games for long, and I want to stay
in games for a long time.
I interviewed at a number of companies, and there were definitely a few big companies that I really
wanted to work for. I didn't have as much luck with some of the bigger names, but I was having some luck.
The day I interviewed at Namco Hometek they actually called me while I was driving home to make me an
offer. That really meant a lot to me and I liked the team so I accepted. Telling the guys at S2 was tough and
it was a total shock the guys. We still talk, and between Savage 2 and Project Offset it's great to see that
everyone involved is still doing amazing games.
• How different is working for companies like Namco and Infinity Ward, compared to S2
Games?
The transition from S2 to Namco Hometek was big for me. Namco Hometek did customer surveys
and focus testing and all the things I had been taught were what makes games turn out to be crap. Marketing
departments steered game design, games were changed to meet a certain budget number, and there were
layers of bureaucracy there that just seemed unnecessary. But on the other hand, they shipped games reliably
and their gamesmade money.
Unfortunately, after 6 months at Namco Hometek I realized that theiranagement issues were much
bigger than anything I could affect andagain I decided to leave. With my more impressive resume, I hoped
that having worked on a console game at Namco Hometek might be enough to get the attention of Infinity
Ward (since I was hooked on Call of Duty when
Savage came out) so I applied only to them. Luckily enough, I was hired and moved down to LA to
work on my favorite game. Sadly, a few months later Namco Hometek laid off the rest of the team that I had
worked on there and all my old coworkers had to scramble to try to find new jobs.
Infinity Ward is what I hoped big game companies would be like. Management is great. We take
great pride in our games themselves as well as the review scores that we get, and work is always a challenge
and I can actually make a difference. I personally love the games that we make and that is extremely
satisfying.
Screenshots of Call of Duty 2
• How is your average day of work in Infinity Ward ?
I get to work between around 10:00am. I check my email and any bugs that were reported. We take
pride in having a very low bug count, so bugs are a major priority for me. Then I just code and try to fix any
emergencies that come up during the day. Some days nothing breaks and I can really crank through code;
other days, well, I get to fix a lot of problems.
I'd say most nights I go home at 7 or 8pm (most of the company goes home around 7pm). Some
nights I'll work a bit later. I really never work on weekends. We have an unusually sane work environment,
and our management realizes that forced long hours will just burn good people out. Once you've worked in
E COM VOCÊS...
the industry for awhile, you realize that long hours aren't a side effect of the game industry, it's a side effect of
management's decisions. Yes, there are some crunch periods, but most days I go home and eat dinner and see
my girlfriend and have a life (well, to be fair, I play games and hang out with my coworkers after work so we
can talk more about games). But we schedule things out and re-evaluate our features so we don't miss our
deadlines and we don't waste time on features that won't help the end product. The end result is I love going
to work every day and I get to keep my sanity.
• You have been working a lot in the multiplayer part of the games. What are the big challenges
in multiplayer programming ?
Every section of the game is full of challenges. Multiplayer programming is tricky in that you're
almost never going to be able to figure out an easy way to reliably reproduce a bug that involves lots of
people playing a game together all doing crazy things, so you need to learn to fix bugs that you can't
reproduce yourself. Additionally, you need to constantly try to figure out how to send less data over the
network. Plus you're always working to hide latency and make the game feel really responsive. The amount
of work necessary to make it feel like you're not doing a 250ms round trip to a server is big. So a lot of the
effort gets spent on things that people will never notice. On top of that there are all the standard gameplay
features you want in a multiplayer game.
• Programming for the XBOX 360 is very different from programming for the PC ?
It's different in some ways, and very similar in others. Most of the differences have more to do with
the environment of how you play a console game. For example, on a console people want matchmaking to be
a social experience and to be very fast and make good decisions about what game to join. PC gamers tend to
want more control - they would rather choose which game to join. Another easy example is in how people
communicate - the difference between text chat and voice is a pretty major difference from a code
perspective. Voice data is much larger than text and is less tolerant of latency.
• Is the average salary of a game programmer bigger than the average salary of other kinds of jobs in
Information Technology ?
I don't think I have enough information to answer that question. A really good resource for that is
the annual game salary survey which Game Developer magazine publishes.
• If you had a young brother (or sister) that wants to work in the game industry too, what you
would suggest him/her to do (or study, or learn) in order to get a job as fast as possible in the
game industry?
Okay, so the goal is to get a job as fast as possible? In that case, it sounds like formal education isn't
really an option. I would definitely recommend getting a degree if you're not in such a rush. You'll find most
programmers have a CS degree, and most of the artists I've worked with have degrees as well. Designers
aren't as degree heavy, but I definitely think that a college degree is worth getting regardless of what you
major in.
First, a note. Many coders have the mentality of "I need to be as good as Carmack." Frankly, this is
just not true. There are hundreds ofopen positions at game companies these days, and the most important skill
is that you write solid code and solve problems well. You don't need to invent a new way of rendering or
revolutionize the world of AI to get a job, you just need to show that you can write code for them that won't
break things and will improve their game.
Okay, on to the job hunt. For programmers, I would tell them to target specific companies that they
want to work for and then to work on mods for existing game engines that are pertinent to those companies.
If you can show a company that you're already familiar with their engine (even an older version of it) and
you write solid code, companies will notice.
E COM VOCÊS...
Having something to show is very important, and generally I would advise against writing your own
engine. When you write your own engine you have to reinvent the wheel quite a bit, and rather than wowing
someone with your amazing new gameplay, you're trying to impress them with your very basic skinning code
(which they hopefully have something more advanced than already). Employers are understandably more
interested in people who work on things they don't already have.
Mods are also good because they are more likely to feel like a shipped product, and that is also very
important to game companies. Polish really matters.
For artists and animators I think it's actually easier. Just work on a great portfolio - quality is more
important than quantity - and send it out. If it's public information, be aware of what packages they use (Max
or Maya) and if you're familiar with them, mention it in your application. Many game companies have
internships available, so even if you're not an expert yet you can get them to show you what you haven't
learned yet.
For designers, sometimes it can be a real gauntlet to get a design job. One of friends had to build and
script an entire single-player levelto get a design job at one company, and he spent about a month working on
it every day. It depends on how the company works - some game companies are still in the pencil and paper
days of design, some require their designers to do modeling and texturing, and some (like Infinity Ward)
would like designers to be able to script.
• Is the development of a Indie game something that can help to get a job in Game Studios?
Definitely having something to show is a huge advantage. Having shipped a game, even an indy
game that never had a real publisher but you've had hundreds of downloads is impressive in itself. But if you
actually manage to "finish" a game and have it in a presentable state, that's going to go a long way to most
employers.
• What is your opinion about Game Engines focused in the independent developer, like Torque
and 3DGame Studio? Learn to develop a game in this engines can help to get a job in the game
industry?
Game companies are pretty familiar with commercial engines, so it's easier for us to realize what
work you did. If you were to do a mod for Toque or another engine that we aren't very familiar with, it's
harder to pin down exactly what you did and what functionality was already there. For that reason, I would
recommend against those engines if your goal is to get a job in the industry (although I'm sure they're nice
engines).
If your area of interest lies in the core of an engine, you might want to look at something like Quake
3 which is available under the GPL. If you are more info gameplay or AI, you could do a mod for Half Life 2
or the Unreal engine without needing their core engine code. But if none of those suit you, doing something
on indy developer engines is not bad.
As I said, having something polished and ready for viewing is the most important thing I can
recommend.
• What is your opinion about the XNA Game Studio Express, the free game development tool
from Microsoft ?
I just tried using it last week to see how C# coding would work for games. I definitely haven't spent
much time with it yet, but I have mixed feelings about C#. Not many game companies are currently looking
for someone who is a C# expert, so that part isn't a big help (maybe that will change, who knows). I think
E COM VOCÊS...
doing small games where fun is more important than technology is a really good mindset, so I appreciate
things like XNA and amateur people doing small Live Arcade type games.
For those currently-amateur people who want to make games, I think it's outstanding. The bonus that
you can shop around a nearly-complete Live Arcade game to Microsoft is pretty amazing.
• Do you believe the next generation Video Games (after XBOX360 and PS3) will be network
only machines, in a way that the games will be downloaded to the video game instead of bought
in stores?
Right now we're at the stage of just trying to get people to connect their console to the network and I
think there is a huge gap between the crowd that is ready to buy their games digitally and the crowd that has
no idea why they would want to do that. MP3s started getting really popular on the net back in1997 or so,
and even today CD sales are much bigger than iTunes sales (about a decade later). Given that games are so
many times larger than an album in MP3, I would say it'll be a long time before the market is ready for all-
digital downloads.
Assuming broadband numbers continue to get drastically better worldwide, getting people to hook
their console up to the network is an ongoing battle. According to Microsoft's numbers, around 60% of 360
owners have ever connected their consoles to the network (which they should be commended on, that's quite
an accomplishment). But look at the flip side - if at least 40% of the hardcore early adopters have never even
plugged in their console to the net, you're talking about a lot of sales to walk away from. Plus that 60%
doesn't give us enough information about people who plugged it in once and never again. All in all, you're
talking about a lot of sales to walk away from currently. Maybe the world will change drastically in the next
5 years in the world of broadband and home networks, but I'm not as optimistic.
Then we need to show people how they benefit from digital purchases. If it's the same price but they
get no box and no manual, can't resell it, and can't bring it to a friend's house, I think you'll find that a lot of
people won't be interested. Selling it cheaper is going to create the problem of unhappy retailers getting
undercut by the same person who is selling them their products. Add to it that you're going to make it
difficult to give someone a game for Christmas, which is possibly the biggest chunk of game sales, and it
seems to have a lot of things going against it. So I suspect that digital-only game purchases are many years
off for a variety of reasons.
• Do you still have time to play games ? What are your favourite games ?
Absolutely. I try to at least watch some of every major game that comes out. Infinity Ward buys
copies of pretty much every game that comes out, and we'll gather around and watch someone play a bit if the
game is doing something new and interesting. As for what I'm playing, I just finished playing Titan Quest, I
play multiplayer Guitar Hero with friends, tried some Dead Rising and Chromehounds, and now I'm working
my way through Saints Row and enjoying it quite a bit, and also dabbling in Company of Heroes. I also play
on my DS - currently Brain Training and Phoenix Wright. I'm pretty much always playing something, and
once I stop playing a game there's a sharp pain in my side telling me I need to find a new game to play.
VOCÊS...
E COM VOCÊS. ..
Jon Shiring resting

ESPAÇOARTE
Entrevista Low-Poly
Entrevistador Christiano Lima Santos

Entrevistado Marcelo M. Prado (Akigames)
Homepage http://marcelo3d.vilabol.com.br
E-mail akigames@ig.com.br
PDJ: Fale-nos sobre sua experiência (em que trabalha, há quanto tempo, ferramentas que conhece,
quanto tempo estuda modelagem 3D).
Marcelo: Trabalhei no desenvolvimento do RPG chamado Legend Alive, que por falta de verbas
acabou morrendo... Apesar de termos alcançado algumas metas bem satisfatórias!
A cerca de 1 ano trabalho em uma empresa de propaganda e marketing chamada Izidoro
Comunicação que fica localizada em Alphaville. (Site:
www.izidoro.com.br)
PDJ: Pode nos falar um pouco sobre a imagem que você está nos apresentando aqui na EspaçoArte?
Marcelo: Essa Imagem foi feita para o #5 Low-Poly Contest da 3D Total (www.3dtotal.com). Onde
o tema era "End Boss Game", e acabei escolhendo o vilão do jogo Final Fnatasy 7... Sephiroth, para modelar.
Levei cerca de 1 mês para finalizar. Gastando 1 semana na modelagem e as demais 3 semanas para
texturização, RIG e melhoramentos nas quais a comunidade do Forum da 3D Total palpitavam.
ESPAÇOARTE
Algumas texturas usadas na modelagem da cabeça do personagem
PDJ: Ferramentas utilizadas (modelador 3D, editores gráficos para texturas, ferramentas de arte-
finalização, etc);
Marcelo: Utilizei o 3Ds MAX 6 para modelagem, junto com o Character Studio do MAX para RIG.
Para Renderizar foi usado o Default Scan Line Render mesmo. Para gerar as texturas utilizei o Photoshop 7. E
como era um contest de Low-Poly não foram usadas ferramentas para pós produção...
PDJ: Técnicas envolvidas no desenvolvimento do modelo 3D e na arte-finalização (descrição e

comentário sobre elas);
Marcelo: Na modelagem utilizei Box Modeling. Nas texturas utilizei pintura digital com Brushes do
photoshop. Uma hora ou outra utilizei alguns filtros do Photoshop para gerar alguns efeitos na textura, como
sujeiras e uniformidades... Como referência para as texturas peguei algumas fotos de modelos reais... Como
bota de couro, Sobre-tudos, etc... E tentei fazer o mais próximo possível do que via nas fotos. Para dar um
efeito legal no modelo 3D, criei Specular MAPS e BUMP Maps, usando como base as texturas Difuse do
modelo 3D. No caso do Contest, o participante poderia utilizar tanto BUMP MAP quanto NORMAL MAP,
ficando a escolha do mesmo. Acabei escolhendo o BUMP MAP que da um efeito legal... Nada tão fino
quanto o Normal MAP que da um efeito de volume melhor para esse tipo de caso, por que BUMP MAP no
meu caso achei muito mais simples de ser gerado... Ja o Normal MAP eu teria que criar um modelo High-
ESPAÇOARTE
Poly para Gerar o Volume do NORMAL MAP... Ou então gerar meu NORMAL MAP a partir do meu BUMP
MAP... O que daria na mesma no final das contas.
Bem, após tanta conversa, hora de apresentar o trabalho final de nosso amigo:
Realmente um trabalho muito bem feito, Marcelo, você está de parabéns.

E muito obrigado pela sua presença nesta edição da PDJzine trazendo um pouco mais da modelagem 3D.
NOTA
TOME NOT A
À Caça das Oportunidades – Cursos na Área de Jogos
Autor: Thiago Marques Martinez (W_Snipes)
Estamos sempre buscando uma forma de aprimorar nossos conhecimentos, aprender coisas novas e
sabemos que isto não é algo fácil.
Bem, aqui vai uma lista contendo uma relação de empresas e cursos que estão oferecendo na área de
jogos para que você fique antenado e procure um mais próximo de você para auxiliá-lo em sua ascensão
profissional e educacional!
EMPRESA : AZMT
Curso oferecido: Game Facilites - Produtividade 3d para desenvolvimento de Games
Site : http://www.azmt.com.br
EMPRESA : Alpha Channel

Cursos oferecidos: Curso de jogos 3D com Game Studio - Essencial
Curso de jogos 3D com Game Studio - Avançado
Site : http://www.alphachannel.com.br
EMPRESA : Interplan
Cursos oferecidos: Games para Desktop - Utilizando C++
Games para Celular - Utilizando J2ME
Site : http://www.interplan.com.br
EMPRESA : Estácio de Sá
Curso oferecido: Blender Básico – Modelagem e Animação para Jogos
Site : http://www.estacio.br
EMPRESA : Impacta
Curso oferecido: Modelando Personagem 3D para Games
Site : http://www.impacta.com.br/treinamentos/trn_treinamento.asp?IDT=829&est=sp
EMPRESA : Senac-sp
Cursos oferecidos: Produção de Webgames
Flash Programado II MX 2004 - Produção de Games
Técnico em Produção Digital - Web e Multimídia
Site : http://www.sp.senac.br
EMPRESA : T&T
Cursos oferecidos: Game Developer
Professional Game Developer
Mobile Developer
TOME NOTA
Site : http://www.ttnet.com.br
EMPRESA : Poli Bentinho

Curso oferecido: Técnico em Design e Projeto de Games
Site : http://www.bentoquirino.com.br/cursos/cursos.php?codigo=18
EMPRESA : PUC RIO

Curso oferecido: Desenvolvimento e Design de Jogos 3D
Sites: http://www.cce.puc-rio.br/artes/designjogos.htm
http://www.icad.puc-rio.br/conteudo/cursos.html
EMPRESA: K3LSB
Curso oferecido: Desenvolvimento de jogos 3D
SITE: http://www.k3lsb.pop.com.br/3dgs
EMPRESA : Engine
Curso oferecido: Curso de Desenvolvimento de Jogos Eletrônicos
SITE : http://www.facje.com
Ensino Técnico
EMPRESA : Unibratec
Curso oferecido: Curso Técnico de desenvolvimento de Games
Site : http://www.unibratec.com.br/ensino_tecnico/ctj.html
Graduação
EMPRESA : FACULDADE DE ENGENHARIA DE JOGOS ELETRÔNICOS
Curso oferecido: Engenharia da Computação com Ênfase em Desenvolvimento de Jogos Eletrônicos.
Site : http://www.facje.com/index.php?pag_cod=1
EMPRESA : FMU
Curso oferecido: Tecnologia de desenvolvimento de games
Site : http://www.fmu.br/vestibular/curtaduracao/tecnologia/games/Games.asp
Graduação Tecnológica
EMPRESA: Universidade Gama Filho
Curso oferecido: Jogos Digitais
Site: http://www.ugf.br/cursos/gprofissional/jogos_digitais.shtml
TOME NOTA
Pós-Graduação
EMPRESA : CGMAX
Curso oferecido: Desenvolvimento de Jogos e Aplicações 3D
Site : http://www.cgmax.com.br
EMPRESA : Unicenp
Curso oferecido: Desenvolvimento de Jogos para Computadores
Site : http://www.posunicenp.edu.br/cursos2006.asp?strCurso=inf03
EMPRESA : Estácio de Sá
Curso oferecido: Animação para Ambientes Digitais
Site: http://www.estacio.br/posgraduacao/cursos/games/ani_amb_dig.asp
EMPRESA : Senac-SP
Curso oferecido: Especialização em Games: Produção e Programação
Site : http://www.sp.senac.br
À TODA PROVA
Game PDJ Contest 2006 (GPC06)
Autores: Christiano Lima Santos

Breno (gammer)
É isso aí, pessoal!
Finalmente temos a lista dos jogos competidores da GPC06, a segunda competição de

desenvolvimento de demos de jogos incentivada anualmente pela nossa comunidade.
E ficamos muito felizes com o número de participantes nesta edição.
Este ano, mantivemos livre a temática dos jogos, entretanto os dividimos por categorias de forma que
todos possam competir de igual para igual. As categorias são: jogos para dispositivos móveis, jogos para
Web, jogos 2D e jogos 3D.
Sem mais demora, vamos apresentar os jogos participantes e torcer por eles!
Jogos para Dispositivos Móveis
Primary Mobile Edition

Nome da Equipe: Hunter Games
Status: Competidor
Integrantes da Equipe: Ariel Miranda Xavier
Descrição do projeto:
Jogo de nave baseado no megamania do atari, com a nave na parte inferior da tela o
objetivo é matar todos os aliens que ficam na parte de cima se movendo de um lado a
outro. Versão para celulares nokia em J2ME, tem apenas 3 fases.
À TODA PROVA
Link para Baixar
http://www.breno.einet.com.br/huntergames/PrimaryME.jar
OBS: Funciona apenas nos smartphones da nokia com sistema SymbianOS (S40, S60,
S80) roda melhor no S60 (1st, 2nd ou 3rd edition) ex.: n-gage (S60 1st edition)
Hey Rabbit!!!
Nome da Equipe: Screamsoft
Status: Competidor
Integrantes da Equipe: TK2000 (Maurílio Silva) - Programação, PJ Torres e Leo
Torres – Desenhos
Game Puzzle 2D com visão superior.
Links para Baixar
http://games.screamsoft.com/ (versão jar – para celulares)
http://games.screamsoft.com/hr_demo/files/HeyRabbit.zip (versão exe - para PCs)

À TODA PROVA
Jogos 3D
Boomwar
Nome da Equipe: Boom Team
Status: Competidor
Integrantes da Equipe:
Programação:
• Renan Augusto Guerra Greinert
• Ankush Dhar
• Didier Collard
• Estevão Arantes
Arte e Modelagem:
• Diogo Maciel de Souza
• David Wang
Jogo de naves de três participantes, onde cada um joga em um turno. Jogabilidade
similar ao Worms.
Link para Baixar
http://www.sf.net/projects/boomwar
À TODA PROVA
Pacman 3D
Nome da Equipe: Boom Innovation
Status: Competidor
Integrante da Equipe:Vladimir Cavalcanti Dobroff
Trata-se de um jogo baseado no clássico Pacman desenvolvido para o Atari. Contudo
esta versão foi implementada em 3D e apresenta um novo conceito, sendo o principal
inimigo do jogador o próprio Pacman!!!
Link para Baixar
http://rapidshare.com/files/9648711/Pacman_3D.zip
OBS: Instruções para fazer o download no rapidshare: Entre no link, clique em Free,
digite o código que aparecerá e finalmente clique em download.
À TODA PROVA
Jogos para WEB
Submundo - A Vida Sobre Rodas

Nome da Equipe: Elfland Studios
Status: Competidor
Integrante da Equipe:Christiano Lima Santos
Trata-se de um jogo de corrida single player 2D com visão Top Down feito em Flash,
apresentando dois modos de jogo - Campeonato e Trial Attack.
Link para Jogar
http://www.elfland.com.br/jogos/submundo/submundo800.html
Força Andrômeda - Operação Tempestade

Nome da Equipe: Elfland Studios
À TODA PROVA
Status: Competidor
Integrante da Equipe:Christiano Lima Santos
Trata-se de um jogo shoot'em up 2D em Flash que traz o início da saga Força
Andrômeda.
Link para Jogar
http://www.elfland.com.br/jogos/faot/faot800.html
Guerra das Tribos

Nome da Equipe: Impactum
Status: Competidor
Integrante da Equipe:Pérsio Flexa e Alexandre Senicato
Guerra das Tribos será um RPG on-line que vai simular uma guerra entre tribos de
origens completamente diferentes, onde os jogadores poderão escolher: Índios
canibais, Índios americanos ou Índios da selva brasileira.
Ao iniciar o jogo, os jogadores começarão como crianças e deverão passar por um

treinamento para aprender a sobreviver e enfrentar seus inimigos, que serão desde
À TODA PROVA
animais pequenos, feras ou até mesmo espiritos que vivem na selva. Feito o
treinamento, o usuário já recebe uma missão passada pelo chefe da aldeia e então
começa o jogo on-line com apenas uma arma básica pra se defender e alguns itens de
cura.
Todos os jogadores poderão se comunicar e participarão de aventuras narradas por

NPCs.
As missões poderão ser diversas, como solução de enigmas, exploração de mapa ou

até mesmo busca por itens especiais com desafios a mestres de aldeias.
Assim como em vários outros jogos de RPG, cada personagem irá desenvolver novas
habilidades ao combater inimigos e aumentando seu nível enquanto procura resolver
suas missões e ir aumentando seu nível.
O jogo também deverá ter uma parte do mapa reservada para a construção de
“OCAS”, onde o personagem poderá guardar os itens que não consegue mais carregar,
além de poder recuperar seu sangue.
Em locais específicos dentro dos cenários, o jogador poderá participar de mini-torneios

de tiro ao alvo com arco-e-flecha, zarabatana, arremesso de lanças e dardos,
competindo com outros jogadores.
Também poderá haver disputas de dança, pintura, pesca, caça e várias outras
atividades que fazem parte do dia-a-dia de uma aldeia indígena.
Na intenção de uma boa divulgação na internet, o jogo terá mini-games, que serão
jogos simples e independentes dos cenários e do roteiro de missões a que os jogadores
estarão sujeitos. Eles serão jogados por jogadores ocasionais, que não precisarão ter
um personagem para facilitar a divulgação e a prospecção de jogadores ativos.
À TODA PROVA
Link para Jogar
http://br.geocities.com/stillmmorpg
OBS:Por favor, preciso que acrescente o seguinte endereço junto ao jogo, para as
pessoas poderem acessar o servidor e colocarem por si só os inimigos no jogo e para
que também os juízes possam avaliar vendo o jogo funcionando. Pois não tenho onde
deixar o servidor ligado, sendo ele o responsável por manter os inimigos no cenário.
Para acrescentar inimigos no jogo acesse:
http://br.geocities.com/stillmmorpg/servidor.swf
E com o servidor ainda aberto acesse para visualizá-los:
http://br.geocities.com/stillmmorpg/
À TODA PROVA
Jogos 2D
Moskas
Nome da Equipe: Schifers Tecnologia e Entretenimento
Status: Desclassificado
Integrante da Equipe: Bruno Schifer e Orlando Haus
Trata-se de um jogo tipo arcade, visão top-down, onde o personagem principal deve
catar moskas e fugir dos perigos que existem nos locais por onde passa.
Link:Não disponibilizado no prazo.
Matx
Nome da Equipe: Brainscore
Status: Competidor
Integrante da Equipe: Adriano Waltrick
É um jogo do tipo arcade, baseado no dominó alemão.
À TODA PROVA
Link para baixar
http://www.informaretreinamento.com.br/akuma/Matx.zip
Obs: É um jogo Puzzle - que pode ser portado facilmente para: Webgame - Jogos para
Celular. Apesar de ser um jogo matemático, estou tentando criar uma temática legal
para não assustar os jogadores. Desta forma eu mesmo estou criando os gráficos.
Starfight
Nome da Equipe: Brainscore
Status: Competidor
Integrante da Equipe: Bruno A. Rovela
Starfight é um jogo de nave onde o jogador deverá salvar a Terra de uma ameaça no
espaço.
À TODA PROVA
Link para baixar
http://gama.roteador.info/%7Ebruno/starfight.zip
Money Toss
Nome da Equipe: Ivory Tower
Status: Desclassificado
Integrante da Equipe: Eduardo Pereira e Rodrigo Mitsuo
Money Toss, é puzzle (estilo tetris) que o jogador deve impedir que uma plataforma
esmague a outra. A plataforma deve ser equilibrada de acordo com o peso das
moedas.
Link:Não disponibilizado no prazo.
À TODA PROVA
Conecta4
Nome da Equipe: Engatinhar Digital
Status: Competidor
Integrante da Equipe: Thiano Pereira Lima
O Conecta4, e uma versão do Connect Four lançado pela estrela e também conhecido
como Capitão Cook, aonde ele é semelhante ao Jogo da Velha, ganhando o adversário
que conseguir primeiro colocar 4 carinhas iguais na diagonal, vertical, ou horizontal.Ele
se passa em um tabuleiro 7x6 aonde todas as peças inseridas iniciam de baixo para
cima.
Link para baixar
http://200.250.245.55/desertmourn/conecta4.rar
Haiyoto Battle v1.0

Nome da Equipe: TeGHaK Spirits
Status: Competidor
Integrante da Equipe: Alex Yudi Endo
À TODA PROVA
Haiyoto Battle conta com seis personagens. Os comandos de ataque estão no mesmo
esquema do jogo do pokémon, tem a defesa e especiais. O jogo foi feito para dois
jogadores.
Link para baixar
http://www.gamecultura.com.br/index.php?option=com_remository&Itemid=56&func
=select&id=4
Lost Paradise
Nome da Equipe: Tuty Hay Company
Status: Competidor
Integrante da Equipe: rodrigo lorenz, glauber bonifácio e leandro rosa.
Jogo de plataforma seguindo o estilo de clássicos como castlevania, megaman entre
outros.
Link para baixar
https://sourceforge.net/projects/dsproject
Mr. Bird Adventures: The Time Line

Nome da Equipe: Barba Games
Status: Competidor
Integrante da Equipe: Ademir José Barba
À TODA PROVA
Jogo de aventura onde o jogador controla um pingüim que se depara com seres e
armas de outras épocas e que luta para desvendar o que está acontecendo.
Link para baixar
http://www.4shared.com/file/7212644/53623c36/MBTimeLine.html
AXOL
Nome da Equipe: Serpa Games
Status: Competidor
Integrante da Equipe: Leandro Serpa de Oliveira
Game de nave com visual superior no melhor estilo Sonic Wins. Gráficos agradáveis e
jogabilidade fácil.
À TODA PROVA
Link para baixar
http://www.elfland.com.br/jogos/axol.zip
VelhaX
Status: Competidor
Um game sobre o bom e "velho" jogo da "velha", com gráficos bem feitos, sons
bacanas, opção de escolha de dificuldade e dois modos de jogo: Normal e
Campeonato.
Experimente o modo Campeonato com a dificuldade "Difícil", o game ficará bem
desafiador.
Link para baixar
http://www.elfland.com.br/jogos/Velha_1.0.rar
À TODA PROVA
Alienógicos
Status: Competidor
Game de naves onde você encontra uma bela inovação: é possível controlar a direção
do tiro depois do disparo. Experimente e faça seu recorde.
Link para baixar
http://www.elfland.com.br/jogos/Alienogicos.zip
RoundBoxer Deluxer
Status: Competidor
RoundBoxer Deluxer é a nova versão de um super jogo de plataforma, com gráficos
agradáveis e jogabilidade fácil, agrada à todas as idades. Passe por vários locais, por
várias situações, enfrente chefes mal encarados, caminhe por florestas, encare
cavernas sombrias, mergulhe em águas gélidas, ande por castelos e fuja da lava
flamejante, corra desgovernado em um carrinho na mina assombrada , tenha cuidado
para não escorregar no gelo, atenção para morcegos nojentos, e muito mais! Jogue
RoundBoxer e conheça o nosso Mário gordão Tupiniquim!!!
À TODA PROVA
Link para baixar
http://www.elfland.com.br/jogos/roundboxer.zip
Streech
Status: Competidor
Streech é um game parecido com Pong com uma temática meio medieval. Nele você
controla um dos slaches e deve marcar pontos acertando no gol do adversário. Quem
fizer 15 pontos ganha a partida. Vozes digitalizadas dão um ar sinistro ao game.
Além disso existe o artefato BOLA DE FOGO que surgirá de vez em quando na partida.
Quem conseguir pegar a BOLA DE FOGO, destruirá seu inimigo momentaneamente
após ele tentar rebater a bola e o gol ficará livre.
É possível escolher o nível para se jogar: FÁCIL ou DIFÍCIL . E também, caso deseje
disputar uma partida com alguém você poderá escolher a opção VERSUS.
Link para baixar
http://www.elfland.com.br/jogos/streech.zip
À TODA PROVA
Primary
Nome da Equipe: Hunter GamesStatus: Competidor
Integrante da Equipe: Ariel Miranda Xavier
Jogo de nave baseado no megamania do atari, com a nave na parte inferior da tela o
objetivo é matar todos os aliens que ficam na parte de cima se movendo de um lado a
outro. Tem 4 fases, e história de início e fim do jogo.
Link para baixar
http://www.breno.einet.com.br/huntergames/primary.zip
Intergalatica
Nome da Equipe: Bernado Araújo
Status: Competidor
Integrante da Equipe: Bernado Araújo
À TODA PROVA
Intergalatica é um jogo de nave diferente dos outros, sendo um jogo para duas
pessoas, você enfrentará um amigo, tornando o jogo mais desafiador e divertido!
Use os itens disponíveis para esmagar seu adversário, fique atento para os obstáculos
do mapa, use-os contra seu oponente!
Links para baixar:
http://rapidshare.com/files/9140861/intergalatic.rar
http://paginas.terra.com.br/lazer/bern3dfiles/intergalatic.rar
Jogo da Velha v1.4

Nome da Equipe: KLCSoftware
Status: Competidor
Integrante da Equipe: Kleber Leandro Coelho
Este game, Jogo da Velha v1.4 by KLCSoftware, é uma versão totalmente modificada
do clássico "Jogo da Velha", com um novo visual e efeitos, onde você pode colocar
uma música mp3 como toque de fundo, tendo o modo 2 jogadores e 1 jogador versus
computador com 3 níveis de dificuldade e muito mais.
À TODA PROVA
Link para baixar
http://www.zshare.net/download/jogo-da-velha-v1-4-rar.html
Solis
Nome da Equipe: Advant Games
Status: Competidor
Integrante da Equipe: João Lucas Raza, Peter Iliev
Solis é um jogo 2d seguindo os padrões de Zelda e Terranigma. O jogador controla
Dresden, um jovem soldado a procura do lendário general Solis, enfrentando magos e
dragões no meio do caminho. E pegando melhores armas no meio do caminho.
Link para baixar:
http://geocities.yahoo.com.br/criatura_abismo/Solis.zip
CUT 0.9
Nome da Equipe: AGF
Status: Competidor
Integrante da Equipe: Hélder Maurício Gomes Ferreira Filho
O jogo foi criado para ser um jogo simples, de um botão só, (estilo o webgame
yetisports por exemplo), ele foi criado para ser multiplataforma (atualmente a versão
0.9 só funciona em windows, linux, MAC e alguns outros *nix) e o conceito dele
permite que ele seja feito para celulares mais antigos, e até no atari é possível fazer
uma versão O objetivo é simplesmente destruir alvos usando uma serra que você
dispara, o jogo pára quando a serra parar ou chegar no topo da tela.
Link para baixar:
http://www.zshare.net/download/cut-zip.html
MinerMan
Nome da Equipe: Erisvaldo Júnior
Status: Competidor
Integrante da Equipe: Erisvaldo Gadelha Saraiva Júnior
À TODA PROVA
Com jogabilidade similar aos clássicos Sokoban e Box World, MinerMan é uma mistura
de puzzle com arcade. Assuma o papel do minerador e colete as pepitas de ouro nos
mais diversos lugares.
Links para baixar:

http://www.unidev.com.br/contest/566/MinerMan.zip
http://www.gamedev-br.net/minerman/MinerMan.zip
FIM DA HISTÓRIA
Uma Salva de Palmas Antes de Fechar as Cortinas!
Autor: Christiano Lima Santos
Desta vez vou encerrar diferente!
Das últimas vezes encerrei falando sobre algo a fim de incentivar mais e mais
pessoas a participar, a reclamar de algum problema que estivéssemos tendo e falando
um pouco sobre as dificuldades que quem começa há de encontrar em seu caminho.
Desta vez quero encerrar esta revista de uma forma diferente: Agradecendo a
todos os que participaram dela!
Sim, porque nem tudo são problemas e por trás das cortinas que trazem todo
esse show que é a PDJzine está um monte de pessoas que corre atrás de conteúdo, de
notícias, enfim: contribuem de alguma forma para que tudo chegue a tempo a todos!
Nesta última edição, como todos devem ter percebido, surgiram muitos
impasses que atrasaram o lançamento da mesma, desde acúmulo de tarefas em
minhas mãos até meu computador ter que ir para a assistência (e ainda voltar com
problemas... Tudo bem, já os solucionei, banana para o povo da assistência!).
Então, aqui vão os meus sinceros agradecimentos a Kishimoto, pois toda vez
que digo que vou parar o desenvolvimento da revista ele acaba me convencendo a
continuar.
Agradecimentos também a todos os que me enviaram conteúdo para a mesma,

são muitos e já estão enumerados na seção “Quem Fez a PDJzine #3”. Realmente,
obrigado!
E gostaria de agradecer também à minha irmã Chryslene e à minha namorada

Marcelle que, quando me viram no desespero, arrancando os fios de cabelo pela raiz
do dente, decidiram me dar uma mão e auxiliar na formatação e correção gramatical
da revista, o que adiantou muito do meu trabalho. Incrível como pessoas que não são
da área às vezes contribuem mais que alguns que são e preferem ficar escondidinhos
atrás do sofá, vaia para esses e aplausos para aqueles!
Bem, pessoal, então é isso. Vou interromper por aqui todo o meu diálogo para
que eu possa voltar e concluir a GPC06, lançar uma edição especial da PDJzine, dar
continuidade ao meu grupo de estudos de Desenvolvimento de Jogos em Flash e aos
meus atuais trabalhos. Como é boa essa vida onde a gente acha tempo onde nem mais
existe!

Pdjzine 03

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Pdjzine 03

Enviado por

Direitos autorais:

Formatos disponíveis

PDJzine – Revista Eletrônica de Distribuição Livre da Programadores e Desenvolvedores de Jogos

PDJzine – Revista Eletrônica de Distribuição Livre da Programadores e Desenvolvedores de Jogos

Quem fez a PDJzine #3

Membro Anderson Marcondes

Membro André Kishimoto

Membro Breno (gammer)

Membro Bruno Schifer (schifers)

Membro Christiano Lima Santos

Membro Jean Freitas (LoneWolf)

Membro Paulo Andrade

Membro Rubens Garcia (linuxboy)

Membro Thiago Marques Martinez (W_Snipes)

Christiano Lima Santos

PDJzine – Revista Eletrônica de Distribuição Livre da Programadores e Desenvolvedores de Jogos

Blender – Textura UV básica

Autor: André Kishimoto

1) Em primeiro lugar, divida a interface do Blender em duas visões (Figura 1).

Figura 1: Interface dividida em duas visões.

Figura 2: Janela UV/Image Editor na direita.

Figura 3: Botão Mode.

Figura 4: Modo UV Face Select.

PDJzine – Revista Eletrônica de Distribuição Livre da Programadores e Desenvolvedores de Jogos

Figura 6: Escolha o arquivo de textura.

Figura 7: Textura carregada.

Figura 8: Textura mapeada nas faces do objeto.

9) A Figura 9 demonstra uma outra visualização do mapeamento de textura depois de realizado os

Figura 9: Outra visualização do mapeamento de textura no Blender.

PDJzine – Revista Eletrônica de Distribuição Livre da Programadores e Desenvolvedores de Jogos

Blender – Interação com LogicBricks

Autor: André Kishimoto

Figura 1: Contexto Logic (em destaque).

Figura 2: Interface da seção de interação do Blender.

5) O primeiro passo para começar o exemplo é adicionar um sensor, um controlador e um atuador.

Figura 3: Botões (em destaque) para adicionar sensores, controladores e atuadores.

Figura 4: Selecionando o sensor do tipo Keyboard.

Figura 5: Opções para o sensor Keyboard.

Figura 6: Definindo a tecla a ser usada na interação.

PDJzine – Revista Eletrônica de Distribuição Livre da Programadores e Desenvolvedores de Jogos

Figura 7: Seta direcional esquerda foi definida no sensor.

Figura 8: Renomeando um sensor (em destaque).

Figura 9: Conectando o sensor ao controlador (em destaque).

Figura 10: Resposta do atuador em relação ao sensor SetaEsq.

Figura 11: Colunas x, y e z do atuador Motion.

Figura 12: Resultado final dos passos anteriores.

PDJzine – Revista Eletrônica de Distribuição Livre da Programadores e Desenvolvedores de Jogos

Figura 14: Iniciando a interação do Blender.

Blender – Sensores de colisão

Autor: André Kishimoto

Nota: este tutorial cobre os seguintes sensores: touch, collision e near.

Figura 1: Cenário a ser usado nesse tutorial (User view).

PDJzine – Revista Eletrônica de Distribuição Livre da Programadores e Desenvolvedores de Jogos

Figura 2: Cubo posicionado no eixo z = 5.00.

Figura 3: Botão Actor.

Figura 4: Novos botões.

Figura 5: Configuração final para o cubo.

Figura 6: Configuração de materiais.

Figura 7: Criando um novo material.

Figura 8: Mudando a cor do material.

Figura 9: Coeficiente de restituição (elasticidade).

PDJzine – Revista Eletrônica de Distribuição Livre da Programadores e Desenvolvedores de Jogos

Figura 10: Sensores de colisão adicionados.

Figura 11: Configuração do sensor Near.

Figura 12: Botão para adicionar propriedades em um objeto (em destaque).