Fatec XNA

CENTRO PAULA SOUZA
FACULDADE DE TECNOLOGIA DE TAQUARITINGA

TECNOLOGIA DE PROCESSAMENTO DE DADOS

DESENVOLVIMENTO DE JOGOS
PARA WINDOWS UTILIZANDO XNA

AUTOR: ALEXANDRE JAMARCO

ORIENTADOR: JOO DE LUCCA

Taquaritinga
2009

DESENVOLVIMENTO DE JOGOS
PARA WINDOWS UTILIZANDO XNA

ALEXANDRE JAMARCO

Taquaritinga
2009

Monografia apresentada Faculdade de
Tecnologia de Taquaritinga, como parte
dos requisitos para a obteno do ttulo de
Tecnlogo em Processamento de Dados.
Orientador: Joo de Lucca Filho

Dedico,

A minha famlia,

Que sempre me apoiou

E sempre esteve ao meu lado.

AGRADECIMENTO
Aos meus pais, Jadir e Cleide, que souberam me educar e agentar meus momentos de
raiva e de tristeza por todos estes anos.
Ao meu irmo Leandro, que durante todos estes anos foi muito mais do que um irmo
para mim.
Aos meus primos Lucas, Adriano, Cleber, Andr e Daniel. Que apesar das brigas e
desavenas, eu amo todos eles.
Aos meus familiares de um modo geral. Um grande homem tem como base uma grande
famlia.
Aos meus amigos que sempre estiveram do meu lado me apoiando e me incentivando.
Ao pessoal do MEB (Movimento de Evangelizao Bblica) de Taquaritinga, o qual
tenho um carinho muito grande por todos eles.
Ao pessoal do Rotaract Club de Taquaritinga.
A todos os funcionrios e professores da Fatec Taquaritinga, em especial ao prof. Joo
de Lucca, que aceitou ser meu orientador e me ajudou muito na concluso deste trabalho.
E por ltimo a Deus, porque os ltimos sero os primeiros.

A vida uma pea de teatro que no
permite ensaios. Por isso, cante, ria,
dance, chore e viva intensamente
cada momento de sua vida, antes
que a cortina se feche e a pea termine sem aplausos.
CHARLES CHAPLIN
Desenvolvimento de Jogos para Windows Utilizando XNA - v

SUMRIO

LISTA DE FIGURAS ........................................................................................................ VII
LISTA DE ABREVIATURAS E SIGLAS ........................................................................ VIII
RESUMO............................................................................................................................. IX
ABSTRACT ......................................................................................................................... X
INTRODUO ................................................................................................................... 11
1. PLANEJAMENTO DE UM JOGO ................................................................................ 14
1.1 Escolhendo o pblico-alvo .................................................................................... 16
1.2 Consideraes finais ............................................................................................. 17
2 PROGRAMAO BSICA DO XNA .......................................................................... 18
2.1 Ciclo de vida de um jogo em XNA ....................................................................... 22
2.1.1 O Gerenciador de Dispositivo Grfico (Graphic Device Manager) ................ 22
2.1.2 O Content Pipeline Manager ......................................................................... 23
2.1.3 Mtodos de Inicializao ............................................................................... 24
2.1.4 Finalizao .................................................................................................... 24
2.1.5 Loop do jogo ................................................................................................. 24
3 PROGRAMAO 2D ................................................................................................... 27
3.1 Termos Usados para Programao 2D ........................................................................ 27
3.2 Sistema de Coordenadas ....................................................................................... 29
3.3 Desenhando um sprite na tela ................................................................................ 30
3.3.1 Inicializando as variveis no-grficas. ......................................................... 33
3.3.2 Movendo a figura na tela ............................................................................... 35
3.3.3 Utilizando o teclado para mover a imagem .................................................... 38
3.3.4 Utilizando o mouse para mover a imagem ..................................................... 39
3.3.5 Utilizando o joystick para mover a imagem ................................................... 39
4 UTILIZANDO O XACT ................................................................................................ 41
4.1 Adicionando ao jogo o udio criado ...................................................................... 44
5 CRIANDO UM JOGO 2D .............................................................................................. 47
Desenvolvimento de Jogos para Windows Utilizando XNA - vi
5.1 Planejando o jogo ................................................................................................. 47
5.2 Desenhando a imagem de fundo ............................................................................ 49
5.3 Criando a espaonave ........................................................................................... 51
5.4 Desenhando os meteoros ....................................................................................... 58
5.5 Desenvolvendo a lgica do jogo ............................................................................ 61
5.6 Adicionando sons ao jogo ..................................................................................... 63
5.7 Adicionando um placar ao jogo ............................................................................. 64
5.8 Fazendo o controle vibrar ...................................................................................... 66
5.9 Fazendo melhorias no jogo ................................................................................... 67
CONCLUSO ..................................................................................................................... 69
REFERNCIAS BIBLIOGRFICAS .................................................................................. 71

Desenvolvimento de Jogos para Windows Utilizando XNA - vii

LISTA DE FIGURAS

FIGURA 1: Camadas do XNA Framework. ......................................................................... 13
FIGURA 2 Tela inicial do Visual C# 2008 Express Edition ............................................... 18
FIGURA 3 criando um novo projeto XNA ........................................................................ 19
FIGURA 4 tela inicial do XNA ......................................................................................... 20
FIGURA 5 Arquitetura do Content Pipeline. ..................................................................... 23
FIGURA 6 Exemplo de Sprite ........................................................................................... 27
FIGURA 7 Exemplo de Textura. ....................................................................................... 28
FIGURA 8 Super Mario World. Exemplo de jogo que utiliza Scrooling background. ........ 28
FIGURA 9 Pokemon Yellow para GameBoy Color. Exemplo de jogo que utiliza Tiles. .... 29
FIGURA 10 Um tringulo desenhado em um sistema de coordenadas 2D. ........................ 30
FIGURA 11 Tringulo desenhado usando o sistema de coordenadas 2D no computador. .. 30
FIGURA 12 figura que ser usada como exemplo. ............................................................ 31
FIGURA 13 Carregando uma figura. ................................................................................. 31
FIGURA 14 Imagem carregada com xito. ........................................................................ 32
FIGURA 15 Declarando as variveis necessrias antes do construtor da classe. ................. 33
FIGURA 16 A figura desenhada na tela do jogo. ............................................................... 35
FIGURA 17 A imagem se movendo pela tela e batendo nas bordas. .................................. 38
FIGURA 18 Tela inicial do XACT. ................................................................................... 41
FIGURA 19 Criando um novo Wave Bank. ....................................................................... 42
FIGURA 20 Adicionando arquivos de som a um Wave Bank. ............................................ 43
FIGURA 21 A tela do programa, com o Wave Bank e o Sound Bank criados. .................... 43
FIGURA 22 Ativando a opo Infinite nas propriedades. .................................................. 44
FIGURA 23 Tela de abertura do jogo Asteroids................................................................. 48
FIGURA 24 Imagem de fundo adicionada ao projeto. ....................................................... 49
FIGURA 25 A figura de fundo desenhada na tela. ............................................................. 51
FIGURA 26 Textura da nave e do meteoro que ser includa no projeto. ........................... 51
FIGURA 27 Adicionando uma nova classe Game Component. .......................................... 52
FIGURA 28 A nave desenhada na tela............................................................................... 57
FIGURA 29 A nave e os meteoros desenhados na tela. ...................................................... 60
FIGURA 30 Jogo exemplo com o texto marcando a quantidade de meteoros ..................... 65
Desenvolvimento de Jogos para Windows Utilizando XNA - viii

LISTA DE ABREVIATURAS E SIGLAS

API Application Programming Interface (Interface de Programao de Aplicativos)
GDC Game Developers Conference
XNA XNA's Not Acronymed (XNA no um acrnimo)
XACT Cross-Platform Audio Creation Tool (Ferramenta de Criao de udio Multi-
plataforma)

Desenvolvimento de Jogos para Windows Utilizando XNA - ix

RESUMO

O presente trabalho tem como objetivo apresentar de uma forma clara e objetiva a
ferramenta XNA para o desenvolvimento de jogos para a plataforma Windows. Durante
muitos anos, os desenvolvedores amadores desejavam ter uma ferramenta simples de fcil
acesso, que possibilitaria a criao de jogos com menos esforos. Ouvindo isso, a Microsoft
lanou o XNA, uma ferramenta que traz cdigos pr-compilados, classes prontas para o
desenvolvimento de jogos e facilidades para a insero de figuras, modelos 3D, msicas,
efeitos sonoros, entre outros. Uma das outras grandes facilidades que, apesar de o XNA no
ser um software usado comercialmente, pode-se lanar um jogo produzido com XNA na rede
online do Xbox 360, e com isso, o jogo e o autor pode ganhar notoriedade do mercado
mundial. O XNA vem ganhando mais adeptos graas a competies organizadas pelo mundo
afora, como a Imagine Cup e a Dream Build Play, competies que incentivam o
desenvolvimento de jogos utilizando a ferramenta.
Palavras-chave: Programao de jogos, XNA, ferramenta de desenvolvimento.

Desenvolvimento de Jogos para Windows Utilizando XNA - x

ABSTRACT

The present work has the objective to show in a clear and objective way the XNA tool
for game development for the Windows platform. During many years, non-profesional
developers claimed for a simple and easy to use tool, which would make game creation with
less effort. Hearing to that, Microsoft released XNA, a tool that brings pre-compiled code,
ready-to-use classes for game development and makes easy the insertion of images, 3D
models, musics, sound effects, and so on. Another great ease is that, despite XNA is not
commercial software, the developers can release their games made with XNA on the online
network of Xbox 360, and with that, the game and the author can win fame from the world
market. The XNA is winning more and more adepts thanks to competitions organized all
around the world, such as Imagine Cup and Dream Build Play, competitions that stimulate
game develop using the tool.
Keywords: Game Programming, XNA, development tools

Desenvolvimento de Jogos para Windows Utilizando XNA - 11
INTRODUO
H aproximadamente vinte anos era praticamente impossvel se pensar em
desenvolver um jogo em sua prpria casa. As linguagens usadas eram difceis de serem
compreendidas, exigia-se uma equipe para montar o menor dos jogos e ainda era necessrio
que se tivesse um alto conhecimento de matemtica.
Desde a dcada de 1990 a programao de jogos passou a ser mais fcil, sendo
possvel desenvolver seu prprio jogo em casa graas a linguagens como C, C++, Python,
entre outras. Se utilizando de engines grficas como por exemplo DirectX e OpenGL era
possvel (com tempo e conhecimento) desenvolver jogos com um alto nvel de detalhes.
O XNA surgiu como uma forma alternativa de programao de jogos. Ele exige pouco
conhecimento da linguagem para se comear a programar, o cdigo managed (ou seja, parte
dele j vem preparado para se comear a programar) e j possvel encontrar muitos tutoriais
e exemplos na Internet (o site de busca Google retorna quase 4 milhes de incidncias).
Segundo o site NPD Group em 2006, a industria do videogame vendeu
aproximadamente 12,5 bilhes de dlares em vendas totais. Em 2007 esse valor foi de 18
bilhes de dlares e em 2008 a venda de produtos relacionados ao entretenimento eletrnico
foi de 21,3 bilhes.

GRFICO 1 Lucro da industria do Videogame em relao aos anos
NPD Group - Industria do Videogame
0
5
10
15
20
25
2006 2007 2008
Ano
B
i
l
h
e
s

FONTE: NPD Group (2009)

O Comeo de tudo foi com o DirectX. Uma API (Application Programming Interface
Interface de Programao de Aplicativos) da Microsoft para gerenciar tarefas relacionadas a
multimdia, como por exemplo, os jogos. Em pouco tempo, o DirectX passou a ser a API mais
usada para o desenvolvimento de jogos, graas a uma de suas ferramentas, o Direct3D, que
possibilitava criar grficos tridimensionais mas mantendo o desempenho em primeiro lugar, o
que muito importante para os jogos eletrnicos.
Em 2002, a Microsoft teve a idia de lanar uma API parecida com o DirectX mais
que aproveitasse a plataforma .NET. Da Surgiu o Managed DirectX. Suas atualizaes
pararam de acontecer em 2006, com a chegada do XNA.
Durante a GDC de 2006, a Microsoft apresentou o XNA (XNA's Not Acronymed
XNA no um acrnimo), uma nova verso do Managed DirectX e tinha como propsito
facilitar a programao de jogos para no-profissionais a tambm o desenvolvimento de jogos
para o seu novo console, o Xbox 360.
Em dezembro do mesmo ano, a Microsoft disponibilizou gratuitamente o download da
sua nova ferramenta.
Uma das grandes vantagens do XNA servir como uma ponte entre a APIs do
DirectX e o programador, possuindo uma grande variedade de funcionalidades e rotinas
previamente compiladas.

FIGURA 1: Camadas do XNA Framework.
FONTE: Microsoft (2007).

Analisando a FIG. 1, tem-se:
Plataforma: Base do XNA. So APIs de baixo nvel.
Framework (Core): o ncleo do framework. Ele contm funcionalidades pr-
compiladas que servem como base para grficos, entrada de dados, funes
matemticas e armazenamento.
Framework (Extension): a camada responsvel pela praticidade que o XNA d
ao desenvolvimento de jogos em alto nvel. Ela possui dois componentes: o
Modelo de Aplicao, que responsvel pelo gerenciamento de janelas, o looping
do jogo e funes em DirectX, e tambm h o Content Pipeline, que responsvel
pelo carregamento de texturas, sons, imagens e outros recursos. Esse componente
carrega os recursos e os transforma de acordo com um tipo de dado que o XNA
entenda. Ele ser explicado com mais detalhes em breve.
Jogos:
o Started Kits: So jogos desenvolvidos pela comunidade e que possuem seu
cdigo aberto, para que as pessoas que esto iniciando seu aprendizado possam
se familiarizar com a lgica e as caractersticas da ferramenta.
o Cdigo: referente s linhas de cdigo que o desenvolvedor programa.
o Contedo: formado por comunidades, fruns e todos aqueles que contribuem
para que a ferramenta possa melhorar a cada verso.
o Componentes: So cdigos criados por terceiros, mas que podem ser includos
nos jogos para minimizar o processo de codificao. Exemplos de
componentes so as ferramentas desenvolvidas que trabalham com cmeras,
fsica, elementos grficos e outros.


1. PLANEJAMENTO DE UM JOGO
Os esforos para a criao de um jogo comeam muito antes da fase de programao.
Essa fase na maioria das vezes esquecida pela maioria dos programadores no-profissionais,
mas sem sombra de dvida a parte mais crucial para o sucesso de um jogo. a parte de
planejamento. Toda essa importncia acontece, pois nesta fase so definidos os planejamentos
para as prximas fases.
O NPD Group, em uma de suas pesquisas, dividiu o mercado de jogos em seis
categorias: Jogadores inveterados (que jogam constantemente e so responsveis pelas
maiores vendas do mercado), jogadores vidos (que compram a maioria dos jogos e podem
jogar muitas horas por dia), jogadores de mercado (os que compram somente jogos famosos
e conhecidos), jogadores que preferem portteis (como o prprio nome diz, so jogadores que
preferem usar dispositivos portteis para jogar), jogadores secundrios (so jogadores que
raramente compram jogos e jogam na sua maioria jogos comprados por outras pessoas) e
jogadores infrequentes (so jogadores que jogam somente muito raramente).
Lobo et al (2008) divide essa lista de jogadores em dois tipos principais:
Jogadores Infrequentes: Esses jogadores so tambm chamados de casuais. Os
jogos para essa categoria devem ser fceis de jogar, sem uma histria complexa e
deve ser desafiador, mas utilizando fases curtas, para dar ao jogador o sentimento
de realizao em um curto perodo de tempo. Jogos para esse mercado tambm
no precisam ter necessariamente alto nvel de detalhes em 3D ou sons
extraordinrios. Esto includos nessa categoria jogos de cartas (Poker, Pacincia,
Copas, entre outros), de raciocnio (Tetris, Sudoku, Palavras cruzadas, entre
outros), jogos de tabuleiro (Xadrez, Damas e Gamo) e jogos similares. No se
pode confundir com relao a esses jogos. Mesmo sendo fceis de programar,
necessrio que se mantenha um nvel de desafio suficiente para que sustente os
jogadores atuais e atraiam outros. Essa uma coisa realmente difcil de se realizar
em jogos desse tipo.
Jogadores inveterados: Tambm chamado de jogadores hardcore. Eles levam o
ato de jogar muito a srio e so movidos atravs de alto nvel de desafios e uma
boa histria, os que ajudam eles a imergir no mundo do jogo mais facilmente. Os
jogos para esse tipo de jogadores devem ter alto nvel de detalhes 3D, efeitos
musicais, msicas de fundo, e muitas horas de jogo com muitos desafios.
O prximo passo definir o tipo de jogo a ser lanado. Segundo o NPD Group, os
jogos mais vendidos de 2005 em porcentagem foram:

Tabela 1 Vendas de jogos referentes a 2005
Jogos de computadores Jogos de consoles Gnero
30,8% Estratgia
19,8% 9,3% Crianas e Famlia
14,4% 8,7% Tiro
12,4% 7,8% RPG
5,8% Aventura
4,7% 30,1% Ao
3,7% 17,3% Esportes
11,1% Corrida
4,7% Luta
8,4% 11% Outros

FONTE: NPD Group (2006)

Um detalhe importante a se notar que o estilo de jogo mais vendido para
computadores no esta nem sequer listado para consoles, enquanto que o gnero mais vendido
para consoles tem somente 4,7% do mercado de jogos para computadores.
Depois dessas etapas, a etapa seguinte um conceito que passa despercebido por
muitos programadores de jogos: a equipe de produo.
Normalmente, jogos amadores exigem uma equipe muito pequena, ou mesmo uma
nica pessoa com mltiplas habilidades podem desenvolver um produto de qualidade. Mas o
desenvolvimento de jogos para o mercado de jogadores inveterados (que foi falado
anteriormente) podem exigir uma equipe muito grande, com diversas habilidades. Pode-se
citar algumas posies disponveis no desenvolvimento de jogos:
Gerente de Projeto: Uma pessoa que est no comando da situao. Ela
responsvel por controlar o tempo (para que no estoure o prazo), os recursos
necessrios, comunicao, coordenao entre os membros da equipe e assim por
diante. Mesmo para equipes pequenas, crucial que se tenha algum que est no
gerenciamento do projeto, para ajudar a resolver os problemas e definir as direes
a serem tomadas.
Escritores: Eles so responsveis por escrever a histria do jogo, definindo os
desafios que sero encontrados e os mistrios que tero de ser resolvidos. Eles
tambm tm grande participao no desenvolvimento dos personagens, dos
dilogos e de todo o background do jogo.
Desenvolvedores de fases (level Designers): Eles criam e usam ferramentas que
sero usadas no desenvolvimento do ambiente do jogo, como por exemplo, os
leveis que o jogador passar, as cidades, entre outros.
Artistas: uma ampla categoria, que contm criadores de rascunhos (concept
arts), criadores de desenhos, criadores de texturas, coloristas, etc. Eles so
responsveis pela tela de abertura, o menu do jogo, e imagens estticas. Eles
tambm podem criar desenhos para o marketing do jogo.
Modeladores: So pessoas responsveis por criar os modelos 3D para o jogo,
seguindo os desenhos criados pelos artistas.
Animadores: Eles do vida aos personagens criados pelos modeladores. Essa parte
da equipe tambm responsvel pela criao dos filmes no meio dos jogos
(conhecidos como cut-scenes), vdeos na abertura e no final do jogo tambm.
Msicos: uma categoria de pessoas muito ampla, que vai desde a criao e
escrita das musicas e efeitos sonoros utilizados no jogo at a orquestra ou o
pessoal responsvel que cria essas msicas e efeitos sonoros.
Testadores: So as pessoas capacitadas para efetuar testes nos jogos que ainda
esto em fase Alfa ou Beta (ou seja, antes de o jogo ser lanado oficialmente). O
objetivo deles encontrar bugs e defeitos no jogo que possam atrapalhar a
jogabilidade quando o jogo for lanado.
Essa lista continuaria com outras pessoas como: Responsveis pelo marketing,
responsveis pela imprensa e responsveis pela infraestrutura de software e hardware (como
por exemplo, se o projeto necessitar de servidores para partidas on-line).
1.1 Escolhendo o pblico-alvo
Escolher o pblico alvo, o estilo do jogo e montar uma equipe no so as nicas
caractersticas para o desenvolvimento de um jogo.
Alguns outros pontos que se deve ter em mente quando se faz um planejamento so:
Objetivo do jogo: Todos os jogos que se vem no mercado possuem um objetivo
bem claro, seja ganhar um campeonato ou salvar o mundo. Esses objetivos devem
ser bem claros e devem ser especificados pelos roteiristas na fase de planejamento
do roteiro.
Fim do jogo: Alm do objetivo, importante tambm definir quando o jogo ter
um fim, o que inclu quando o jogador vence o jogo (na maioria das vezes,
alcanado quando o jogador alcana os objetivos definidos no tpico anterior) e
tambm inclui quando o jogador no chega ao objetivo (seja porque ele est sem
vidas, ou porque o tempo acabou, entre outros). Quando se define o critrio de
no-vitria, necessrio tambm especificar como o jogador ir voltar para o jogo,
se voltar na mesma fase, se voltar no ltimo checkpoint ou se ele ir receber uma
tela de Game Over e ter que comear desde o principio.
Enredo: O enredo fornece deve fornecer uma explicao slida que justifique o
objetivo do jogo. crucial para manter os jogadores imersos no jogo. Quando se
tem um enredo tudo no jogo deve contribuir para que o jogador a siga e esteja a
cada hora mais prximo do seu objetivo. Criar jogos com roteiros no-lineares faz
o jogador sentir como se suas decises fizessem a diferena. Embora seja difcil de
se desenvolver um jogo assim, os resultados podem ser muito melhores.
Jogabilidade: A jogabilidade refere-se quo fcil e divertido jogar o produto.
Os primeiros 15 minutos so cruciais para os jogadores decidirem se eles
continuaram jogando. O jogo deve fornecer um balanceamento entre controles
fceis para jogadores novatos, e comandos mais complexos para os jogadores mais
experientes.
Replay: Refere-se ao desejo que os jogadores tm de jogar o jogo novamente aps
terem terminado-o uma vez. Para se realizar isso necessrio que o desenvolvedor
crie novas fases, ou novas armas, ou novos personagens que so liberados a cada
vez que o jogador termina o jogo.
Desafio: O jogo deve fornecer um desafio para os jogadores que sejam difceis
mas no impossvel para se cumprir. Jogos com objetivos muito fceis, ou muito
difceis, podem fazer com que o jogador mude para outro jogo melhor balanceado.
O jogo tambm pode fornecer diversos nveis de dificuldade e fases que aumentam
o nvel de dificuldade a cada level.
Recompensas: Recompensar os jogadores uma parte crucial do planejamento.
Ningum gostaria de passar dezenas de horas jogando apenas para ler Parabns
escrito na tela. necessrio alguma coisa a mais para que este jogador sinta
vontade de continuar jogando, como, por exemplo, adicionar cut scenes a cada
fase, ou aps um inimigo difcil de derrotar, o jogador ganhar itens extras e assim
por diante.
Salvamento e registro do jogo: Como o jogador vai salvar o seu progresso no jogo
tambm um ponto importante. Principalmente em jogos longos, muito
frustrante quando o jogador est no final da fase e acaba morrendo, tendo que
comear toda a fase denovo. necessrio que ele possa salvar seu jogo no meio do
caminho ou a hora que o jogador desejar, como por exemplo, um menu Salvar.
Outra caracterstica que pode fazer a diferena a possibilidade de se tirar fotos do
jogo, para que o jogador mostre a outras pessoas seu progresso e seus atributos.
1.2 Consideraes finais
Como foi visto, desenvolver um jogo muito mais do que somente programar e checar
se existem erros. Todas as pessoas que fazem parte do processo de desenvolvimento tm a
mesma importncia para o sucesso do jogo no mercado. Quanto mais unido a equipe for, mais
sucesso o jogo far. Essa uma das diferenas entre os jogos que vendem milhes e os que
no chegam nem a casa dos milhares.
2 PROGRAMAO BSICA DO XNA
Inicialmente, necessrio dentro do ambiente Windows clicar no boto Iniciar,
Programas, Microsoft XNA Game Studio 3.0, Microsoft Visual C# 2008 Express Edition. A
tela inicial do Visual C# 2008 ser aberta conforme ilustra a FIG. 2.

FIGURA 2 Tela inicial do Visual C# 2008 Express Edition
FONTE: Alexandre Jamarco

Uma vez inicializado Microsoft Visual C# 2008 Express Edition possvel criar um
novo projeto em XNA. Neste caso, preciso ativar em File, New Project, e clicar em
Windows Game (3.0). Em seguida, pode-se escrever o nome do projeto ou deixar o nome
padro dado pelo XNA, ser ento exibido uma palheta conforme exibe a FIG. 3..

FIGURA 3 criando um novo projeto XNA

Um novo projeto poder ser criado, e ento, sero criados tambm os arquivos pr-
compilados do XNA, a ilustrao desta etapa mostrada na FIG. 4.
Olhando o Solution Explorer ( direita) pode-se destacar os seguintes itens:
Content: a pasta aonde sero colocados todos os recursos do jogo, como por
exemplo: imagens, texturas, sons, efeitos, modelos 3d, entre outros.
Game.ico: o cone que ir aparecer no executvel do jogo.
Game1.cs: Este o arquivo principal, ele ser responsvel por inciar os objetos,
carregar as imagens, carregar os sons e desenhar e atualizar os quadros do jogo.
Program.cs: responsvel por efetuar a chamada do mtodo principal da classe
Game1.cs.


FIGURA 4 tela inicial do XNA

A estrutura geral de um jogo consiste em preparar o ambiente no qual o jogo ir rodar,
executar o loop do jogo at que os critrios de finalizao sejam encontrados e limpar o
ambiente.
A idia de ter a lgica do programa principal rodando em um loop crucial para um
jogo, porque o mesmo precisa estar sempre em execuo, com interao do usurio ou no
(coisa que no acontece nos aplicativos comerciais, aonde ele aguarda a entrada do usurio
para mostrar algo na tela).
O seguinte pseudocdigo mostra uma estrutura simplificada:

Inicialize grficos, entrada e som
Carregue os recursos
Comece o loop do jogo, em cada passo faa:
Pegue a entrada do usurio
Faa os clculos necessrios (IA, movimentos, deteco de coliso, etc.)
Checar se foram encontrados os critrios de finalizao
Se forem, ento encerrar loop.
Desenhar tela, gerar sons e responder aos controles
Finalize grficos, entrada e sons
Limpar recursos

Apesar de ser uma estrutura bem simples, d uma clara idia de como funciona um
loop de um jogo.
Antes do XNA, a estrutura do jogo tinha que ser desenvolvida do zero. Sendo assim,
o programador devia se preocupar com detalhes que no estavam ligados diretamente com o
jogo a ser desenvolvido. Quando um novo projeto criado, o arquivo Game1.cs herda da
classe Microsoft.XNA.Framework.Game todos o cdigo necessrio para gerar o espao que o
jogo ser desenhado, deixando para o programador somente a tarefa de se preocupar com o
desenvolvimento do jogo em si.
A classe Game1.cs contm seis mtodos pr-compilados:
public Game1(): o construtor padro. Responsvel por carregar a varivel
correspondente a placa de vdeo e tambm por informar qual ser a pasta utilizada
para os recursos do jogo (como padro, a pasta Content).
protected override void Initialize(): Responsvel por carregar toda a parte no-
grfica de um jogo. Como exemplo pode-se citar um arquivo XML com as
configuraes de um jogo ou um profile do jogador.
protected override void LoadContent(): Esse o mtodo responsvel por carregar
toda a parte grfica do jogo, desde figuras e texturas at modelos 3D.
protected override void UnloadContent(): Mtodo responsvel por descarregar do
sistema tudo o que foi carregado no mtodo LoadContent. Ele usado somente por
usurios mais experientes, pois essa parte toda feita pelo Garbage Colector do
.NET.
protected override void Update (Gametime gametime): um dos mtodos
principais do jogo. O mtodo responsvel por gerar as atualizaes do jogo. Sua
chamada feita constantemente, sendo possvel assim checar por teclas
pressionadas, coliso entre objetos, entre outras coisas.
protected override void Draw (Gametime gametime): Mtodo responsvel por
desenhar tudo no jogo. Esse mtodo muito parecido com o Update, mas sua
funo unicamente desenhar.
Olhando a classe Program.cs tem-se:
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main(string[] args)
{
using (Game1 game = new Game1())
{
game.Run();
}
}
}

A classe Program.cs o ponto de partida para qualquer projeto desenvolvido no XNA,
pois essa classe possui a funo Main. Essa funo tem somente duas linhas, uma para criar o
objeto da classe Game1.cs, e outra para chamar o mtodo Run desse objeto, que o mtodo
que inicializa todo o loop do jogo.
2.1 Ciclo de vida de um jogo em XNA
A classe Game1.cs comea definindo e criando os objetos que vo gerenciar a placa de
vdeo e tambm cria um objeto conhecido como SpriteBatch usado para desenhar textos e
imagens em 2D.
No construtor tambm declarado qual vai ser o caminho padro a ser utilizado pelo
Content Manager e a varivel graphics inicializada.

public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;

public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
}
2.1.1 O Gerenciador de Dispositivo Grfico (Graphic Device Manager)
Essa classe (que instanciada pelo objeto graphics) o ponto de entrada para
manusear a placa grfica. includo nessa classe mtodos, propriedades e eventos que
permitem ao programador gerenciar a placa de vdeo de maneira desejada.
Somente criando o objeto dessa classe uma tela do jogo gerada para o programador.
Toda as complexidades sobre funes e inicializao das funes 3D para gerenciar as
camadas da parte grfica esto escondidas do desenvolvedor.

2.1.2 O Content Pipeline Manager

uma das caractersticas mais interessantes do XNA, pois simplifica como o jogo
trata o contedo gerado por diferentes geradores de contedo.
Em um jogo feito fora do XNA, uma grande preocupao saber como carregar certos
tipos de dados, como udios, grficos e modelos 3D. necessrio saber onde est o contedo
a ser carregado, como o programa vai ler o contedo, se o programador possui as bibliotecas
certas para ler o contedo criado por aplicativos comerciais, entre outros.
O Content Pipeline processa todo o contedo para que ele possa ser entendido como
um todo pelo XNA. Ele abstrai muitos mtodos e importadores que so necessrios para a
leitura de certos tipos de dados e a partir disso e dos recursos ele gera um arquivo conhecido
pelo XNA.
A FIG. 5 apresenta uma forma de alto nvel do Content Pipeline:

FIGURA 5 Arquitetura do Content Pipeline.
FONTE: http://msdn.microsoft.com/en-us/library/bb447745.aspx

Quando se inclui algum contedo no XNA, usado um dos importadores de contedo
para se carregar o recurso. Esses importadores normalizam o contedo, e colocam em um
formato que ser fcil para se entender depois. Alguns dos tipos suportados pelos
importadores padres do XNA so:
Arquivos 3D: X (usado pelo DirectX) e FBX (arquivo de transporte, originalmente
criado pela Autodesk).
Arquivos de materiais: FX (arquivos de efeito (effects), que podem ser usados para
descrever os detalhes de renderizao de um modelo 3D, ou adicionar efeitos a
uma cena).
Arquivos 2D: BMP, DDS, DIB, HDR, JPG, PFM, PNG, PPN e TGA (os mais
comuns tipos de arquivos de imagem).
Arquivos de udio: O nico tipo de arquivo aceito o tipo XAP, que a extenso
de arquivos criados usando a ferramenta XACT (Cross-Platform Audio Creation
Tool Ferramenta de Criao de udio Multi-plataforma), uma ferramenta
contida no pacote do XNA, usada para criar sons, msicas e efeitos sonoros.
Depois que o importador processou o arquivo, ele ser lido e gerado um objeto que
pode ser manuseado em tempo de execuo.
Ento o jogo faz uso do Content Manager para ler esses objetos e poder us-los com
facilidade.
2.1.3 Mtodos de Inicializao
O necessrio ainda inicializar o projeto e carregar os recursos que sero necessrios.
Alm do construtor, o XNA tambm se utiliza de dois outros mtodos: Initialize e o mtodo
Load Content.
O mtodo Initialize chamado assim que o loop do jogo se inicia. Este o lugar certo
aonde devem ser iniciados recursos no-grficos, como preparar o contedo auditivo.
Os grficos so carregados em um mtodo diferente porque algumas vezes o jogo
necessita recarregar os grficos, como por exemplo, quando o usurio muda a resoluo da
tela ou muda de um modo janela para o modo tela cheia. O mtodo Load Content chamado
toda vez que o jogo precisar recarregar os grficos.
2.1.4 Finalizao
Toda a finalizao do jogo, por exemplo, eliminar recursos desnecessrios da
memria, so feitos pelo Garbage Collector do XNA. No entanto existe um mtodo para que
os programadores mais experientes utilizem no caso de rotinas particulares. Esse mtodo o
Unload Content. Como o mtodo Load Content, esse mtodo chamado toda vez que for
necessrio ao jogo descarregar os grficos que foram lidos.
2.1.5 Loop do jogo
A maior parte do processamento do jogo feito dentro deste loop. aqui que o jogo
checa se o jogador apertou algum boto, a inteligncia artificial, os movimentos, a coliso
entre objetos, entre outros. Depois, a tela desenhada.
A classe Game do framework do XNA disponibiliza dois mtodos que o loop interno
chama: Update, aonde includo os clculos necessrios para atualizar o jogo, e o mtodo
Draw, aonde so desenhados os componentes. Olhando este mtodo no projeto visto:

protected override void Update(GameTime gameTime)
{
if (GamePad.GetState(PlayerIndex.One).Buttons.Back ==
ButtonState.Pressed)
this.Exit();
base.Update(gameTime);
}

protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);
base.Draw(gameTime);
}

O primeiro ponto importante a discutir o uso do parmetro GameTime que
recebido nos dois mtodos. Esse parmetro crucial para toda a lgica do jogo, pois o jogo
precisa saber quanto tempo se passou desde que o loop foi chamado pela ltima vez para se
fazer os clculos necessrios, por exemplo, a posio de um objeto no jogo de acordo com sua
velocidade no jogo. Olhando a classe GameTime mais de perto teem-se as seguinte
propriedades:
ElapsedGameTime: Essa propriedade representa quanto de tempo (em jogo) que se
passou desde a ltima vez que o loop foi chamado. Trabalhar com o tempo em
jogo significa que o loop chamado um nmero fixo de vezes por segundo, ento
a lgica do jogo pode usar o tempo em jogo para se fazer os clculos necessrios.
ElapsedRealTime: essa propriedade mostra quanto de tempo real j se passou
desde que o loop foi chamado pela ltima vez
TotalGameTime e TotalRealTime: Essas duas propriedades representam o total de
tempo desde que o jogo comeou, fazendo a contagem em tempo de jogo
(unidades fixas por segundo) ou tempo real.
IsRunningSlowly: se o jogo est chamando o mtodo Update menos do que
esperado, essa propriedade automaticamente mudada para true, ento o jogo
pode fazer os ajustes necessrios.

Outro detalhe a mencionar o cdigo que vem como padro no mtodo update,
definindo um fim para o jogo no caso de o boto Back no controle do Xbox 360 ser
pressionado.
A classe GamePad permite acessar o estado do controle que estiver selecionado
(atravs da funo PlayerIndex). Neste caso, a classe no guarda nenhum dado, ou seja, a
informao exatamente sincronizada com a interao do usurio. Para sair do jogo
pressionando a tecla ESC preciso adicionar o seguinte cdigo na classe update:

if (Keyboard.GetState().IsKeyDown(Keys.Escape))
this.Exit();

Igualmente aconteceu com a checagem do controle, aqui checado se a tecla ESC foi
pressionada (IsKeyDown). Depois, o bloco If fecha o jogo em caso afirmativo.
O mtodo Draw, no princpio, somente inclui uma linha para limpar o dispositivo
grfico, colocando somente uma cor na tela.
Vale salientar que as linhas de cdigo base.draw(gameTime), base.update(gameTime)
e base.itilialize() servem para executar essas mesmas funes em classes que herdam da
classe DrawableGameComponent, ou seja, um componente que se pode desenhar na tela.
A programao em XNA muito simples. Mas no se deve confundir simplicidade
com facilidade. Na verdade, nenhum tipo de programao fcil, e o XNA no uma
exceo. A simplicidade vem dos mtodos pr-compilados que a ferramenta traz e tambm
atravs do Content Manager, uma das grandes inovaes do XNA para o desenvolvimento de
jogos. Com isso, o programador perde menos tempo tentando importar um objeto para o jogo
e pode investir mais tempo na programao em si.

3 PROGRAMAO 2D
Antes de se iniciar a programao 2D em si, necessrio entender alguns termos
usados para esse fim.
3.1 Termos Usados para Programao 2D
Sprite: Um sprite uma imagem 2D que pode ser manipulada independente do
resto da cena. Como o computador sempre desenha uma imagem 2D como um
retngulo, na maioria das vezes um sprite tem reas transparentes, o que da a
aparncia de o objeto no ser retangular. O termo animated sprite tambm faz
referncia a um sprite que a imagem muda em um perodo determinado de tempo,
para dar a aparncia de movimento (como por exemplo, um personagem andando).

FIGURA 6 Exemplo de Sprite
FONTE: http://sdb.drshnaps.com/display.php?object=7478

Textura: Este termo significa uma imagem 2D carregada sobre um modelo 3D, que
pode ser visto de qualquer ngulo, dependendo da posio do modelo e da posio
da cmera usada para renderizar a imagem. Texturas tambm podem ser tipos de
materiais (por exemplo, madeira) usados em superfcies.
Billboard: Este um termo usado na programao 3D que se refere a uma textura
mapeada em um plano que sempre perpendicular ao eixo da cmera. Usando
essas imagens uma forma efetiva de criar componentes como rvores ou tochas
na parede sem a necessidade de criar modelos muito detalhados. Essa tcnica
permite criar cenas maiores com o mesmo processamento de renderizao.

FIGURA 7 Exemplo de Textura.
FONTE: http://www.burningwell.org/gallery2/v/textures/buildings/pavingBrickCobbles

Background: Um jogo 2D normalmente composto de uma imagem de fundo com
sprites sobre ela. Quando este background uma imagem que se movimenta, ele
se chama Scrooling background, que foi uma tcnica muito usada nos jogos em
meados da dcada de 1990. A FIG. 10 exibe um exemplo de jogo que utiliza
Scrooling background.

FIGURA 8 Super Mario World para Super Nintendo. Exemplo de jogo que utiliza Scrooling background.
FONTE: http://wiiconsumer.files.wordpress.com/2008/08/super-mario-world.jpg
Tiles: Pequenas figuras que so usadas para compor imagens maiores,
normalmente mapas. Um exemplo de tiles so os tipos de jogos Role Playing
Game (RPG), aonde na maioria das vezes o jogo vem com um editor de mapas,
aonde o usurio pode construir novos mapas, utilizando diversos Tiles usados
pelo jogo.

FIGURA 9 Pokemon Yellow para GameBoy Color. Exemplo de jogo que utiliza Tiles.
3.2 Sistema de Coordenadas
No XNA, usado o mesmo sistema de coordenadas 2D usados em trigonometria nas
escolas.
A diferena principal entre este sistema da figura e o sistema utilizado nos jogos de
computador, que o eixo de origem no de baixo para cima, esquerda para direita. Na tela
de um computador o sistema de coordenadas tem seu incio na parte superior esquerda do
monitor e vai at a parte inferior direita.
Outro ponto importante que as coordenadas esto diretamente ligadas com a
resoluo da tela. Por exemplo, se o monitor estiver configurado para uma resoluo
800x600, isto significa que X (a largura da tela) ir ter 800 pixels e Y (a altura) ir ter 600
pixels, exatamente como foi sugerido na FIG. 11.

FIGURA 10 Um tringulo desenhado em um sistema de coordenadas 2D.

FIGURA 11 Tringulo desenhado usando o sistema de coordenadas 2D em um computador.

Outro ponto importante que as coordenadas esto diretamente ligadas com a
resoluo da tela. Por exemplo, se o monitor estiver configurado para uma resoluo
800x600, isto significa que X (a largura da tela) ir ter 800 pixels e Y (a altura) ir ter 600
pixels, exatamente como foi sugerido na figura Fig. 11.
3.3 Desenhando um sprite na tela
Para o exemplo, ser usado o logotipo do XNA.

FIGURA 12 figura que ser usada como exemplo.
FONTE: http://www.sharpgames.net/Portals/0//Images/Artigos/xna_thumbnail.png.

Para se carregar essa figura no XNA, depois de se ter criado o projeto, basta clicar
com o boto direito em Content (no Solution Explorer) e selecionar Add, depois Existing Item.
Depois selecionar a FIG. 12, e a mesma j ser importada para o XNA.

FIGURA 13 Carregando uma figura.

Pode-se perceber que depois que a figura foi carregada para o XNA, o Content
Pipeline fez o servio de transformar um tipo de arquivo (no caso um arquivo .png) para um
tipo de arquivo que o XNA entenda com facilidade. Usurios no conseguem ver como este
processo feito, mas sabe-se que ele concluiu o servio com xito se olharmos as opes
Content Importer e Content Processor. As opes do XNA Framework j estaro
automaticamente selecionadas.
Outro ponto importante o primeiro campo das propriedades, o campo Asset Name.
Esse ser o nome que o programa conhecer este arquivo, e no mais pelo nome do mesmo.
Por padro, este nome o mesmo nome do arquivo sem a extenso. Mas ele pode ser alterado,
se assim for desejado.

FIGURA 14 Imagem carregada com xito.

Para se desenhar um sprite na tela, necessrio declarar algumas variveis que vo
guardar certas propriedades da imagem:
Textura: Esta varivel ser do tipo Texture2D. Este tipo de varivel tem muitas
propriedade e mtodos especialmente feitos para tratar texturas. A textura
armazenada nesta classe como um grid de texels. Como pixels, que so a menor
unidade que pode ser desenhada na tela, texels so a menor unidade que pode ser
armazenada pelo quadro grfico. Ele tambm inclui cor e transparncia.
Tamanho: Ir guardar o tamanho do Sprite atravs da classe Vector2. Esta classe
possui dois componentes, X e Y, que sero usados para armazenar a largura e a
altura da imagem.
Posio: Guarda a posio da imagem utilizando novamente a classe Vector2. As
propriedades X e Y desta classe iro armazenar as coordenadas da tela para o
sprite.

Deve-se declarar essas variveis antes do construtor da classe. Ento se tem em
seguida, deve-se iniciar as variveis no-grficas no mtodo Initialize. As variveis sero a
posio e o tamanho da figura (position e size respectivamente).

protected override void Initialize()
{
position = new Vector2(0, 0);
size = new Vector2(64, 64);
}

FIGURA 15 Declarando as variveis necessrias antes do construtor da classe.
FONTE: Alexandre Jamarco.
3.3.1 Inicializando as variveis no-grficas.
Como foi visto anteriormente, a classe Vector2D guarda duas posies (X e Y). Neste
caso, a posio que a figura ser desenhada na tela e o tamanho da figura. No seria
necessria a criao de uma varivel para o tamanho, pois o XNA redimensiona a mesma em
tempo de compilao, mas por boas prticas de programao foi feito aqui.
O passo seguinte instanciar a figura que foi carregada varivel texture, que foi
criada exclusivamente para isso.

protected override void LoadContent()
{
spriteBatch = new SpriteBatch(GraphicsDevice);
texture = Content.Load<Texture2D>("xna_thumbnail");
}

No mtodo LoadContent() pode-se perceber que a varivel spriteBatch tambm
inicializada aqui por padro. Como foi visto, ela a responsvel por desenhar grficos 2D na
tela. Pode-se ver tambm que o parmetro que essa varivel recebe a varivel
correspondente a placa de vdeo.
A varivel texture est recebendo o contedo que foi carregado pelo Content
Manager. Entre os smbolos de maior e menor tem-se o tipo de varivel que (no caso, o tipo
de varivel Texture2D), e depois o nome do Asset da imagem a ser carregada.
O ltimo passo desenhar a imagem na tela. Como foi exposto no captulo anterior,
isto feito no mtodo Draw.

{
GraphicsDevice.Clear(Color.CornflowerBlue);
spriteBatch.Begin();
spriteBatch.Draw(texture, position, Color.White);
spriteBatch.End();
}

Neste ponto j possvel observar que na primeira linha (padro do XNA) a varivel
correspondente a placa grfica, se encarrega de limpar a tela e pint-la com uma nica cor
(CornFlowerBlue). Em seguida, o objeto spriteBatch iniciado para se comear a trabalhar
com ele. Sem est linha o objeto est inicializado, mas no est preparado para desenhar na
tela.
Na segunda linha (spriteBatch.draw) passado alguns parmetros: a textura a ser
desenhada, a posio que ser desenhada e a cor que ela ser misturada. Branco no caso
significa que ela no ter nenhum tipo de mistura e que conter somente a cor padro.
A ltima linha do objeto spriteBatch encerra suas aes atravs do mtodo End.
Depois disto, tem-se a figura desenhada na tela.


FIGURA 16 A figura desenhada na tela do jogo.

Como foi visto, o Garbage Collector se encarrega de limpar toda a memria, mas
sempre uma boa tcnica de programao fazer isso manualmente, para evitarmos sobrecargas
de memria indesejadas. Isto feito no mtodo UnloadContent(), atravs da funo
Dispose().

protected override void UnloadContent()
{
texture.Dispose();
spriteBatch.Dispose();
}

3.3.2 Movendo a figura na tela
Como na programao 2D no XNA se trabalho diretamente com as coordenadas na
tela, mover a imagem fcil. A nica coisa a se fazer desenh-la em um lugar diferente.
Incrementando a sua posio em X, a imagem ser desenhada mais direita. Decrescendo
esse valor, ela ser desenhada mais prxima da borda esquerda. Com o eixo Y, o sistema
parecido. Incrementando seu valor a figura descer na tela, e decrescendo esse valor, a
figura ficar mais perto do topo.
Como visto anteriormente, o lugar ideal para se fazer essas modificaes no mtodo
Update.
Escrevendo as linhas abaixo, a figura se mover a 1 PPF (pixel por frame) para a
direita e para baixo, at desaparecer atravs das bordas.

position.Y += 1;
position.X += 1;

Ainda h um problema: A figura desaparece quando sua posio (varivel position) for
maior do que as bordas, para resolver este problema e transformar o cdigo para ser mais
parecido com um jogo real, necessrio se criar uma quarta varivel chamada Velocity do
tipo Vector2D que vai armazenar a velocidade que a figura vai percorrer a tela (como visto
anteriormente, mas armazenando seus valores em uma varivel).
Texture2D texture;
Vector2 position;
Vector2 size;
Vector2 velocity;

Depois necessrio inicializar esta varivel no mtodo Initialize()

protected override void Initialize()
{
position = new Vector2(0, 0);
size = new Vector2(64, 64);
velocity = new Vector2(1, 1);
base.Initialize();
}

Para se organizar melhor o cdigo necessrio criar um novo mtodo, chamado
Move(). Ele ir ser o responsvel por mover a imagem na tela e alterar o seu rumo quando ela
for colidir com uma das bordas, alterando sua velocidade para um sentido contrrio.

public void Move(){
if (position.X + size.X > graphics.PreferredBackBufferWidth){
velocity.X = -velocity.X;
}
if (position.Y + size.Y > graphics.PreferredBackBufferHeight)
{
velocity.Y = -velocity.Y;

}
if (position.X < 0)
{

}
if (position.Y < 0)
{

}
position += velocity;
}

Analisando este mtodo, pode-se ver quatro condies If: na primeira, somado a
posio de X e o tamanho da figura em X e checado se esse valor maior do que a largura
da tela (chamada atravs da propriedade PreferredBackBufferWidth da varivel Graphics).
Em caso afirmativo, a velocidade, em X, invertida.
A segunda condio if faz a mesma comparao, mas usando o eixo Y como
referncia.
A terceira e quarta condies checam se a posio em X e Y, respectivamente, so
menores que 0, ou seja, se iriam sair pelas bordas esquerda e superior. Em caso afirmativo, a
velocidade invertida novamente. No final, a posio da figura recebe o valor dela mesma,
somado com a velocidade. O passo final inserir uma linha de cdigo para chamar o mtodo
Move dentro do mtodo Update.

protected override void Update(GameTime gameTime)
{
if (GamePad.GetState(PlayerIndex.One).Buttons.Back ==
ButtonState.Pressed)
this.Exit();

KeyboardState keyboardState = Keyboard.GetState();
if (keyboardState.IsKeyDown(Keys.Escape))
this.Exit();

Move();

}

O resultado final ser a figura se movendo diagonalmente e se mantendo dentro dos
limites.

FIGURA 17 A imagem se movendo pela tela e batendo nas bordas.
3.3.3 Utilizando o teclado para mover a imagem
Tambm possvel utilizar o teclado para controlar a imagem. Para se usar as setas,
necessrio apagar a chamada do mtodo Move que fica dentro do mtodo Update e programar
algumas linhas.

if (keyboardState.IsKeyDown(Keys.Up))
position.Y -= 1;
if (keyboardState.IsKeyDown(Keys.Down))
position.Y += 1;
if (keyboardState.IsKeyDown(Keys.Left))
position.X -= 1;
if (keyboardState.IsKeyDown(Keys.Right))
position.X += 1;

3.3.4 Utilizando o mouse para mover a imagem
O processo semelhante para controlar a figura utilizando o mouse. Primeiramente,
necessrio alterar a classe Program.cs, adicionando uma linha de cdigo para tornar o mouse
visvel durante a aplicao.

static class Program
{

static void Main(string[] args)
{
using (Game1 game = new Game1())
{
game.IsMouseVisible = true;
game.Run();
}
}
}

O prximo passo alterar o mtodo Update e fazer com que a posio atual da figura
receba a posio do mouse na tela.

MouseState mouse = Mouse.GetState();
position = new Vector2(mouse.X, mouse.Y);
3.3.5 Utilizando o joystick para mover a imagem
Como o XNA tambm foi desenvolvido para criar jogos para o Xbox 360, seria
necessrio introduzir o uso do controle do videogame para jogar os jogos no PC, e foi
exatamente o que a Microsoft fez.
Do mesmo modo que o framework disponibiliza as classes Mouse e Keyboard (para
mouse e teclado, respectivamente), tambm disponibilizado uma classe chamada GamePad
para controlar os recursos do controle conectado. Para se utilizar do mesmo, o mtodo Update
deve conter as linhas dizendo que a posio da figura deve receber a velocidade multiplicada
pela posio do controle analgico do joystick.

GamePadState gamePad = GamePad.GetState(PlayerIndex.One);
position.X += velocity.X * gamePad.ThumbSticks.Left.X;
position.Y -= velocity.Y * gamePad.ThumbSticks.Left.Y;

O exemplo utilizado, de como se mover uma figura pela tela, apesar de simples, da
uma ampla idia de como o XNA organiza os eventos em dois mtodos principais: o mtodo
Update e o mtodo Draw. Tambm foi visto como simples utilizar um joystick, o teclado ou
mesmo o mouse para mover a figura pela tela, exemplos que seriam muito difceis de realizar
na programao direta em DirectX ou OpenGL.

4 UTILIZANDO O XACT
Para inserir sons em projetos, necessrio utilizar o XACT, uma ferramenta para
criao de sons que acompanha o XNA.

FIGURA 18 Tela inicial do XACT.

Para utilizar os arquivos de som, o XNA usa o mesmo mtodo utilizado para tratar os
outros tipos de arquivos: o Content Pipeline. Os arquivos de som so somente outro tipo de
contedo. A nica diferena que arquivos de som precisam estar em um certo tipo de
arquivo, que criado atravs do XACT.
O primeiro passo criar um Wave Bank. Para se fazer isso, necessrio clicar com o
boto direito em Wave Bank (do lado direito da tela) e em seguida New Wave Bank.

FIGURA 19 Criando um novo Wave Bank.

Uma nova janela em branco aparecer no lado direito da tela. O prximo passo
adicionar arquivos de udio para este banco de ondas. Para adicionar os arquivos
necessrio clicar com o boto direito na tela em branco e escolher a opo Insert Wave Files.
Os arquivos de som que sero usados sero os arquivos Chord.wav e notify.wav (dois
arquivos padres do Windows). Eles podem ser encontrados por padro em
C:\WINDOWS\Media.
Depois de adicionar os arquivos que sero usados, o prximo passo criar um Sound
Bank. A maneira de se fazer isso parecida com a forma de como foi criado o Wave Bank. S
que ao invs de clicar em Wave Banks, necessrio clicar em Sound Banks.


FIGURA 20 Adicionando arquivos de som a um Wave Bank.
FONTE: Alexandre Jamarco.

FIGURA 21 A tela do programa, com o Wave Bank e o Sound Bank criados.

Depois de criado, o Sound Bank est pronto para receber arquivos de som. Para se
fazer isso, preciso clicar e arrastar os dois arquivos de som do Wave Bank para o painel
inferior esquerdo do Sound Bank (aonde existem as colunas Cue Name e Notes).
Para se criar um som com looping, que pode ser utilizado em msicas de fundo em
jogos necessrio ir ao painel superior esquerdo, depois clicar em notify. Agora no painel
direito, necessrio clicar em Play Wave para mostrar o painel de propriedades, aonde ser
marcada a opo Infinite, no frame Looping.

FIGURA 22 Ativando a opo Infinite nas propriedades.

Depois de todos esses processos, o nico passo restante salvar o arquivo XAP dentro
da pasta Content\Audio, que fica na pasta do projeto do XNA (o caminho padro Meus
documentos\Visual Studio 2008\Projects\WindowsGame1\WindowsGame1).
4.1 Adicionando ao jogo o udio criado
Para se usar o udio que foi criado, a primeira coisa a fazer incluir o projeto que foi
criado no XACT. O processo semelhante ao de adicionar figuras e imagens (boto direito
em Content, depois Add, e em seguida Existing Item).
Depois de incluir o arquivo XAP no contedo do jogo, necessrio criar variveis
para gerenciar os arquivos de udio. Os objetos necessrios sero:
AudioEngine: este objeto uma referncia do programa ao servios de som do
computador. Ele usado principalmente para ajustar configuraes padres e
usado como parmetro para a criao dos dois outros objetos. Quando se for
criar este objeto, necessrio passar o nome do projeto que est no Content
Manager, que, por padro, o mesmo nome que foi salvo o projeto no XACT.
WaveBank: uma coleo de arquivos Wave (arquivos de som com extenso
WAV). Para instanciar esta classe, necessrio passar como parmetro o
objeto AudioEngine (criado anteriormente) e o arquivo Wave Bank que foi
criado no XACT (por padro, o nome do arquivo Wave Bank.xwb).
SoundBank: uma coleo de sons que referenciam arquivos armazenados no
Wave Bank, bem como as propriedades que possuem os detalhes dos arquivos e
como tocar esses arquivos e os mtodos que permitem ao programador definir
quando ele ser iniciado, pausado, e assim por diante.
O primeiro passo adicionar essas trs variveis no mesmo local aonde as outras esto
declaradas.

AudioEngine audioEngine;
WaveBank waveBank;
SoundBank soundBank;

O prximo passo instanciar essas variveis no mtodo Initialize.

audioEngine = new AudioEngine(@"Content\GameAudio.xgs");
waveBank = new WaveBank(audioEngine, @"Content\Wave Bank.xwb");
soundBank = new SoundBank(audioEngine, @"Content\Sound Bank.xsb");

Ao invs de usar a chamada do Content Pipeline (igual feito com a imagem, usando
o mtodo Content.Load<>) usado a forma tradicional de chamada do construtor da classe a
ser instanciada.
Contudo, o Content Pipeline ainda est envolvido. Em tempo de compilao, ele usa o
arquivo gerado pelo XACT (de extenso xap) e gera trs tipos de arquivos: Um arquivo de
extenso xgs (responsvel pelo motor principal do udio), um de extenso xwb ( gerado um
arquivo para da Wave Bank no projeto) e um arquivo do tipo xsb (tambm um arquivo para
cada Sound Bank no projeto).
necessrio perceber tambm que para cada varivel da classe WaveBank e
SoundBank necessrio passar como parmetro a varivel do tipo AudioEngine. Por esta
razo, esta ltima deve ser instanciada antes das demais.
O ltimo passo colocar os sons para tocar em determinados momentos do jogo.
public void Move()
{
if (position.X + size.X > graphics.PreferredBackBufferWidth)
{
soundBank.PlayCue("chord");
}
if (position.Y + size.Y > graphics.PreferredBackBufferHeight)
{
soundBank.PlayCue("notify");
}
if (position.X < 0)
{
soundBank.PlayCue("chord");
}
if (position.Y < 0)
{
soundBank.PlayCue("notify");
}
position += velocity;
}

O mtodo Move foi atualizado para tocar o som notify cada vez que a imagem bater
nas bordas laterais e tocar o som chord cada vez que a imagem atinge as bordas superior e
inferior.


O XACT um programa contido no pacote do XNA e facilita muito a insero de
msica e efeitos sonoros nos jogos. Apesar de se ter algum trabalho para criar o projeto e
depois inseri-lo no jogo, ainda uma maneira simples e fcil de usar, se comparada com
outras ferramentas de desenvolvimento de jogos.

5 CRIANDO UM JOGO 2D
Para se comear a criao de um jogo, necessrio, como foi falado anteriormente,
que se planeje o mesmo. Muitos projetos falham porque no h um planejamento adequado, o
que leva o jogo a ficar sem um objetivo definido ou mesmo finalizando o projeto, mas com
uma idia totalmente diferente da inicial.
5.1 Planejando o jogo
Pode-se usar como tema principal a frase: Voc um explorador intergalctico e est
preso em um campo de asterides. O jogo ser um desafio, que faz o jogador desviar dos
asterides que passam pela tela. como um clone do famoso jogo Asteroids.


FIGURA 23 Tela de abertura do jogo Asteroids.
FONTE: http://www.maniacworld.com/asteroids-2.jpg.

Este tipo de jogo possui um conceito simples, aonde o jogador precisa desviar de um
grupo de obstculos na tela e, quanto mais tempo ele ficar sem colidir, mais pontos ele ganha.
Alm disso, a quantidade de meteoros aumenta com o passar do tempo, fazendo o desafio
ficar cada vez mais e mais difcil.
Como parte do planejamento, necessrio definir as regras e as constantes do jogo:
O jogador livre para mover-se pela tela, sem, no entanto sair pelas bordas.
Os meteoros aparecem no topo da tela e se movem para baixo com ngulo e
velocidade aleatrios. Depois de algum tempo, um novo meteoro adicionado
quantidade mxima de meteoros na tela.
A pontuao dada de acordo com a quantidade de meteoros na tela.
Se o jogador colidir com um meteoro, a pontuao reiniciada e o jogo volta ao
incio com a quantidade inicial de meteoros.
Valores como a quantidade inicial de meteoros e quanto tempo levar antes que um
novo meteoro adicionado no foram especificados porque estes so parmetros do jogo.
Os objetos como a espaonave, os meteoros e a pontuao devem ser detalhados
tambm antes de se iniciar a programao em si, porque cada um deles possui caractersticas e
comportamentos diferentes. Por exemplo, os meteoros caem, o jogador controla a nave e a
pontuao aumenta de acordo com a quantidade de meteoros.
O jogo ter somente trs efeitos sonoros: A msica de fundo, um som que tocar
quando um novo meteoro adicionado e um som que ser executado com o jogador colidir.
Como ser usado o controle do xbox, tambm ser usado o recurso de vibrar o controle
quando o jogador colidir.
5.2 Desenhando a imagem de fundo
Primeiramente, ser criado um novo projeto chamado JogoExemplo. Em seguida, ser
adicionado pasta Content a figura que representar a imagem de fundo
(SpaceBackground.dds).

FIGURA 24 Imagem de fundo adicionada ao projeto.

Agora preciso carregar esta figura e desenh-la na tela, fazendo com que a imagem
preencha toda a tela do jogo.
Primeiramente, como foi visto, preciso criar uma varivel para guardar a imagem.
Tambm ser criado uma varivel do tipo Rectangle, que guardar as dimenses da tela. Em
seguida, ser carregada a imagem nesta varivel (atravs do mtodo LoadContent). O ltimo
passo desenhar a imagem na tela, como foi visto no captulo anterior.

private Texture2D backgroundTexture;
private Rectangle screen;

protected override void LoadContent()
{
spriteBatch = new SpriteBatch(GraphicsDevice);
Services.AddService(typeof(SpriteBatch), spriteBatch);

screen = new Rectangle(0, 0,
graphics.GraphicsDevice.Viewport.Width,
graphics.GraphicsDevice.Viewport.Height);

backgroundTexture = Content.Load<Texture2D>("SpaceBackground");

}

{
GraphicsDevice.Clear(Color.Black);
spriteBatch.Draw(backgroundTexture, screen, Color.LightGray);
spriteBatch.End();
}

Como pode ser visto, a varivel screen armazena as dimenses da tela. O tipo
Rectangle recebe quatro parmetros que receberam os valores iniciais (0 e 0) e os valores
mximos de largura e de altura (width e height respectivamente). Estes quatro valores foram
usados no mtodo Draw do objeto spriteBatch para informar que a figura deveria ser
desenhada preenchendo a tela toda.
Se o jogo for compilado neste momento, somente a imagem de fundo do espao ser
mostrada na tela.


FIGURA 25 A figura de fundo desenhada na tela.

Pode-se ver que, mesmo a figura tendo dimenses diferentes da resoluo do jogo, ela
se encaixa perfeitamente na tela.
5.3 Criando a espaonave
O jogador ser representado como uma pequena nave que pode ser controlada usando
o controle do Xbox 360, bem como o teclado do computador. A mesma imagem possui a
textura da nave e do meteoro, portanto, s necessrio adicionar esta figura ao projeto.

FIGURA 26 Textura da nave e do meteoro que ser includa no projeto.
FONTE: Alexandre Lobo (2008).

Essa imagem inserida e instanciada do mesmo jeito que as demais. Criando-se uma
varivel de nome texture e carregando a imagem nessa varivel no mtodo LoadContent.
Agora, ser criada a classe que representar o jogador no projeto. Isto feito
adicionando uma classe GameComponent no jogo. O que difere esta classe de classes normais
que ela j possui os mtodos pr-compilados da classe Game1.cs e ele herda da classe
GameComponent.
Para se fazer isso preciso clicar com o boto direito em cima do nome do projeto no
Solution Explorer, escolher a opo Add New Item, selecionar a opo GameComponent,
renomear a classe para Ship.cs e clicar em Add.

FIGURA 27 Adicionando uma nova classe Game Component.

Esta nova classe derivada da classe GameComponent. Esta classe estar visvel para
o jogo, mas preciso desenh-la na tela. Ento o necessrio alterar a classe base para a
classe DrawableGameComponent, que um componente que permite usar o mtodo Draw.

public class Ship : Microsoft.Xna.Framework.DrawableGameComponent

Esta classe vai copiar a parte da textura que contm a figura da nave. Para isso, ela
precisar da textura em si, das coordenadas onde a nave est na textura e as coordenadas na
tela aonde ela precisa ser renderizada.
Quanto ao comportamento do componente, ele somente precisar mover-se de acordo
com o controle do Xbox ou com os comandos do teclado e verificar se a nave continua na
tela. Sabendo disso, pode-se afirmar que h dois passos bem definidos: o mtodo Draw, o
qual desenhar a figura na tela e o mtodo Update, que atualizar a tela de acordo com os
comandos do joystick ou do teclado.

public class Ship : Microsoft.Xna.Framework.DrawableGameComponent
{
protected Texture2D texture;
protected Rectangle spriteRectangle;
protected Vector2 position;

protected const int SHIPWIDTH = 30;
protected const int SHIPHEIGHT = 30;

protected Rectangle screen;

public Ship(Game game, ref Texture2D newTexture, Rectangle newScreen)
: base(game)
{
texture = newTexture;
position = new Vector2();
screen = newScreen;

spriteRectangle = new Rectangle(31, 83, SHIPWIDTH, SHIPHEIGHT);
}

public void PutinStartPosition()
{
position.X = screen.Width / 2;
position.Y = screen.Height - SHIPHEIGHT;
}

public override void Update(GameTime gameTime)
{
GamePadState gamePadState = GamePad.GetState(PlayerIndex.One);
position.Y += (int)((gamePadState.ThumbSticks.Left.Y * 3) * -2);
position.X += (int)((gamePadState.ThumbSticks.Left.X * 3) * 2);

KeyboardState keyboardState = Keyboard.GetState();

if (keyboardState.IsKeyDown(Keys.Up))
{
position.Y -= 5;
}

if (keyboardState.IsKeyDown(Keys.Down))
{
position.Y += 5;
}

if (keyboardState.IsKeyDown(Keys.Left))
{
position.X -= 5;
}

if (keyboardState.IsKeyDown(Keys.Right))
{
position.X += 5;
}

if (position.X < 0)
{
position.X = 0;
}

if (position.X > screen.Width - SHIPWIDTH)
{
position.X = screen.Width - SHIPWIDTH;
}

if (position.Y < 0)
{
position.Y = 0;
}

if (position.Y > screen.Height - SHIPHEIGHT)
{
position.Y = screen.Height - SHIPHEIGHT;
}

}

public override void Draw(GameTime gameTime)
{

SpriteBatch sBatch =
(SpriteBatch)Game.Services.GetService(typeof(SpriteBatch));

sBatch.Draw(texture, position, spriteRectangle, Color.White);

}

public Rectangle GetBounds()
{
return new Rectangle((int)position.X, (int)position.Y, SHIPWIDTH,
SHIPHEIGHT);
}
}

Nas trs primeiras linhas da classe, so declarados os objetos que representaro a
textura da nave, um objeto do tipo Rectangle que vai conter a posio da nave na imagem, e a
posio da figura na tela. Tambm foram criadas duas constantes que recebero a largura e a
altura da nave. Uma varivel local que armazenar o tamanho da tela do jogo tambm foi
criada.
No construtor da classe, so recebidos trs parmetros: A classe Game em si, a textura
da nave e do meteoro (sendo passado por referncia usando ref) e a varivel que contm o
tamanho da tela.
O prximo mtodo (PutinStartPosition) servir apenas para posicionar a nave no
centro da tela no inicio do jogo e quando um meteoro acertar o jogador.
No mtodo Update como foi visto no captulo anterior, o controle da nave pode ser
feito tanto pelo joystick como pelo teclado. Tambm checado se a nave continua dentro da
tela. Vale notar aqui que programadores mais experientes usam de classes prontas do XNA
para fazer o servio. Como por exemplo, para checar se a nave continua dentro das bordas da
tela, ao invs de usar quatro Ifs, eles usam as seguintes linhas:

position.X = MathHelper.Clamp(position.X, 0, screen.Width - SHIPWIDTH);
position.Y = MathHelper.Clamp(position.Y, 0, screen.Height - SHIPHEIGHT);

O mtodo Clamp da classe MatHelper recebe trs valores: o primeiro o valor atual, o
segundo o valor mnimo e o terceiro o valor mximo. Se o valor atual estiver entre o
mximo e o mnimo, nada acontecer. Se o valor for menor do que o mnimo, o valor mnimo
ser atribudo varivel. Se o valor for maior do que o valor mximo (ltimo parmetro) a
varivel receber o valor mximo.
Voltando ao cdigo da classe Ship, o prximo passo usar a classe Draw para
desenhar a figura na tela. Para isso ser necessrio usar o objeto SpriteBatch. Vale notar que a
classe Draw no cria novo objeto, como foi feito para desenhar a imagem de fundo. Como
boa prtica de programao, no se deve ficar criando e destruindo objetos SpriteBatch
porque isso poderia colocar a aplicao em risco de travar ou mesmo atrapalhar a
performance. O XNA possui outra maneira de se fazer isso e usando o GameServices.
GameServices nada mais do que um servio que est disponvel a qualquer classe
que possui uma referncia para o jogo.
No caso do cdigo da classe Ship, o mtodo Draw procurar por um SpriteBatch
diretamente no GameServices e us-lo para desenhar na tela.
Para se fazer isso, tambm necessrio adicionar o SpriteBatch ao GameServices.
Para isso necessrio digitar a seguinte linha logo depois da criao do SpriteBatch no
mtodo LoadContent da classe principal:

Services.AddService(typeof(SpriteBatch), spriteBatch);

O mtodo AddService recebe dois valores: o tipo do servio que ser adicionado, e o
objeto daquele servio.
Voltando ao cdigo da classe Ship, o objeto SpriteBatch pego do GameServices
desenhar na posio desejada (position) a parte da imagem que se deseja (usando a varivel
spriteRectangle).
O ltimo mtodo (GetBounds) retornar a posio atual da nave na tela. Este mtodo
ser usado quando se for criar o detector de colises.
A classe Ship est pronta, agora necessrio cri-la na classe Game1.cs na declarao
de variveis.

private Ship player;

Agora ser criado na classe principal um mtodo chamado Start que ser o passo
inicial para se iniciar os componentes do jogo.

private void Start()
{
if (player == null)
{
player = new Ship(this, ref texture, screen);
Components.Add(player);
}
player.PutinStartPosition();
}

A classe Components uma classe padro do XNA, que conter uma coleo de Game
Components e usada para facilitar o trabalho quando feita a checagem de coliso, ou, por
exemplo, quando o jogo reiniciado e os componentes so recolocados no lugar.
O mtodo Start ser chamado no mtodo Update da classe principal.

if (player == null)
Start();

O ltimo detalhe que falta que a ltima linha do mtodo Draw (base.draw) precisa
estar entre os mtodos Begin e End do SpriteBatch.

spriteBatch.Draw(backgroundTexture, screen, Color.LightGray);
spriteBatch.End();

Depois disso, se o jogo for compilado ser mostrado a nave controlada pelo jogador na
tela, com o fundo tambm desenhado.

FIGURA 28 A nave desenhada na tela.

5.4 Desenhando os meteoros
Os mesmos conceitos usados na criao da nave tambm sero usados para criar os
meteoros. A nica diferena que eles no so controlados pelo jogador, e sim possuem uma
posio inicial e velocidade aleatrias.

public class Meteor : Microsoft.Xna.Framework.DrawableGameComponent
{
protected Texture2D texture;
protected Rectangle spriteRectangle;
protected Rectangle screen;
protected Vector2 position;
protected int YSpeed;
protected int XSpeed;
protected Random random;

protected const int METEORWIDTH = 45;
protected const int METEORHEIGHT = 45;

public Meteor(Game game, ref Texture2D newTexture, Rectangle
newScreen)
: base(game)
{
texture = newTexture;
screen = newScreen;
position = new Vector2();
spriteRectangle = new Rectangle(20, 16, METEORWIDTH,
METEORHEIGHT);

random = new Random(this.GetHashCode());
PutinStartPosition();
}

protected void PutinStartPosition()
{
position.X = random.Next(screen.Width - METEORWIDTH);
position.Y = 0;
YSpeed = 1 + random.Next(9);
XSpeed = random.Next(3) - 1;
}

public override void Draw(GameTime gameTime)
{
SpriteBatch sBatch =
(SpriteBatch)Game.Services.GetService(typeof(SpriteBatch));

sBatch.Draw(texture, position, spriteRectangle, Color.White);

}

{
if ((position.Y >= screen.Height) || (position.X >= screen.Width)
|| (position.X < 0))
{
PutinStartPosition();
}
position.Y += YSpeed;
position.X += XSpeed;

}

public bool CheckColision(Rectangle rect)
{
Rectangle spriteRect = new Rectangle((int)position.X,
(int)position.Y,
METEORWIDTH, METEORHEIGHT);
return spriteRect.Intersects(rect);
}
}

Nas declaraes de variveis so declaradas, como na classe Ship, a textura, a posio
na figura que est a imagem que se deseja (no caso, a imagem do meteoro), a varivel que
armazena as coordenadas da tela e a posio do meteoro na tela.
Alm dessas, so declaradas outras trs variveis: a velocidade em X e em relao ao
eixo Y e uma varivel do tipo Random, que ser usada para a velocidade e a posio. Tambm
foram criadas duas constantes com a largura e a altura do meteoro, respectivamente.
No construtor da classe as variveis so iniciadas e o mtodo PutinStartPosition
chamado. Este mtodo coloca o meteoro na posio 0 de Y e em qualquer posio em relao
ao eixo X, alm da velocidade ser aleatria tambm.
O mtodo Draw idntico ao da classe Ship (usando os servios do jogo para
desenhar o meteoro na tela).
O mtodo Update checa se o meteoro ainda est visvel na tela. Se no, um novo
meteoro criado. Este mtodo tambm movimenta o meteoro.
O ltimo mtodo (CheckColision) checa se ouve coliso entre o retngulo spriteRect
(que nada mais do que o meteoro) e o retngulo rect (que passado como parmetro e
receber o retngulo da nave). Isso feito atravs do mtodo Intersects da classe Rectangle
que recebe um parmetro (outro retngulo) e checa se ouve uma interseco entre os mesmos.
Agora necessrio declarar a quantidade inicial de meteoros. A declarao feita na
classe principal (Game1.cs).

private const int STARTMETEORCOUNT = 10;

Para adicionar os meteoros no jogo, preciso adicion-los atravs da classe Start, a
mesma que foi usada para adicionar a nave.

for (int i = 0; i < STARTMETEORCOUNT; i++)
{
Components.Add(new Meteor(this, ref texture, screen));
}

Depois disso, j ser possvel compilar o jogo e verificar os meteoros caindo e a nave
podendo ser manipulada pelo jogador.

FIGURA 29 A nave e os meteoros desenhados na tela.

Apesar de toda a parte grfica estar pronta, ainda no h coliso entre a nave e os
meteoros.
5.5 Desenvolvendo a lgica do jogo
Os componentes visveis do jogo esto praticamente prontos. O que resta faz-los
trabalharem juntos.
H o mtodo Start que inicializa os componentes. preciso agora criar um mtodo
chamado DoGameLogic que Ir executar a lgica do jogo em si. Se houver alguma coliso os
meteoros so retirados e reinicializados e a nave recolocada no lugar inicial.

private void DoGameLogic() {
bool hasColision = false;
Rectangle shipRectangle = player.GetBounds();

foreach (GameComponent gc in Components){
if (gc is Meteor){
hasColision = ((Meteor)gc).CheckColision(shipRectangle);
if (hasColision)
{
RemoveAllMeteors();
Start();

break;
}
}
}

}

Na primeira linha criado uma varivel booleana que dir se houve coliso ou no. A
segunda varivel recebe a posio atual da nave.
A coleo de componentes ser iterada usando foreach. Se a posio atual contiver um
meteoro, checado se houve a coliso entre o mesmo e a nave do jogador, atravs do mtodo
local CheckColision. Se houver coliso, todos os meteoros so retirados atravs do seguinte
mtodo.

private void RemoveAllMeteors()
{
for (int i = 0; i < Components.Count; i++)
{
if (Components[i] is Meteor)
{
Components.RemoveAt(i);
i--;
}
}
}
Em seguida, os meteoros e a nave do jogador so reiniciados com a chamada do
mtodo Start novamente. Agora, o prximo passo chamar o mtodo DoGameLogic dentro
do mtodo Update para o jogo realizar a lgica a cada frame.
Para tornar o jogo mais interessante, necessrio adicionar mais dificuldade conforme
o tempo passa. Para se fazer isso, o jogo adicionar um meteoro na tela a cada 5 segundos.
necessrio criar algumas variveis na classe principal primeiro.

private const int ADDMETEORTIME = 5000;
private int lastTickCount;
private int rockCount;

A constante ADDMETEORTIME o nmero em milisegundos que levar para que o
jogo adicione outro meteoro, no caso h 5 segundos antes que isso acontea. Com as outras
variveis, necessrio inicializar seus atributos no mtodo Start, para que os mesmos sejam
reiniciados a cada vez que o jogador colidir.

lastTickCount = System.Environment.TickCount;
rockCount = STARTMETEORCOUNT;

A primeira varivel armazena a quantidade em milisegundos desde que a aplicao
iniciou, e a segunda armazena a quantidade inicial de meteoros.
Agora criar um mtodo que verifique o tempo para adicionar um novo meteoro a
cada intervalo.

private void CheckforNewMeteor()
{
if ((System.Environment.TickCount - lastTickCount) > ADDMETEORTIME)
{
Components.Add(new Meteor(this, ref texture, screen));
rockCount++;
}
}

Se o tempo em milisegundos atual subtraindo o tempo em milisegundos de quando o
jogo inicial for maior do que 5000 (que o valor para adicionar um novo meteoro e que est
na constante) ento o tempo inicial passa a ser o momento atual e adicionado um novo
meteoro coleo de componentes.
O ltimo passo restante chamar o mtodo CheckforNewMeteor na ltima linha do
mtodo DoGameLogic.

5.6 Adicionando sons ao jogo
Como foi visto no captulo 4, para tornar o jogo mais atraente, necessrio adicionar
efeitos musicais. Para este jogo, so usados trs tipos de sons:
explosion.wav: Um som de exploso, que ser usado quando houver uma
coliso.
backmusic.wav: A msica de fundo do jogo.
newmeteor.wav: Um som que toca quando um novo meteoro adicionado ao
jogo.
Depois de criar um novo projeto no XACT e adicionar os arquivos, preciso salvar o
projeto como audio.xap para depois adicion-lo no projeto do XNA. Para tornar o trabalho
mais fcil, o mesmo processo que foi usado para os outros componentes do jogo ser usado
com o som tambm, a nica diferena que os efeitos sonoros no um componente visvel,
ou seja, no necessrio mudar a classe base.

public class AudioComponent : Microsoft.Xna.Framework.GameComponent
{
private AudioEngine audioEngine;
private WaveBank waveBank;
private SoundBank soundBank;

public AudioComponent(Game game)
: base(game)
{

}

public override void Initialize(){

audioEngine = new AudioEngine(@"Content\audio.xgs");
waveBank = new WaveBank(audioEngine, @"Content\Wave Bank.xwb");
if (waveBank != null)
soundBank = new SoundBank(audioEngine, @"Content\Sound Bank.xsb");
base.Initialize();

}

public override void Update(GameTime gameTime){
audioEngine.Update();
}

public void PlaySound(string sound){
soundBank.PlayCue(sound);
}
}

Trs variveis so declaradas inicialmente (igual foi feito no captulo anterior). As
variveis so inicializadas e atualizadas quando necessrio. O mtodo PlaySound executa o
som que for passado como parmetro.
Na classe principal, criado uma varivel do tipo AudioComponent, um objeto da
classe que manipula o som.

private AudioComponent audioComponent;

Em seguida, no mtodo Initialize a varivel inicializada, o componente adicionado
coleo e comeado a executar a msica de fundo.

audioComponent = new AudioComponent(this);
Components.Add(audioComponent);
audioComponent.PlaySound("backmusic");

A linha a seguir deve ser colocada no mtodo DoGameLogic, dentro do If, para que, se
houver coliso, tocar o som desejado.

audioComponent.PlaySound("explosion");

O ltimo som chamado dentro do mtodo CheckforNewMeteor, para ser tocado
quando um novo meteoro adicionado.

audioComponent.PlaySound("newmeteor");
5.7 Adicionando um placar ao jogo
O placar neste jogo somente mostrar o nmero atual de meteoros na tela. O placar
normalmente um componente do jogo, mas neste caso, por ele ser simples, ele somente ser
desenhado na tela atravs do mtodo Draw, sem a necessidade da criao de uma nova classe.
O primeiro passo adicionar a fonte que ser usada ao projeto. Depois de compilada
ela j estar em um formato pronto (.spritefont) para ser executada pelo Content Manager.

private SpriteFont gameFont;

No mtodo LoadContent ser realizado o carregamento da fonte na varivel, idntico
ao processo que feito aos componentes 2D.

gameFont = Content.Load<SpriteFont>("font");

O nico passo restante fazer com que o SpriteBatch desenhe a fonte na tela. Para isso
ele ser inicializado novamente (atravs da instruo Begin).

spriteBatch.DrawString(gameFont, "rocks: " + rockCount.ToString(),
new Vector2(15, 15), Color.YellowGreen);
spriteBatch.End();

O primeiro parmetro se refere ao arquivo da fonte que ser usado. O segundo
parmetro o texto que ser escrito na tela. O quarto e o quinto parmetros so a posio do
texto na tela e a cor, respectivamente.

FIGURA 30 Jogo exemplo com o texto marcando a quantidade de meteoros no topo esquerdo da tela

5.8 Fazendo o controle vibrar
Para tornar o jogo mais interessante, esta funcionalidade est disponvel atravs do
framework do XNA. Alm do som de exploso quando a nave colidir com algum meteoro, o
controle do Xbox ir vibrar para dar uma sensao mais realista de impacto.
Para isso, ser criado um novo componente do jogo que ajudar na criao deste
efeito.

public class RumblePad : Microsoft.Xna.Framework.GameComponent
{
private int time;
private int lastTickCount;

public RumblePad(Game game)
: base(game)
{
}

{
if (time > 0)
{
int elapsed = System.Environment.TickCount - lastTickCount;
if (elapsed >= time)
{
GamePad.SetVibration(PlayerIndex.One, 0, 0);
}
}
}

protected override void Dispose(bool disposing)
{
GamePad.SetVibration(PlayerIndex.One, 0, 0);
base.Dispose(disposing);
}

public void Rumble(int newTime, float leftMotor, float rightMotor)
{
time = newTime;
GamePad.SetVibration(PlayerIndex.One, leftMotor, rightMotor);
}
}

Nas duas primeiras linhas, duas variveis so criadas. A que guardar o tempo, e a que
guardar quando ocorreu a ultima vibrao do controle.
O Mtodo Dispose far o controle parar de vibrar se algo ocorrer de errado no jogo e
ele subitamente se encerrar.
O Mtodo Rumble chamado no mtodo DoGameLogic da classe principal, no caso
de haver tido coliso.

private void DoGameLogic()
{
bool hasColision = false;
Rectangle shipRectangle = player.GetBounds();

foreach (GameComponent gc in Components)
{
if (gc is Meteor)
{
hasColision = ((Meteor)gc).CheckColision(shipRectangle);
if (hasColision)
{
RemoveAllMeteors();
audioComponent.PlaySound("explosion");
rumblePad.Rumble(500, 1.0f, 1.0f);
Start();

break;
}
}
}
CheckforNewMeteor();
}

Os trs parmetros do mtodo Rumble so: O tempo que o controle ficar vibrando
(em milisegundos), e a fora da vibrao no lado esquerdo e no lado direito do controle.
O mtodo Update da classe RumblePad serve para parar a vibrao depois que o
tempo definido (500 milisegundos) for atingido.
Ainda necessrio criar a varivel da classe RumblePad, inicializ-la no mtodo
Initialize e adicionar a varivel aos componentes do jogo.
5.9 Fazendo melhorias no jogo
Supondo que est seja a verso inicial do jogo, ainda podem ser feitos muitas
implementaes nele como contador de vidas, tela inicial, modos de dificuldade (fcil, normal
ou difcil), modo para dois jogadores, modo para jogar em rede ou on-line, entre outras. Essas
melhorias podem ser colocadas em verses futuras do jogo ou em atualizaes.
Este jogo serve para demonstrar algumas caractersticas interessantes do XNA, como
por exemplo, coliso entre duas imagens, coliso com as bordas do jogo, insero de novos
componentes em tempo de execuo e reinicializao do jogo no caso de coliso. Todas essas
caractersticas so usadas em jogos comerciais tambm, e foi mostrado como muito mais
simples se fazer isso utilizando o XNA.

CONCLUSO
A programao de jogos hoje uma das reas que mais cresce no mundo em termos
financeiro e pessoal. Todos os anos, as empresas de desenvolvimento contratam milhares de
profissionais para trabalhar nos seus projetos a mdio e longo prazo. Infelizmente, no Brasil,
essa rea de programao de jogos no bem explorada, nem pelo mercado de
desenvolvimento, nem pelas faculdades, que poderiam usar uma ferramenta como o XNA
para ensinar matemtica e programao ao mesmo tempo.
Programao de jogos, longe do que muitos pensam, no somente sentar em uma
mesa e fica jogando horas e horas a procura de erros de cdigo e de melhorias. um tipo de
desenvolvimento muito mais avanado do que qualquer programa comercial, pois como foi
falado, um aplicativo s interage com o usurio e espera uma resposta do mesmo, ficando
inativo o resto do tempo. Com um jogo acontece diferente. O usurio interagindo ou no, o
jogo est sempre em execuo, fazendo clculos e desenhando os objetos nas coordenadas
corretas, todo o tempo.
O XNA veio para simplificar a programao de jogos, atravs de mtodos prontos e
classes desenvolvidas especialmente para esse fim. Um outro objetivo do XNA incentivar o
desenvolvimento de jogos por amadores e entusiastas da rea, pois em sua maioria, esses
desenvolvedores no possuem grandes habilidades na programao em cdigo nativo, se
utilizando na maioria das vezes de ferramentas, como o XNA.
A Microsoft, com uma jogada de mestre, incentiva os desenvolvedores tambm a usar
essa ferramenta para conceber jogos para o seu videogame, o Xbox 360. Um dos incentivos
vem financeiramente, pois o desenvolvedor pode vender seus jogos pela rede online do Xbox,
aonde uma parte do dinheiro vai para ele, e a outra parte para a Microsoft. Com isso ela
incentiva tambm pessoas a comprarem seu videogame.
Pode-se ver que o XNA veio para ficar, pois j existem muitas competies que
atraem as pessoas para utilizar essa ferramenta, como por exemplo a Imagine Cup, e a Dream
Build Play (essa ltima inclusive oferece 40 mil dlares ao primeiro grupo colocado e ainda o
jogo lanado na rede online do Xbox 360).
Alm de no ser usado comercialmente, o XNA uma ferramenta excelente para as
pessoas que desejam comear na rea de desenvolvimento de jogos e que desejam tornar-se
profissionais um dia.

REFERNCIAS BIBLIOGRFICAS
CARTER, C. Microsoft XNA Game Studio 3.0 Unleashed. Estados Unidos. Sams, 2009.

CAWOOD, S.; McGEE, P. Microsoft Xna Game Studio Express Creator's Guide. Estados
Unidos. McGraw-Hill, 2007.

FERREIRA, R. Manipulao de udio com XNA utilizando o XACT. So Paulo. Mar 2009.
Disponvel em <http://www.sharpgames.net/Artigos/Artigo/tabid/58/selectmoduleid/
376/ArticleID/1621/reftab/54/Default.aspx>. Acesso em 07 Abr 2009.

FURTADO, A. Criando Drawable Game Components no XNA. So Paulo. Mar 2009.
Disponvel em <http://www.sharpgames.net/Artigos/Artigo/tabid/58/selectmoduleid/376/
ArticleID/1072/reftab/54/Default.aspx>. Acesso em 15 Dez 2008.

GROOTJANS, R. XNA 3.0 Game Programming Recipes: A Problem-Solution Approach.
Estados Unidos. Apress, 2009.

JOS, L. Boas prticas ao codificar seus jogos com XNA. So Paulo. Mar 2009. Disponvel
em < http://www.sharpgames.net/Artigos/Artigo/tabid/58/selectmoduleid/376/ArticleID/1545/
reftab/54/Default.aspx>. Acesso em 07 Abr 2009.

LOBO, A.; EVANGELISTA, B.; de FARIAS, J.A.L. Beginning XNA 2.0 Game
Programming. Estados Unidos: Apress, 2008.

NITSCHKE, B. Professional XNA Programming: Building Games for Xbox 360 and
Windows. Estados Unidos. Wrox, 2007.

REED, A. Learning XNA 3.0: XNA 3.0 Game Development for the PC, Xbox 360, and Zune.
Estados Unidos: O'Reilly Media, 2008.

SANTEE, A. Programao de Jogos com C++ e DirectX. So Paulo. Novatec. 2005.

SHARP, J. Microsoft Visual C# 2008 Step by Step. Estados Unidos. Microsoft Press. 2007.

SILVA, J.; SEDLAK, J. Building XNA 2.0 Games: A Practical Guide for Independent Game
Development. Estados Unidos. Apress, 2008.

Video Game And PC Game Retail Sales. NPD Group. 2006, 2007, 2008. Disponvel em
<www.npd.com>. Acesso em 20 abr. 2009.

Fatec XNA

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Fatec XNA

Hochgeladen von

Copyright:

Verfügbare Formate

CENTRO PAULA SOUZA

FACULDADE DE TECNOLOGIA DE TAQUARITINGA

Das könnte Ihnen auch gefallen