XNA – Framework para desenvolvimento de jogos

Hewerson Gomes, Marcos Alberto Lopes da Silva

Sistemas de Informação – Centro Universitário do Triângulo (UNITRI)

Av. Nicomedes Alves dos Santos 4545 – 38411-106 – Uberlândia – MG – Brasil
{hewerson, malopes21}@gmail.com

Abstract. The Framework XNA was officially announced by Microsoft in

November of 2006, however, it is known that worked in this project since
2004, the Microsoft XNA Framework in this version 3.1 and this allows us to
develop games for Windows (PC), Xbox 360 (Video Game) and Zune
(Portable Media Player). The ease of developing games using this framework
draws attention and one of the main benefits is the ability to use familiar tools
such as Microsoft Visual C # 2005 Express Edition (Free) and MS Visual
Studio 2005 or 2008.

Resumo. O Framework XNA foi oficialmente anunciado pela Microsoft em

Novembro de 2006, porém, é sabido que ela trabalhava neste projeto deste
2004, o Microsoft XNA Framework esta na versão 3.1 e nos permite
desenvolver jogos para Windows (PC), Xbox 360 (Video Game) e Zune
(Media Player Portátil). A facilidade de desenvolver jogos utilizando este
framework chama a atenção e um dos principais benefícios é a possibilidade
de utilizar ferramentas conhecidas tais como, Microsoft Visual C# 2005
Express Edition (gratuita) e MS Visual Studio 2005 ou 2008.

1. Introdução
O objetivo deste artigo é despertar nos amantes de jogos a curiosidade de aprofundar
seus conhecimentos na construção e na facilidade de desenvolver pequenos projetos,
que seja por hobby ou profissionalmente. Existem várias ferramentas que possibilitam a
criação de jogos, escolhi o Framework XNA por ser divertido e estar mais próximo das
ferramentas utilizadas para desenvolver programas comerciais.
Microsoft XNA é um framework desenvolvido pela Microsoft para auxiliar os
desenvolvedores no processo de criação de jogos tanto para Windows (PC), Xbox 360
(Video game) e Zune (Media Player Portátil). A primeira versão lançada foi o XNA 1.0
e se deu por volta de novembro de 2006, mesmo não sendo popular entre a comunidade
de desenvolvedores o framework já ajudava bastante o programador a criar seus jogos
para Windows sem se necessidade de conhecimentos técnicos sobre DirectX (Interface
de Programação de Aplicativos Graficos). Com o passar do tempo a Microsoft fez
modificações consideráveis no XNA Framework principalmente no que diz respeito a
conexões em rede que antes não existiam na versão 1.0.
Atualmente o framework esta na versão 3.1, porém, neste artigo será trabalhado
a versão 3.0. O XNA possui uma rica API (Interface de Programação de Aplicativos)
para criação de jogos 3D assim como jogos 2D, além de permitir a manipulação de som
e entrada de dados como teclado, mouse e joystick (XBox 360).
Com o framework a interação com recursos gráficos, teclado e outros periféricos
ficam mais fáceis, ou seja, sem a necessidade de utilizar funções diretas e DLL’s
(Bibliotecas de Ligações Dinâmicas) do DirectX, a incorporação destes recursos pelo
XNA facilita a manipulação de texturas, o que antes devia ser programado com códigos
complexos, agora passa a ser apenas uma linha de código utilizada para que possamos
carregar uma imagem sem nos preocuparmos em saber qual a extensão ou como iremos
tratar o arquivo.
Outro benefício do framework é a compatibilidade do código desenvolvido para
ser usado no Windows, Xbox 360 e Zune. As ferramentas para trabalhar com
desenvolvimento para PC são distribuídas gratuitamente pela Microsoft, basta apenas
realizar o download e instalá-la em sua maquina. O desenvolvedor pode utilizar também
de ferramentas profissionais, porém pagas.
Já o desenvolvimento para Xbox é necessário uma assinatura (licença) junto ao
XNA Creators Club anual ou parcial por 04 (quatro) meses para a publicação dos jogos
na rede. A iniciativa da Microsoft para facilitar ao máximo o desenvolvimento de jogos
vem de encontro a necessidade de entusiastas e até mesmo a outros tipos de
desenvolvedores como os profissionais, que buscam a praticidade na criação de seus
jogos.

2. O Mundo dos Jogos

Para as pessoas que gostam de jogos, e mais ainda, gostam de construí-los, então o
momento que o Brasil se encontra está facilitando unir o útil ao agradável. A construção
de jogos pode ser agradável e ao mesmo tempo remunerado, a todo o momento
aparecem mais ferramentas que facilitam a construção, em alguns casos sem custos e
totalmente de desenvolvimento visual facilitando a auto-aprendizagem.
A Abragames (Associação Brasileira das Desenvolvedoras de Jogos Eletrônicos)
publicou artigo dia 30/05/2008 sobre a nova política para desenvolvimento de jogos no
Brasil apresentada pelo Governo Federal:
O Brasil tenta desde a década de 80 entrar no mercado de jogos eletrônicos e foi
em 1992 a inauguração de duas empresas com foco em games, em 1997 houve aumento
expressivo na comercialização fazendo com que em 1999 o recorde de fundação de
empresas fosse batido com 21%. Em 2005 os Estados Unidos faturaram US$ 10 bilhões
no mercado de jogos.
Foi publicado também pela Abragames uma pesquisa sobre o mapeamento de
crescimento do setor desenvolvimento de jogos nos últimos 4 (quatro) anos, nesta
pesquisa foi enfatizada o crescimento do setor nos últimos 2 (dois) anos mesmo tendo o
mercado interno oprimido pela pirataria, ainda assim podemos ver que os números
agradam (Figura 1).
O principal vilão não é a pirataria, como muitos pensam, e sim os impostos
cobrados pelo governo, um exemplo é o estado de SP que em 2006 aumentou o ICMS
de 7% para 18% em serviços de desenvolvimento. Com novas demandas de cursos para
este fim as faculdades foram criando especializações e graduações, a primeira foi
UNICENP em Curitiba, e depois diversas faculdades de SP e RJ. Com isso aumentaram
a publicidade vinculando os games a outros produtos, e até dentro dos games.
 Figura 1. Abragames – Pesquisa 2008

Alguns eventos nacionais são criados especificamente para incentivar o

comercio de jogos nacionais, dentre eles: Concurso de jogos eletrônicos Brasileiros -
com premiação para os ganhadores, Mundo dos Games – com workshops, palestras,
campeonatos e oficinas. Outros eventos marcantes foram a Conferência de GD RIO
2005 e a Eletronic Entertainment Expo (E3) – que ocorreu em Los Angeles-US
recebendo empresas de todo o mundo, inclusive esta feira ocorre todos os anos até hoje.
O mercado é promissor e dele foi criado nova profissão, o desenvolvedor de
jogos ou Design de games, este profissional a cada dia ganha mais espaço no mercado
nacional e maior reconhecimento no mercado internacional.
Após toda essa análise para comprovar que criar jogos pode compensar, será
apresentado neste artigo uma ferramenta (Framework XNA) capaz de fazer com que
esta criação possa ser divertida e mais simples do que parece.

3. Conhecendo o Framework XNA

O Framework XNA é um conjunto de classes, ou seja, é uma biblioteca com recursos
prontos para serem utilizados por código projetado para o desenvolvimento de jogos.
Desenvolvido pela Microsoft com o intuito de facilitar a construção e
gerenciamento, reduzindo os custos e esforços no desenvolvimento de jogos. Grande
parte do código escrito funciona tanto no Windows como no Xbox 360 e o Zune.
3.1. Conceitos
O XNA, por ser uma plataforma de desenvolvimento, é formada por alguns
componentes descritos a seguir:
 XNA Game Studio: IDE de desenvolvimento, baseado no Visual C# Studio,
versão gratuita e baseada no Visual C# 2005 Express. Ele foi desenvolvido para
ser usado por estudantes, desenvolvedores hobbistas e pequenos grupos de
desenvolvimento com o intuito de permitir que os usuários desenvolvessem seus
 próprios jogos;
 XNA Framework: conjunto de classes necessárias para se execução do jogo.
Funciona sobre o .NET (Dot Net) Framework 2.0 ou mais novo (PCs) ou do
.NET Compact Framework for Xbox 360 (Xbox 360);
 XNA Content Pipeline: componente de gerência de conteúdo e artefatos do
projeto, tais como imagens (JPG, PNG, BMP, etc), modelos 3D (X, FBX, etc),
sonoros (WAV, etc) e dados (XML, etc). Ele transforma os arquivos
automaticamente no momento do build em um formato que será entendido pela
aplicação em tempo de execução. O Content Pipeline é extensível e permite que
o desenvolvedor escreva um conversor para um formato especial ou
desconhecido com flexibilidade;
 XACT (Audio Authoring Tool): ferramenta para áudio designers organizarem
seus arquivos de áudio e efeitos sonoros.
3.2. Fluxos e Camadas
O fluxo de funcionamento para criação da tela gráfica dos jogos é representado
conforme Figura 2, a forma de interação entre o desenvolvedor e a tela para o jogador.

Figura 2. Fluxo de Inicialização Gráfica

Os métodos Draw e Update podem ser executados até 60x/segundo, cada execução é
tratada como um ciclo, aos olhos humanos é perceptível o objeto que está em
movimento, porém, durante os ciclos toda a tela é refeita, e os tratamentos são
efetuados. O desenvolvimento do projeto de jogo pode utilizar as seguintes camadas:
Plataforma:
 Direct3D – Controla os Gráficos 3D;
 XACT – Controla o áudio e possibilita a criação de sons;
 XINPUT – Suporte a dispositivos de entrada (Teclado, Mouse e outros);
 XContent – Suporte a conteúdo de imagens, vídeos, sprites.
Core Framework:
 Acesso básico a inicialização de Gráficos, Áudio, Entrada de Dados, Matemática
(lógica) e Armazenamento;
 Framework Dot.NET 2.0 ou mais atual.
Extended Framework:
 Modelo de Aplicação – Comportamento do jogo (inteligência);
  Content Pipeline – Gerencia conteúdos, loadings de texturas, som e matemática.
Jogos:
 Starter Kits – Modelos com a inicialização básica dos componentes;
 Code – Código de desenvolvimento;
 Content – Conteúdo (imagens, sons...);
 Components – Elementos feitos pela comunidade, disponível para download.
4. Desenvolvendo um Jogo
O objetivo é apresentar, de forma simples, como criar um jogo com as funcionalidades
básicas já disponibilizadas pelo Framework XNA 3.0, já disponível para download.
Enredo: O jogador “Heroi” deve recuperar todas as jóias da rainha sem ser pego
pelos adversários “Múmias” espalhados pelo mapa utilizando os recursos de
movimentação (direita / esquerda / pulo) acionados pelas setas ou joystick, e o efeito de
fogo e fumaça (espaço) gerando invencibilidade temporária ao “Heroi”, modelo
conforme Figura 3.

Figura 3. Enredo

4.1. Ferramentas para Desenvolvimento

Para implementação do projeto apresentado neste artigo é necessário a instalação das
ferramentas listadas abaixo:
 Visual Studio 2008: Projeto pode ser desenvolvido também no Visual C#Studio;
 XNA Framework 3.0: Pode ser baixado no site de downloads da Microsoft,
basta pesquisar por XNA e será apresentado a lista das versões
(http://www.microsoft.com/downloads);
 Starter Kit – Plataform: Disponível juntamente com o XNA Framework 3.0;
 Framework .NET 3.5: Pode ser baixado no site de downloads da Microsoft.
4.2. Projeto de Jogo
Após instalação das ferramentas deve-se criar o projeto para desenvolvimento do
exemplo prático e simples, utilizando os recursos nativos do framework e entendo os
principais conceitos.
4.2.1. Criando o Projeto
Como qualquer aplicação comercial, a criação do projeto segue o mesmo fluxo, após a
inicialização do Visual Studio, selecione a opção para criar novo projeto, e conforme
Figura 4., selecione o tipo de projeto (Visual C#), clique em XNA Game Studio 3.0 para
aparecer na lista de templates (modelos) o Starter Kit chamado “Platformer Starter Kit”
e selecione o local onde seu projeto será gravado. Lembrando que este template
somente estará disponível após instalação do XNA Framework 3.0.

Figura 4. Criando o Projeto

Altere o nome do projeto para RecuperaJoia, ou se desejar utilize o nome que

achar mais conveniente. Clique em OK para continuar.
Neste ponto o Visual Studio já criou uma Solução com 3 (três) projetos:
 RecuperaJoia: contendo todo o conteúdo para publicação em PCs;
 Xbox 360 Copy of RecuperaJoia: para publicação no Xbox 360;
 Zune Copy of RecuperaJoia: para publicação no Zune.
Os arquivos gerados são compartilhados nos projetos, qualquer alteração já
estará publicada para as 3 versões, somente em casos de utilização de recursos mais
complexos o desenvolvimento deve ser específico.
Neste ponto o jogo já pode ser executado, isso mesmo, o Starter Kit fornece toda
a estrutura para inicialização gráfica, controle das teclas, som e regras de colisão.
Durante os próximos passos serão apresentados alguns recursos a fim de exemplificar a
facilidade de se criar a sua própria história.
4.2.2. Definindo as Classes e Conteúdos
O projeto é composto por classes contendo a “inteligência” e conteúdos, sejam gráficos
ou sons, estes artefatos são utilizados durante execução do jogo (Figura 5).
Alguns artefatos foram criados e podem ser baixados junto com os fontes do
projeto em estudo neste artigo, pela link na Internet disponibilizado no item 4.3.
(ExplosionParticleSystem, Particle, ParticleSystem ,SmokePlumeParticleSystem).
 Figura 5. Classes e Conteúdos

A seguir será apresentado a funcionalidade dos artefatos envolvidos no projeto:

Program.cs: responsável pela inicialização do jogo, a primeira linha de código a ser
executado está associado nesta classe, a instância criada da classe PlatformerGame
(herança da classe Game) é responsável por todo o controle do jogo, a classe Game faz
parte do framework e possui o método Run.
PlatformerGame.cs: responsável pela inicialização gráfica, carga de conteúdos
públicos e desenho da tela gráfica. Em destaque os principais métodos:
 PlatformerGame: construtor da classe, responsável pela inicialização da tela
gráfica (GraphicsDeviceManager), definição de acesso ao conteúdo (imagens e
sons) e ajuste do tempo de atualização da tela (Frame Rate = 30 para Zune e 60
para PC e XBox360);
 LoadContent: carrega conteúdos de uso geral, objetos gráficos, sons, fonte para
escrita em tela (Figura 6). Neste método é inicializado a música de fundo e as
imagens utilizadas na carga do mapa.
//carrega conteudo principal para utilizar durante o jogo
protected override void LoadContent()
{
//cria objeto para desenhar imagens na tela (texturas)
spriteBatch = new SpriteBatch(GraphicsDevice);
//carrega fonte de texto
hudFont = Content.Load<SpriteFont>("Fonts/Hud");
//carrega imagens
winOverlay = Content.Load<Texture2D>("Overlays/you_win");
...

Figura 6. LoadContent

 Update: este método é sobreposto pela classe Game (Figura 7), ou seja, após a
primeira execução ele é chamado continuamente.
//loop para ler o teclado e executar rotinas programadas no mapa
protected override void Update(GameTime gameTime)
{
HandleInput();
level.Update(gameTime);
base.Update(gameTime); }

Figura 7. Update
  HandleInput: método responsável pelo controle das teclas pressionadas e pela
interação com o Joystick, neste método foi inserido manualmente o código para
aceitar a tecla ESC para sair e a tecla UP para continuar o jogo (Figura 8).
//responsavel por capturar os eventos do teclado ou joystick
private void HandleInput()
{
KeyboardState keyboardState = Keyboard.GetState();
GamePadState gamepadState = GamePad.GetState(PlayerIndex.One);
//sai do jogo quando pressionado Back no joystick ou tecla ESC
if ((gamepadState.Buttons.Back == ButtonState.Pressed) ||
(keyboardState.IsKeyDown(Keys.Escape)))
Exit();
bool continuePressed = keyboardState.IsKeyDown(Keys.Up) ||
gamepadState.IsButtonDown(ContinueButton);
...

Figura 8. HandleInput

 LoadNextLevel: método responsável por identificar e carregar os mapas que

estão criados na pasta de conteúdo dos mapas (HighResolutionContent\Levels),
isso torna o desenvolvimento dinâmico pois este método tem a inteligência de
identificar qual é o próximo mapa e, se não encontrar, finaliza (Figura 9).
//metodo para carregar o conteudo do mapa, e descarrega anterior
private void LoadNextLevel()
{
...
//loop para buscar mapas
while (true)
{
//busca o proximo, conforme sequencia numerica dos mapas .TXT
levelPath = String.Format("Levels/{0}.txt", ++levelIndex);
levelPath = Path.Combine(StorageContainer.TitleLocation, "Content/" +
levelPath);
if (File.Exists(levelPath))
break;
//verifica se existe pelo menos um mapa
if (levelIndex == 0)
throw new Exception("Nenhum mapa encontrado.");
//se não encontrar proximo mapa inicia novamente no 0
//levelIndex = -1;
throw new Exception("Jogo acabou.");
}
...

Figura 9. LoadNextLevel

 Draw: método sobreposto pela classe Game, ou seja, após a primeira execução
ele é chamado continuamente (Figura 10), responsável por gerar imagens na tela
é executado 60 frames/segundo para PC, XBox360 e 30 frames/segundo Zune.
//metodo para desenhar a tela
protected override void Draw(GameTime gameTime)
{ //limpa a tela virtual
graphics.GraphicsDevice.Clear(Color.CornflowerBlue);
//inicializa metodo de impressao da imagem na tela virtual
spriteBatch.Begin();
//desenha a imagem na tela virtual
level.Draw(gameTime, spriteBatch);
//desenha os textos na tela virtual
DrawHud();
spriteBatch.End();
//transfere a tela virtual de uma vez para a tela do usuario
base.Draw(gameTime); }

Figura 10. Draw

  DrawHud: o conceito deste método é conhecido, Draw significa desenha e HUD
(Heads-Up Display) significa informações a frente da tela. O objetivo é imprimir
na tela sobre demais objetos as informações de tempo, pontuação e mensagens.
Neste método foi incluído logo abaixo da mensagem “Pontos” o seguinte
código: spriteBatch.DrawString ( hudFont, "Pressione ESC para sair",
hudLocation + new Vector2(0.0f, timeHeight * 2.4f), Color.Blue).
Tile.cs: responsável pela definição da colisão dos blocos utilizados como base para o
movimento do “Heroi”e das “Múmias” pelo chão, três tipos definidos:
 Sólido, não é possível atravessar por dentro do bloco;
 Insólido, pode atravessar por dentro e não permite ao “Heroi” andar por cima;
 Plataforma, pode atravessar por dentro e permite ao “Heroi” andar por cima.
RectangleExtensions.cs: responsável pela validação de retângulos e colisão de
transposição entre os objetos criados.
Player.cs: responsável pelas definições e características do “Heroi”, nesta classe é
criado os objetos de animações e sons para os eventos de quando ele está em
movimento, parado, pulando, celebrando e morte. É ajustada também a velocidade de
todas as animações, a textura (imagem conforme Figura 11) e os áudios são carregados
dos Contents, classes de conteúdos geradas no projeto. Outro ponto importante gerado
nesta classe é a física posta sobre o personagem, quando é acionado o pulo em
movimento ou parado, o método ApplyPhysics é responsável por esta dinâmica, calcula
a aceleração e se está no ar ou no chão. Os métodos Draw e Update são utilizados nesta
classe com o mesmo conceito utilizado na classe PlatformerGame, no método GetInput
responsável pela interação com o usuário foi alterado a tecla SPACE de pulo para fogo.
E por ultimo a cada ciclo executado pelo Update é chamado o método GetInput,
ApplyPhysics e HandleCollisions para tratar as colisões dos objetos. Mesmo alterando a
imagem do “Heroi” que esta associada aos conteúdos, esta alteração não afeta a relação
com os demais recursos.

Figura 11. Alterando o Heroi

Level.cs: responsável por montar o mapa com as imagens de fundo, os blocos, os

personagens e seus atributos (em movimento, parado, etc), as jóias, registro dos pontos
coletados, tempo de jogo e as colisões entre os objetos.
A distribuição dos objetos é feita conforme design do mapa (Figura 12), a definição
é feita em arquivos texto (TXT), facilitando a criação e manipulação dos objetos.
Os objetos são dispostos conforme legenda abaixo:
 [ . ]: espaço em vazio;  [ # ]: bloco sólido ;
 [ X ]: saída do mapa;  [ A – D]: Mumias;
 [ G ]: Jóia;  [ 1 ]: posição de inicio do “Heroi”;
 [ - ]: bloco plataforma;
....................
....................
..........X.........
.......######.......
..G..............G..
####..G.G.G.G....###
.......G.G.GCG......
......--------......
....-...........-...
....................
.G.G............G.G.
####............####
....................
.1..................
####################
Figura 12. Mapa level 2

Gem.cs: responsável por controlar e desenhar as Jóias distribuídas no mapa (Figura 13),
quando o “Heroi”colide com a jóia é executando o método OnGemCollected dentro do
Level.cs que por sua vez retira o objeto da tela e chama o método OnCollected desta
classe para executar o som. O efeito de onda é criado por cálculos matemáticos no
método Update, durante a sequência de montagem das imagens na tela o sistema cria
cada objeto com seus atributos específicos inclusive a posição na tela.
//atualiza posição do objeto
public void Update(GameTime gameTime)
{
//variaveis de controle - altura, variação e sincronismo
const float BounceHeight = 0.18f;
const float BounceRate = 3.0f;
const float BounceSync = -0.75f;
//matematica logica para criar o efeito de onda
//altera a coordena X das joias em sequencia com a próxima
double t = gameTime.TotalGameTime.TotalSeconds * BounceRate +
Position.X * BounceSync;
bounce = (float)Math.Sin(t) * BounceHeight * texture.Height;
}

Figura 13. Update Gem

Enemy.cs: responsável pelas definições e características dos “Inimigos” possui

características parecidas com a classe do “Heroi”, nesta classe é criado os objetos de
animações de quando está em movimento ou parado. A textura (imagem conforme
Figura 14) para as animações são carregadas dos Contents, classes de conteúdos geradas
no projeto. Os métodos Draw e Update são utilizados nesta classe com o mesmo
conceito utilizado na classe PlatformerGame. A inteligência dos movimentos dos
inimigos, pelo mapa, está codificado no método Update, é verificado se está em
movimento calculando, se houve a finalização dos blocos do chão, se houve colisão
com outros blocos ou fim do mapa.

Figura 14. Content Enemy Run

RectangleExtensions.cs: responsável pela validação de objetos em círculos e colisão de
transposição entre os objetos criados.
AnimationPlayer.cs: controla as animações criadas para o “Heroi”, esteja ele em
movimento, parado, pulando, celebrando ou morrendo. A cada ciclo executado
(60frames/segundo) métodos são executados para calcular qual imagem deve ser
apresentada conforme a animação definida, a velocidade de apresentação destas
imagens é muito rápida a ponto de ser imperceptível pelo olho humano o efeito de
apagar a imagem anterior e atualizar para a nova. Pode-se dizer que toda a tela visível
pelo usuário é refeita 60 vezes por segundo.
Animation.cs: esta classe é responsável por manter em objeto a imagem recuperada no
Content guardando qual frame foi o ultimo frame apresentado.
Content HighResolutionContent: possui todo o conteúdo referente a apresentação
gráfica, para o projeto foi definido da seguinte forma:
 Backgrounds: contém imagens utilizadas para montar o fundo do jogo;
 Fonts: contém a configuração da fonte utilizado na apresentação de texto;
 Levels: definição do layout dos mapas, podendo ser criado novos mapas
simplesmente adicionando novos arquivos TXT;
 Overlays: são imagens com objetivo de apresentar mensagens e de interação
com o jogador (“você morreu”, “você perdeu”, “você ganhou”) ;
 Sprites: contém as imagens para criar os movimentos do “Heroi”, dos
“Inimigos” e das jóias, são arquivos PNG que possibilitam utilizar a
transparência de fundo, facilitando sobreposição de imagem;
 Tiles: contém as imagens da placa de saída e dos blocos utilizados para montar o
mapa, a Level.cs utiliza os blocos aleatoriamente para misturar as cores.
Content SharedContent: guarda todo o conteúdo referente aos sons, para o projeto foi
criado pasta única (Sounds), possui efeitos sonoros como música de fundo, som de final
de mapa, coleta da jóia, quando o jogador cai, quando o jogador pula, quando o jogador
morre, os conteúdos são acessados pelas classes detalhadas anteriormente.
Os Contents podem ter a nomenclatura definida pelo desenvolver, os nomes
apresentados foram gerados automaticamente pelo framework.
Particle.cs e ParticleSystem.cs: possui classes responsáveis por criar objetos com base
em texturas selecionadas, possibilitando gerar movimentos utilizando fórmulas
matemáticas para simular a física, a posição, velocidade e rotação são atributos
específicos para gerar os efeitos. Estes objetos são sincronizados com o método Update
para que durante todo o ciclo de montagem da tela os efeitos sejam gerados.
ExplosionParticleSystem.cs: responsável por gerar as características especificas para o
efeito gerado, nesta classe é definido o valor dos atributos específicos para gerar o fogo.
SmokePlumeParticleSystem.cs: igual ao item anterior, porém, é responsável pela
definição dos atributos específicos para gerar a fumaça.
4.3. Artefatos de instalação
Para executar o jogo na máquina do usuário, deve-se garantir que tenha instalado na
máquina o Dot Net 3.5 e o XNA Framework 3.0, o Visual Studio 2008 possibilita ao
desenvolvedor gerar o pacote de instalação incluindo todas suas dependências.
 O projeto apresentado neste artigo pode ser baixado (48mb) pelo link:
Google Code “http://code.google.com/p/xnaplataforma/downloads”
5. Considerações Finais
O desenvolvimento de jogos no Brasil está em ascendência e as faculdades já estão
incluindo formação especifica para esta área, a tecnologia está disponível para qualquer
pessoa que deseja criar jogos, seja por hobby ou profissionalmente.
A facilidade de utilização do Microsoft XNA Framework vem de encontro com
as necessidades de termos tecnologias padronizadas, de fácil utilização e com baixo
custo. Com esta ferramenta é possível construir projetos profissionais com qualidade de
nível internacional, várias empresas estão investindo, proporcionando cursos e
campeonatos nacionais com altas premiações.
O volume de informações disponíveis sobre o assunto ajuda na especialização,
porém, ainda existe dificuldade em encontrar materiais para estudo em português. Outro
dificultador é a pouca disponibilidade de livros nacionais sobre o assunto, a demora de
entrega quando importado, gera insatisfação e até mesmo o desinteresse do iniciante ao
mundo dos jogos.
Referências Bibliográficas
Carter, Chad (2007) “Microsoft XNA Essentials - Graphics and Game Programming for
Xbox 360 and Win”, SAMS, 1ª edição
Cawood, Stephen (2007) “Microsoft XNA Game Studio Express Greators Guide”,
OSBORNE - MCGRAW-HIL, 1ª edição
José, Luciano (2008) “Ganhando Desempenho em jogos com XNA”, em Português.
Disponível em : http://www.sharpgames.net/Artigos/tabid/54/Default.aspx
Lobão, Alexandre S.(2008) “Beginning XNA 2.0 Game Programming”, aulas XNA, em
português. Disponível em: http://www.alexandrelobao.com/Jogos/Alexandre_Lobao-
Palestras_Jogos.asp
Penha, André Gustavo G. (2008) “A Indústria Brasileira de Jogos Eletrônicos”, em português.
Disponível em: http://www.abragames.org/docs/Abragames-Pesquisa2008.pdf
Aguilar, Daniel (2007) “Microsoft XNA Framework – post”, em português. Disponível em:
http://farraposdispersos.blogspot.com/2007/11/microsoft-xna-framework.html
Katayama, Fernando (2008) “Gerente da Microsoft mostra como o XNA é fácil”, em português.
Disponível em: http://games.terra.com.br/interna/0,,OI3198011-EI1702,00-
Gerente+da+Microsoft+mostra+como+o+XNA+e+facil.html
Amaral, Bruno (2008) “Introdução ao Microsoft XNA - Desenvolvendo Jogos em casa”, em
português. Disponível em: http://brunoamaral.wordpress.com/2008/06/03/desenvolvendo-
jogos-com-xna-microsoft-parte-1/
José, Luciano (2009) “Entrevista com as 3 equipes vencedoras do 3° XNA Challenge Brasil”,
em português. Disponível em: http://www.sharpgames.net/Home/tabid/36/Default.aspx