Camello XNA

XNA Game Studio - O Recomeço

2014-04-18T19:39:00.000-03:00

Faz 4 anos que eu não atualizo o meu blog. E nesse longo tempo fiquei bem afastado do desenvolvimento com o XNA Game Studio.

Essa semana, resolvi dar uma olhada em todos os meus projetos e ajeitar o código deles com o objetivo de colocá-los no GitHub. Ia começar pelos tutoriais aqui do blog pois até hoje recebo muitos e-mails de leitores me pedindo ajuda.

Ao tentar configurar meu PC para ajeitar o código dos tutoriais aqui do blog me deparei com uma triste notícia: o XNA foi descontinuado pela Microsoft.

Inicialmente fiquei triste com a descoberta mas depois de investigar um pouco descobri que não há motivos para a tristeza. Um projeto chamado MonoGame está dando continuidade ao framework.

Lembram do Mono.XNA?

Em outubro de 2008 escrevi um post sobre uma implementação multi plataforma e open source do XNA framework. Em março de 2011, o projeto foi renomeado para MonoGame e foi movido para o GitHub.

O objetivo do projeto é permitir que os desenvolvedores que usam o XNA para desenvolver jogos para Xbox 360, Windows e Windows Phone, também consigam portar esses jogos para IOS, Android, Mac OS X, Linux e Windows 8 Metro. O desenvolvimento para PlayStation Mobile, Raspberry PI e PlayStation 4 também está em andamento.

Página do projeto: http://www.monogame.net/

Um recomeço

O que parecia uma notícia ruim acabou se tornando uma notícia, no mínimo, animadora. Com nosso conhecimento em XNA, agora podemos desenvolver jogos que podem ser publicados em diversas plataformas.

Em breve tentarei escrever um tutorial sobre esse novo assunto, ou então portar o tutorial antigo para o MonoGame.

Abraços a todos. Até breve.

Novidade - XNA 4.0

2010-04-01T21:32:00.004-03:00

Faz mais de 6 meses que eu não apareço para atualizar o blog.

O ano de 2010 começou e tivemos diversas boas notícias sobre o desenvolvimento de jogos com o XNA Game Studio.

As que mais me chamaram a atenção foram o lançamento da versão 4.0, e com isso a possibilidade de criar jogos para Windows Phone.

Agora além de conseguirmos fazer jogos para PC, Xbox360 e Zune, também poderemos disponibilizar nossos jogos para qualquer celular ou smatphone que utiliza o sistema operacional da Microsoft. O melhor de tudo: da mesma maneira que fazíamos antes.

No site http://creators.xna.com/en-US/article/firstwindowsphonegame temos um breve tutorial de como começar a desenvolver jogos para windowsphone.

No site http://developer.windowsphone.com/windows-phone-7-series/ temos alguns exemplos, demos e documentações também sobre o desenvolvimento.

Em breve se for possível farei um tutorial sobre o assunto.

Abraços a todos. Até a próxima.

Tutorial - Nosso Primeiro Jogo 2D - Extra

2009-08-06T11:00:00.002-03:00

Este será o nosso último tutorial da série de desenvolvimento do nosso primeiro jogo 2D. Esse tutorial foi baseado nos vídeos Beginners Guide to 2D Games encontrado no site creators.xna.com.

Nesta última parte iremos surpreender os jogadores do nosso simples jogo com explosões bem legais a cada destruição.

Salvando as Novas Imagens e Adicionando ao Projeto

Começaremos esta parte do nosso tutorial, adicionando ao nosso projeto as imagens que usaremos para a explosão e a fumaça de nossas explosões. Para isso vamos salvar as imagens abaixo com seus seguintes nomes em nosso PC clicando com o botão direito do mouse.

explosion:

smoke:
Agora, no Visual C# Express Edition, no Solution Explorer, vamos clicar com o botão direito do mouse na pasta Sprites que está dentro de Content. Agora iremos adicionar as novas imagens assim como fizemos com as outras, clicando em Add->Existing Item e selecionando as novas imagens no local onde as salvamos.

Criando o Sistema de Particulas

Para fazer as explosões dos aviões inimigos no nosso jogo iremos precisar de um sistema de particulas para que fiquem mais realistas as explosões e a fumaça.

Assim ainda no solution explorer, vamos criar uma nova classe que será a responsável por cada particula de efeito no nosso jogo, clicando em Belonave->Add->New Item->Class, o nome do arquivo se chamará Particle.cs.

Essa nossa classe será uma classe pública, assim vamos mudar a declaração dela para public class Particle. E não podemos esquecer também de mudar os using para os do XNA como na figura abaixo.

Nossa partícula terá os seguintes atributos: position; velocity; acceleration; lifetime, por quanto tempo a particula ficará viva; timeSinceStart, quanto tempo já passou desde que ela foi criada; scale; rotation; rotationSpeed, a velocidade da rotação da particula; e também o isActive, que indicará se a partícula ainda está "viva".

Nossa partícula também terá dois métodos, um para inicializa-la e um para atualiza-la. O primeiro irá inicializa-la em uma posição, com uma velocidade e aceleração, um tempo em que ficará viva, sua escala e a velocidade de sua rotação. Daremos também, ainda nesse primeiro método, o tempo desde que foi iniciada a particula como 0.0 já que esse método é o que inicializa nossa particula. Se estivermos atentos iremos perceber que ainda falta inicializarmos a rotação, mas isso faremos em outro momento mais a frente.

Agora trataremos da parte de atualização da nossa particula. O que faremos basicamente é manter os atributos dela atualizados a cada intervalo de tempo.

Agora que temos nosso modelo de particula, podemos criar o nosso sistema de particulas, que será responsável por gerenciar todas as particulas do nosso jogo. Assim como fizemos para criar o Particle.cs, vamos fazer o mesmo para criar o ParticleSystem.cs.

Mas nessa nossa nova classe, não só trocaremos os using, e tornaremos ela pública, como também a tornaremos abstrata e faremos ela herdar da classe DrawableGameComponent. Isso significa que ela irá proporcionar as funcionalidades básicas para criarmos um efeito de partículas. Outras subclasses irão extender os efeitos dessa classe de uma maneira mais customizada.

Ela terá acesso a diversos atributos de outras classes como do objeto ao qual daremos o efeito de explosão e fumaça. Teremos também um gerador de números randomicos para dar mais realidade ao nosso efeito.

Outras constantes também serão necessárias pois serão usadas nos sistemas de particulas mas especializados que criaremos a seguir. Continuaremos na linha onde paramos anteriormente.

Agora poderemos passar para o construtor da nossa classe. No construtor receberemos o nosso Game, o numero de particulas que esperamos ver na tela a cada momento e o nome da nossa textura.

Nossa classe terá também a implementação das funções Initialize, LoadContent, Update e Draw. Mas antes de começarmos a implementá-las, temos que implementar diversos métodos auxiliares para nosso sistema de particulas, ainda continuando abaixo de onde paramos antes.
Agora abaixo das implementações que acabamos de fazer, vamos implementar os métodos Initialize:

LoadContent:

Update:

e Draw:

E temos também que lembrar que deixamos para setar o atributo rotation da classe Particle, o que faremos agora:

Sistemas de Particulas Customizados

Agora que já temos a base do nosso sistema de particulas, podemos começar a trabalhar nos nossos sistemas especializados em explosões e fumaça. Como fizemos para adicionar o Particle.cs e o ParticleSystem.cs, vamos adicionar também mais dois arquivos ao nosso projeto, o ExplosionParticleSystem.cs e o SmokeParticleSystem.cs.

Faremos também as mesmas alterações dos using que fizemos nos outros arquivos e tornaremos estas classes também públicas e as faremos herdar do nosso recém finalizado ParticleSystem.

Devido ao grande trabalho que tivemos implementando o nosso ParticleSystem, nessas nossas classes especializadas, só precisaremos implementar três funções: a InitializeConstants(), InitializeParticle() e o construtor delas.

Começaremos pela classe ExplosionParticleSystem:

Seu construtor:
InitializeConstants:

InitializeParticle:
Agora na classe SmokeParticleSystem:

Seu construtor:
InitializeConstants:

Agora, para finalizarmos, devemos ir a nossa classe Game.cs e fazer as seguintes alterações:

Mais algumas variáveis:

Construtor:
UpdateCannonMissiles:

Ahh... ainda em Game.cs não podemos esquecer de um último detalhe:

Se não nos esquecemos de nenhum detalhe, podemos rodar nosso jogo e veremos explosões e fumaças realistas ao derrubarmos cada aeronave inimiga.

Resumo

Esta foi a ultima parte do nosso tutorial de como criar um jogo 2D com o XNa Game Studio. Nela conseguimos criar um sistema de particulas e simular explosões e fumaça no nosso jogo... Poderiamos expandir esse sistema para abordar outras formas de particulas como um brilho mágico, neblina, sei lá, depende da sua imaginação.

Espero que as coisas fiquem bem claras e qualquer dúvida não exitem em entrar em contato comigo, via comentários, via e-mail, etc.

Sei que ficou bastante "cuspido" esta ultima parte, mas é resultado da minha falta de tempo, por isso estou bem aberto para responder a duvidas sejam quais forem.

Espero que tenha ajudado e que a maioria tenha gostado.

Em breve colocarei uma enquete aqui para saber qual será a temática do próximo tutorial.

Abraços a todos.

Kodu Game Lab - O que é?

2009-07-01T18:34:00.004-03:00

Neste post falarei um pouco sobre uma novidade. O Kodu Game Lab!

O Kodu Game Lab

É uma nova linguagem de programação visual criada especialmente para o desenvolvimento de jogos. Foi criada para ser acessível para crianças e agradar a todos. É um ambiente de programação que permite uma criação rápida usando apenas o joystick. E ainda permite compartilhar seus jogos criados pela Xbox LIVE.

Foi desenvolvido pelo Microsoft Research utilizando o XNA Game Studio e custa 400 Microsoft Points no Xbox LIVE Marketplace. Com seu menu baseado em imagens permite a criação de jogos utilizando o joystick do Xbox360. Oferece um gameplay cooperativo de até 4 jogadores simultaneos e até 20 personagens diferentes com diversas abilidades.

Já encontra-se disponível no Xbox LIVE Marketplace

XNA Game Studio 3.1

2009-06-29T12:21:00.003-03:00

No dia 11 de junho de 2009 foi lançada a versão 3.1 do XNA Game Studio. Essa é uma versão incremental a versão 3.0 e contém muita coisa nova.

Agora é possível renderizar e animar avatares para serem usados nos jogos representando jogadores e outros personagens do jogo, permitir a comunicação entre os jogadores mesmo se eles não estiverem jogando na mesma sessão, suporte ao playback de vídeos durante o jogo, também tivemos algumas mudanças na API de áudio, melhorias no Content Pipeline e suporte ao XACT3.

Os jogos desenvolvidos com a versão 3.1 do XNA Game Studio poderão ser enviados ao Xbox LIVE Community Games em julho por usuários premium.

Tutorial - Nosso Primeiro Jogo 2D - Parte 6

2009-06-18T10:33:00.018-03:00

Neste tutorial veremos, passo a passo, como criar um jogo 2D simples. Este tutorial foi baseado nos vídeos Beginners Guide to 2D Games encontrados no site creators.xna.com.

Esta é a sexta parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio. Aqui veremos como manter e atualizar o controle da pontuação do nosso jogo. Mas antes...

Pesquisando sobre as colisões em jogos 2D, encontrei um método de verificar a colisão por pixel que funciona checando se os pixels de uma imagem intercedem algum pixel de uma outra imagem. Assim podemos tornar nossas colisões mais realistas pois só irão colidir se os pixels das duas imagens entrarem em contato.

Atualizando as Colisões

No nosso arquivo GameObject.cs vamos adicionar um vetor de cores que chamaremos de textureData e que armazenará a informação dos pixels dos nossos objetos.

No arquivo Game1.cs, onde carregamos nossos mísseis, e onde carregamos as aeronaves inimigas, vamos carregar também os vetores de textura de cada um deles.

Agora que temos os dados das texturas de cada imagem, tanto dos mísseis como das aeronaves inimigas, vamos criar no final do arquivo Game1.cs o método IntersectPixels que receberá os retangulos que envolvem duas imagens e suas informações de textura e retornará verdadeiro ou falso caso essas imagens colidam ou não. Esse método também está disponível no site creators.xna.com.

Por último, na função UpdateCannonMissiles(), no trecho em que testávamos a colisão dos mísseis com as aeronaves inimigas, vamos utilizar o método que acabamos de criar.

Se não esquecemos de nada e modificamos tudo direito o projeto deve compilar e rodar sem problemas e agora com colisões mais precisas.

Agora podemos partir para nosso placar. rs.

Criando e Carregando o Arquivo de Definição de Fonte

Para criarmos o nosso controle da pontuação do jogo, precisaremos criar um arquivo que descreverá a fonte que usaremos para escrever algo na tela. Assim, no Solution Explorer, vamos criar uma sub pasta dentro da pasta Content. Clicando com o botão direito na pasta Content, no Solution Explorer, Add->New Folder. Chamaremos essa nova pasta de Fonts.

Após a criação da nossa nova pasta chamada Fonts, iremos clicar com o botão direito nela e Add-> New Item. Aparecerá na tela uma janela para adicionarmos um novo item ao nosso projeto. Selecionaremos adicionar um Sprite Font cujo nome será gameFont.spritefont.

Clicando no botão Add veremos o arquivo gameFont.spritefont ser adicionado ao projeto dentro da pasta em que o inserimos no Solution Explorer e uma nova aba aberta exibindo o conteúdo do nosso novo arquivo. Esse arquivo não é descrito em C# mas em XML que é uma linguagem criada para descrever dados. O nosso arquivo XML está organizado de modo que descreve as informações de nossa fonte.

Faremos algumas alterações nesse arquivo para que fique de acordo com o que desejamos em nosso jogo. Dentro das tags que descrevem o nome da nossa fonte, FontName, iremos colocar o nome da fonte que desejamos utilizar no nosso jogo e que tenhamos no nosso sistema, neste caso usaremos a fonte Arial. Logo abaixo das tags de nome da nossa fonte, temos as tags Size, responsáveis pelo seu tamanho e iremos alterá-la para 18. Feitas essas alterações, podemos salvar nosso arquivo.

Agora iremos ao arquivo Game1.cs e no início do arquivo, logo depois das declarações de variáveis que fizemos para os inimigos vamos declarar mais algumas. A primeira variável que iremos declarar é um inteiro chamado score para computar os pontos que o jogador fizer, logo após iremos declarar uma variável do tipo SpriteFont chamada font que será a representação da nossa fonte e por último um vetor da posição da tela onde nosso placar será desenhado.

Dentro da função LoadContent() iremos carregar com a variável font nossa fonte ao Content Pipeline como fizemos com todas as outras imagens do nosso jogo.

Antes de desenhar nosso placar na tela, vamos verificar como estamos computando as baixas das aeronaves inimigas.

Atualizando a Pontuação a Cada Colisão

No método UpdateCannonBalls() temos um trecho de código que identifica as colisões dos mísseis com as aeronaves inimigas. Dentro da condição que checa essa colisão vamos incrementar a nossa variável score para que ela registre o número de inimigos que derrubamos.

Desenhando o Placar na Tela

Vamos ao método Draw(). Após o trecho de código onde desenhamos nossos inimigos, iremos utilizar o spriteBatch mais uma vez para desenharmos nosso placar. Mas dessa vez utilizaremos sua função DrawString().

Se não nos esquecemos de nenhum detalhe podemos rodar o jogo e teremos nosso placar no canto esquero superior da tela e a cada aeronave que destruimos ele será atualizado.

Resumo

Nesta sexta parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio vimos como adicionar um placar para a contagem de inimigos que acertamos durante o jogo.

Na sétima e última parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio veremos como animar um pouco mais as cenas inserindo explosões realistas a cada colisão.

Tutorial - Nosso Primeiro Jogo 2D - Parte 5

2009-04-29T14:29:00.012-03:00

Finalmente, depois de muita espera, o tutorial do nosso primeiro jogo 2D está de volta. Tive alguns problemas com meu PC, que infelizmente "pifou" e não pude continuar postando. Como ainda não estão nos meus planos consertar meu PC, tive que tomar uma atitude quanto a continuidade dos nossos tutoriais... Instalar o Visual C# e o XNA aqui no PC do trabalho! Isso implica em ficar horas a mais "trabalhando"... rs

Neste tutorial veremos, passo a passo, como criar um jogo 2D simples. Este tutorial foi baseado nos vídeos Beginner's Guide 2D encontrados no site creators.xna.com.

Esta é a quinta parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio. Aqui veremos como calcular a colisão dos mísseis com as aeronaves inimigas e destrui-las. Também veremos como criar e atualizar nossa pontuação.

Detectando a Colisão entre os Mísseis e as Aeronaves

Atualmente no nosso jogo, quando um míssil cruza com uma aeronave inimiga nada acontece, cada um desses objetos continua seu trajeto como se nada tivesse acontecido. Não é esse efeito que desejamos durante o jogo. Gostariamos que quando o míssil encontrasse a aeronave inimiga, ambos desaparecessem indicando a colisão. Para isso, vamos ao método UpdateCannonMissiles(). Nele verificamos, para cada míssil, se o mesmo ainda está "vivo". Se estiver, apenas o "matamos" caso esteja fora da tela, que é a checagem mais básica que podemos fazer. Para checarmos se o míssil encontra a aeronave inimiga faremos uma checagem um pouco parecida. Assim, logo depois do final do escopo da checagem do caso do míssil ainda estar dentro da tela, criaremos um retângulo que é do tamanho da textura do nosso míssil, e que a cada loop do nosso jogo estará iniciado de acordo com a posição do míssil.

Agora teremos que criar outro retângulo, que compararemos com esse, para saber se eles colidem ou não. Criaremos retângulos ao redor das aeronaves inimigas, que são os objetos com os quais desejamos identificar colisões. Ainda dentro do método UpdateCannonMissiles(), logo em seguida do trecho que acabamos de escrever, faremos um loop em que, para cada aeronave inimiga, criaremos um retângulo. Testaremos também se há interseção entre esses dois retângulos e, se houver, "mataremos" tanto o míssil quanto a aeronave.

Para conseguirmo visualizar melhor as colisões, vamos alterar o valor das variáveis MaxCannonMissiles e MaxEnemyPlanes para 3. Esse modo de verificar colisões através de retângulos é o jeito mais simples de verificarmos colisões mas não é muito bom, pois a forma de nossos objetos não são retangulares o que causa algumas detecções mesmo sem haverem colisões. Se não nos esquecemos de nenhum detalhe podemos rodar nosso jogo e teremos os mísseis colidindo com as aeronaves.

Resumo

Nesta quinta parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio vimos como detectar as colisões dos mísseis de nosso Belonave com as aeronaves dos inimigos.

Deixarei para uma sexta parte do nosso tutorial como manter e atualizar a pontuação do nosso jogo e nesse finalzinho me focarei em algumas alterações que devemos fazer para melhorar a experiencia do jogo, principalmente com relação a esse recém introduzido sistema de colisões.

Alterações

Como pudemos perceber, nosso sistema de colisões está muito falho. Muito desse problema se deve ao seguinte fato: Utilizamos uma imagem grande para as aeronaves e a reduzimos no momento em que a desenhamos. Com isso, ao gerarmos o retangulo com as dimensões da aeronave, o fazemos baseado nas dimensões da imagem grande, o que causa grande erro nas nossas detecções de colisão. A alternativa mais simples que temos para esse caso é diminuir a imagem das aeronaves inimigas que adicionamos ao projeto com o nome de EnemyOne.png.

Ao baixarmos a imagem acima, temos que adiciona-la no projeto substituindo a que estavamos usando. Primeiramente podemos excluir do projeto a imagem da aeronave que já estamos usando. Faremos isso clicando com o botão direito do mouse em cima da imagem que está em Content->Sprites no Solution Explorer.

Agora podemos clicar com o botão direito na pasta Sprites e selecionar Add->Existing Item..., onde procuraremos e adicionaremos a nova imagem reduzida da aeronave.

Também teremos que fazer uma alteração no código do nosso jogo 2D. Onde desenhavamos a aeronave como sendo 65% da imagem original, podemos desenha-la sendo 100% da nova imagem redimensionada. Assim passaremos para a função Draw do spriteBatch 1.0f que é a escala que desejamos desenhar nossa aeronave.

Com essas alterações, se não nos esquecemos de nenhum detalhe podemos rodar nosso jogo e teremos as imagens no tamanho que estavam antes, mas a detecção de colisões teve uma notável melhora, pois agora estamos desenhando retângulos do tamanho das imagens que estamos desenhando.

Finalização

Na sexta parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio iremos descobrir como mantemos e atualizamos o controle da pontuação do nosso jogo.

Dream-Build-Play - O que é?

2009-03-31T11:44:00.007-03:00

"Construa o jogo dos seus sonhos e dispute com outros desenvolvedores de jogos do mundo todo!"

O Dream-Build-Play

Mais uma grande competição anual de desenvolvimento de jogos utilizando o XNA Game Studio para desenvolver jogos para o Xbox360. Ao se inscrever, cada equipe ganha uma assinatura trial do Creators Club Online de 12 meses.

- Dream-Build-Play Website

Os participantes concorrem a prêmios num total de 75 mil dólares e uma das dez melhores equipes ganhará a oportunidade de um contrato de publicação na rede Xbox LIVE.

Em 2008 houveram mais de 7800 membros da comunidade participando da competição e mais de 350 jogos completos de diversos países do mundo. O Dream-Build-Play 2009 terá início no dia 6 de abril de 2009.

Dois dos vencedores do Dream-Build-Play 2008, juntos, receberam mais de 70 mil dólares em prêmios além de estarem entre os jogos mais vendidos no Xbox LIVE Community Games Channel.

As equipes vencedoras da competição em 2008 foram o Team GAMBIT com o jogo "CarneyVale: Showtime" e o Mommy's Best Games com o jogo "Weapon of Choice".

Os trailers dos vencedores de 2008:

CarneyVale: Showtime

Weapon of Choice

Boa sorte a todos!

Resultado do Concurso de Mini-Games

2009-02-18T11:01:00.005-03:00

O concurso de mini-games da Revista oficial do Xbox360 no Brasil recebeu diversos jogos e foi um sucesso.

Cada jogo foi avaliado por representantes do Sharpgames, da Abragames, da ROX e da Microsoft Brasil de acordo com os critérios de inovação, qualidade final e diversão.

Abaixo os jogos vencedores e os links para seus downloads.

- Primeiro Lugar - Mikura, de Rafael Valle Barradas e Luciano José Firmino Jr.
- Segundo Lugar - Paraquedismo, de Diego Cordeiro Barboza
- Terceiro Lugar - Steam Pong, de Aldeir Arcanjo, Fábio Bombonato e Patryck Pabll

XNA Challenge Brasil - Anteriores

2009-01-21T20:16:00.004-02:00

Com as inscrições para o 3° XNA Challenge Brasil quase chegando ao fim, vou postar uma matéria da página do evento sobre as edições anteriores e seus vencedores. Espero que possa empolgar os interessados em participar.

http://www.xnachallenge.com.br/EdAnteriores.aspx

Edições Anteriores

Ganhador do 1º XNA Challenge – André Furtado

Clique na imagem para ampliar

O Microsoft XNA Challenge Brasil 2007 foi uma das oportunidades mais interessantes de minha trajetória profissional. Quando me inscrevi na competição, nunca havia escrito uma única linha sequer de código XNA, e decidi participar da competição assim mesmo para, na pior das hipóteses, aprender um pouco mais sobre a tecnologia. No fim das contas, o XNA me fascinou.

Utilizo-o até hoje em meu doutorado e estou considerando a equipe do XNA como um possível próximo destino para meu trabalho aqui na sede da Microsoft, em Redmond/EUA.

Na Engenharia de Software, costuma-se dizer que devemos buscar automatizar as tarefas mais rotineiras e de baixo-nível para que, ao criar um novo software, seja possível economizar tempo e investir nosso cérebro naquilo em que os humanos são realmente melhores do que as máquinas: a criatividade. Vivi isso na prática com o XNA: a facilidade de se criar um jogo completo, ou estender um já existente, foi tão grande que eu realmente pude me aventurar a fazer algo nunca antes feito: integrar reconhecimento de voz com um jogo XNA. O resultado foi o Space War Mission Commando, um jogo em que você não apenas controla sua nave com o joystick mas também dá ordens a um esquadrão aliado através de um microfone qualquer plugado no computador.

O primeiro lugar na competição foi uma grande satisfação, especialmente pela excelente qualidade dos projetos concorrentes. Como prêmio, realizei um sonho antigo: viajar a bordo de um cruzeiro pelo Caribe. Tal evento uniu o útil ao agradável (ou seria o agradável ao agradável?): palestras sobre games intercaladas com banhos de mar nas praias do Caribe! Nos bastidores do evento, conheci um dos Program Managers da equipe do XNA da Microsoft, e fui convidado para participar do Desafio XNA 4x4 da Game Developers Conference (GDC), em São Francisco/EUA, em que fui incumbido da missão de criar um jogo XNA completo, do zero, em apenas quatro dias, programado em um cercado em um dos pavilhões principais do evento. Algo como um “Big Brother da Programação de Jogos”. Ao final, a missão foi bem sucedida e ampliei ainda mais os meus contatos e meu conhecimento sobre a tecnologia.

Assista ao vídeo abaixo e veja o jogo desenvolvido

Equipe Ganhadora do 2º XNA Challenge

Clique na imagem para ampliar

Participar do II XNA Challenge foi uma grande experiência em vários aspectos. O aprendizado na criação do jogo é maior do que muitos podem pensar. O desafio está presente desde os primeiros momentos, quando a idéia está nascendo, até os minutos finais, quando se está programando aquelas últimas linhas de código. O desafio é também trabalhar em equipe, organizar bem as tarefas, é correr contra o tempo.

Participar de um XNA Challenge já é, na pior das hipóteses, aprender muito sobre criação de games, programação, sobre gerenciamento de projetos, trabalho em equipe... que são justamente as coisas que nos farão ser bons profissionais no futuro. E lógico, é se divertir um pouco, afinal, estamos fazendo games!

E junto a isso, a Microsoft oferece ótimos prêmios e a oportunidade de tornar você e o seu projeto conhecido por muita gente!

E quanto a minha viagem para o Microsoft Academic Days, bem, isso foi uma outra experiência demais. Eu pouco havia saído do meu estado natal, de repente o meu trabalho(e da minha equipe, claro) me coloca nos Estados Unidos em um cruzeiro com uma conferência de games, e ainda deu pra conhecer o México!

"Galera, pra mim, resolver participar de um XNA Challenge foi uma bela de uma idéia!"
Vítor Antonioli, integrante da equipe ganhadora do 2º XNA Challenge.

Assista ao vídeo abaixo e veja o jogo desenvolvido

Estarei torcendo para que algum de nossos leitores tenha sucesso nessa competição!

Sorte a todos!

3º XNA Challenge Brasil

2008-12-16T11:34:00.003-02:00

Foram prorrogadas as inscrições para o terceiro XNA Challenge Brasil.

Agora as inscrições podem ser feitas até o dia 31 de janeiro de 2009.

Mais informações

Dúvida - Xbox Live Community Games

2008-12-03T20:21:00.007-02:00

As principais dúvidas que surgiram entre nossos leitores nas ultimas semanas foi quais países podem vender seus jogos no Xbox Live Community Games e quando será possivel, nós, do Brasil, Uruguai e Portugal, vender nossos jogos também.

Desenvolvedores de quais países poderão vender seus jogos no Xbox Live Community Games?

Em seu lançamento, somente usuários premium do creators club dos seguintes países podiam vender seus jogos pelo Xbox Live Community Games:

Estados Unidos(claro! rs)
Canadá
Reino Unido
França
Itália
Suécia
Noruega
Dinamarca
Irlanda
Espanha
Netherlands

E nós do Brasil, Portugal, Uruguai...?

Prometeram ir expandindo o suporte e aos poquinhos irem possibilitando criadores de outros países a também vender seus jogos via o Community Games.

Em menos de 1 mês de seu lançamento já trouxeram essa realidade a usuários premium do creators club de mais três países:

Singapura
Australia
Nova Zelândia

Provavelmente, muito em breve poderemos "ganhar a vida" vendendo nossos jogos feitos com o XNA Game Studio no Xbox Live Community Games.

Concurso de Mini-Games

2008-12-03T19:54:00.005-02:00

Foram prorrogadas as inscrições para o primeiro concurso de mini-games da revista oficial do Xbox360 no Brasil.
Agora as inscrições podem ser feitas até o dia 15 de janeiro de 2009. Alteração realizada para possibilitar a participação de diversos estudantes que entram de férias, agora, no final do ano.

Alguns dos prêmios também foram divulgados:

1o lugar: Visual Studio 2008, Controller do Xbox360 sem fio, assinatura da revista Xbox360 e o livro "Beggining XNA 2.0 Game Programming - From Novice To Professional"
2o lugar: Jogo do Xbox360, Webcam e o livro "Beggining XNA 2.0 Game Programming - From Novice To Professional"
3o lugar: Jogo do Xbox360

Mais informações e o regulamento completo em: http://www.sharpgames.net/concursoROX/

Errata - Nosso Primeiro Jogo 2D - Parte 4

2008-11-18T15:14:00.004-02:00

Algumas imagens da Parte 4 do Nosso Primeiro Jogo 2D estavam erradas mas já foram consertadas.

Gostaria de agradecer ao José Roberto e ao Gilton pelo alerta do erro que passou despercebido. Acabei consertando o meu projeto mas esquecendo de atualizar as imagens do blog.

Agora tudo já está em seu devido lugar. As imagens que encontravam-se erradas eram as img_35.jpg e img_36.jpg. Em ambas faltava a exclamação que negava a condicional, ou seja, se os aviões não estivessem no retangulo que representa a tela eles deveriam ser considerados "mortos".

Aqui abaixo também estão as imagens corrigidas:

img_35

img_36

Gostaria de pedir desculpas a todos que acompanham o blog e meus tutoriais pelo ocorrido.
Leo Camello

Concurso de Mini-Games

2008-11-18T10:51:00.004-02:00

A revista oficial do Xbox360 no Brasil está lançando seu primeiro concurso de mini-games com o apoio da SharpGames e da Microsoft.

O objetivo do concurso é criar um mini-game com no máximo 100 linhas de código utilizando o XNA Game Studio que deve ser submetido ao site do concurso até o dia 30 de novembro de 2008.

A divulgação dos vencedores será feita na Revista Oficial do Xbox360 em janeiro de 2009.

Mais informações e o regulamento completo em http://www.sharpgames.net/concursoROX/

Xbox LIVE Community Games - O que é?

2008-11-12T12:24:00.004-02:00

Neste post farei uma breve introdução ao que é o Xbox LIVE Community Games.

Xbox LIVE Community Games

Agora, os jogos que fizermos, podem ser jogados por milhões de jogadores no Xbox LIVE e ainda podemos receber em dinheiro por isso.
A partir do dia 19 de novembro de 2008, jogos feitos com o XNA Game Studio, após serem revisados e aprovados, podem ser vendidos via Xbox LIVE.

Como isso Funciona?

Sendo um usuário Premuim do XNA Creators Club, será possível submeter qualquer jogo completo de Xbox360 que você criar no XNA Game Studio a comunidade do Creators Club para revisão. Outros usuários Premium irão avaliar seu jogo para certificar de que ele é seguro de jogar. Se tudo correr bem e seu jogo for aprovado, você poderá definir um preço para ele entre 200 e 800 pontos que as pessoas pagarão para baixar seu jogo no Xbox LIVE Marketplace.

Dessa maneira você pode receber em dinheiro até 70% da areecadação do seu próprio jogo e dependendo do sucesso dele ainda poderá aparecer em evidencia no Xbox360 e em propriedades online da Microsoft.

Tutorial - Nosso Primeiro Jogo 2D - Parte 4

2008-11-06T15:06:00.013-02:00

Neste tutorial veremos, passo a passo, como criar um jogo 2D simples. Este tutorial foi baseado nos videos Begginers Guide 2D encontrados no site creators.xna.com.

Esta é a quarta parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio. Aqui veremos como criar as aeronaves inimigas para que apareçam em posições randomicas do canto direito da tela.

Adicionando e Inicializando as Variáveis Relacionadas as Aeronaves

Agora vamos então começar a trabalhar para colocarmos os inimigos no nosso jogo. No arquivo Game1.cs, na classe Game1, abaixo de onde declaramos as variáveis previousgamepadstate e previouskeyboardstate iremos declarar mais uma série de variáveis ligadas as aeronaves inimigas. Assim como fizemos com os mísseis, os inimigos também terão um número máximo e um array, mas além disso teremos as velocidades mínima e máxima possiveis a uma aeronave inimiga, e a altura mínima e máxima onde é possível um inimigo aparecer. Teremos também uma variável que gerará um valor randomico para nós sempre que precisarmos.

Assim como fizemos com os mísseis, temos que inicializar nosso array de inimigos. Vamos então ao método LoadContent() e abaixo do for onde inicializamos nosso array de mísseis vamos instanciar nosso array de inimigos e inicializar cada posição desse array com o uso de um loop.

Atualizando as Aeronaves Inimigas

Depois de inicializar nossos inimigos vamos então ao método Update() e abaixo da chamada ao método UpdateCannonMissiles() vamos fazer outra chamada, só que agora ao método UpdateEnemyPlanes(). Como fizemos no caso dos mísseis, esse método ainda não existe e teremos que implementa-lo.

Para criar o nosso método vamos ao final do método Update() e depois da chave que termina esse método vamos implementar o nosso método UpdateEnemyPlanes(). Esse método irá "matar" as aeronaves inimigas assim que elas forem saindo da tela para que novas aeronaves possam ser desenhadas na tela.

Ainda estamos considerando apenas o caso de a aeronave inimiga "morrer" por sair da tela para redesenha-las. Assim ainda no método UpdateEnemyPlanes() utilizaremos um bloco else logo após o bloco if em que checamos se o inimigo está "vivo". Nesse bloco tornaremos o inimigo vivo de novo e faremos ele nascer em uma nova posição aleatória e com uma nova velocidade aleatória.

Desenhando e Alterando o Tamanho dos Inimigos na Tela

Agora já podemos desenhar as aeronaves inimigas na tela. Usaremos um overload do método Draw do SpriteBatch que nos possibilide alterar a escala da nossa Sprite visto que se desenhassemos a imagem original as aeronaves ficariam muito maiores que o resto dos objetos do jogo e não ficaria tão legal o visual do nosso jogo.

Se não nos esquecemos de nenhum detalhe podemos rodar nosso jogo e teremos aeronaves se movimentando da direita para a esquerda a alturas e velocidades aleatórias.

Resumo

Nesta quarta parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio vimos como criar e desenhar as aeronaves inimigas na tela em posições e com velocidades aleatórias e também mudando seu tamanho ao desenha-las.

Na quinta parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio veremos a destruição das aeronaves inimigas devido colisão dos nossos mísseis com as mesmas e também como manter e visualizar a pontuação em nosso jogo.

Novidade - XNA Game Studio 3.0

2008-11-03T22:53:00.007-02:00

Já está disponível para download a versão 3.0 do XNA Game Studio.

- XNA Game Studio 3.0

Essa nova versão traz diversas novas funcionalidades que continuam facilitando o desenvolvimento de jogos para PC(Windows), Xbox360 e agora também a possibilidade de desenvolver para o Microsoft Zune.

Outro aspecto que chama bastante atenção e que foi lançado junto a essa nova versão é a distribuição dos jogos por meio do Xbox Live Community Games no Xbox360 o que transforma em realidade a possibilidade de os usuários do Xbox Live verem, comprarem e jogarem jogos que você criou, desde que você seja um membro Premium do XNA Creators Club.

Algumas novidades bem interessantes nessa versão 3.0 do XNA Game Studio:

- Experimente antes de comprar: Agora pode-se criar um modo trial no jogo que criamos, o que possibilita aos jogadores experimentarem nosso jogo antes de realizar a compra.

- Convidar amigos: Podemos colocar nos jogos multiplayer do Xbox Live que criarmos uma opção para que os jogadores convidem, de dentro do jogo, seus amigos para jogarem juntos.

- Integração com o Visual Studio: A versão 3.0 do XNA Game Studio tem suporte ao C# 3.0, LINQ e a maioria das versões do Visual Studio 2008 o que facilita ainda mais a vida do desenvolvedor.

As principais diferenças entre a versão 2.0 e a versão 3.0 do XNA Game Studio podem ser encontradas aqui.

O XNA Game Studio 3.0 é requesito para a subimissão de jogos para o Xbox Live Community Games.

Tutorial - Nosso Primeiro Jogo 2D - Parte 3

2008-10-28T16:15:00.001-02:00

Neste tutorial veremos, passo a passo, como criar um jogo 2D simples. Este tutorial foi baseado nos videos Begginers Guide 2D encontrados no site creators.xna.com.

Esta é a terceira parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio. Aqui veremos como criar e desenhar os mísseis que o canhão do nosso navio irá disparar para acertar as aeronaves inimigas. Veremos também o conceito de array, como declarar uma constante e alguns tipos de loop que a linguagem C# nos oferece.

Adicionando e Inicializando Mais Algumas Variáveis

Para a criação dos mísseis que o nosso canhão irá disparar contra as aeronaves inimigas teremos que adicionar novas variáveis a nossa classe GameObject, no arquivo GameObject.cs. Se esse arquivo não estiver aberto, dê um duplo clique nele no Solution Explorer. Uma das variáveis que iremos adicionar é do tipo Vector2 e a chamaremos de velocity, ela tem o objetivo de armazenar a velocidade do deslocamento do míssil disparado. A segunda variável que iremos adicionar será do tipo bool e a chamaremos de alive, sua função é identificar se o missil ainda está "vivo", ou seja, se ele ainda pode ser vusualizado em nossa tela.

Como fizemos com nossas outras variáveis, vamos inicializa-las no construtor da nossa classe GameObject. Logo abaixo da inicialização da nossa variável center, vamos inicializar nossas variáveis velocity e depois a nossa variável alive. Como tanto o missil como o canhão são objetos do tipo GameObject devemos ter o cuidado de inicializar as variáveis com valores "neutros" que não causem nenhum efeito indesejável no jogo e podemos muda-las mais adiante, fora da classe GameObject, pelo objeto a que pertence. Iremos inicializar a nossa variável velocity como um vetor Zero e nossa variável alive com o valor false.

Instanciando e Carregando Nossos Mísseis

Agora poderemos voltar ao nosso arquivo Game1.cs e declarar na classe Game1, uma constante do tipo int e de nome maxCannonMissiles, que indicará o número máximo de mísseis que poderão aparecer na tela ao mesmo tempo, e um array GameObject[] de nome cannonMissiles, que conterá nossos mísseis. Ao declararmos uma constante usamos antes de seu tipo a palavra reservada const que caso por engano tentemos mudar o valor dessa constante durante a codificação do nosso jogo nos proporcionará erros. O tipo GameObject[] indica um array que nada mais é do que um conjunto de elementos do tipo GameObject organizados de forma sequencial e que podem ser acessados por um indice.

Depois disso vamos até o método protected override void LoadContent() e abaixo de onde inicializamos a posição do nosso canhão vamos instanciar nosso array de mísseis. Esse array terá tamanho maxCannonMissiles. Logo abaixo inicializaremos cada missil utilizando um loop para percorrer o array do início ao fim. Para aqueles que não conhecem, o loop for(,,) funciona da seguinte forma. Fornecemos a ele um inteiro que usaremos como contador que geralmente é o i, depois ele compara o contador com uma condição, que no nosso caso o loop vai acontecer enquanto i for menor que o tamanho do nosso array, e em seguida realizamos um incremento ou decremento do contador, no nosso caso o incrementamos fazendo i++. Quando a condição se torna falsa, no nosso caso quando i for maior ou igual ao tamanho do array o loop é quebrado. Dentro do nosso for vamos inicializando cada elemento do array pelo seu indice cannonMissiles[i] sabendo que o i vai variando de 0 até o tamanho do nosso array.

Atualizando Misseis, Tratando Entradas e Disparos

Tendo instanciado e inicializado nosso array e nossos misseis podemos ir ao método protected override void Update(GameTime gameTime) e dentro dele chamaremos o método UpdateCannonMissiles() logo abaixo do trecho de código onde limitamos a rotação do nosso canhão e acima do base.Update(gameTime).

O método UpdateCannonMissiles() ainda não existe e nós iremos implementá-lo. Nele faremos a atualização da posição de nossos mísseis. Então, no final do método protected override void Update(GameTime gameTime), abaixo da chave que indica seu fim, iremos implementar nosso método. Utilizaremos o loop foreach() que percorre todos os elementos do nosso array sem necessitarmos de um contador. A diferença entre ele e o loop for(,,) é que o foreach() incondicionalmente percorre o array do início ao fim e no for(,,) podemos estabelecer uma condição de parada.

Temos que criar também o método que irá disparar nossos mísseis. Para isso necessitamos de mais duas variáveis na classe Game1 e iremos declara-las logo abaixo de onde declaramos nosso array cannonMissiles. Essas variáveis que iremos declarar são do tipo GamePadState e KeyboardState e usaremos elas para guardar o ultimo estado em que o controle do xbox360 ou o teclado se encontravam a cada quadro.

Podemos voltar ao método protected override void Update(GameTime gameTime) e logo abaixo de onde limitamos a rotação do canhão e acima do método UpdateCannonMissiles() vamos checar se o jogador pressionou o botão A do controle do xbox360 ou a barra de espaço do teclado. Para que fique mais interessante, vamos impedir que hajam disparos continuos caso o jogador mantenha pressionado qualquer um desses botões checando se o estado anterior do botão A do controle do xbox360 ou a barra de espaço era "não pressionado". Caso ele pressione qualquer um desses botões de disparo chamaremos a função FireCannonMissile() que realizará o disparo do missil. Devemos também ao final de tudo atualizar o valor das nossas variáveis de estado do controle e do teclado para que funcionem corretamente a cada quadro.

Vamos agora implementar nosso método FireCannonMissile() logo abaixo do fim do método protected override void Update(GameTime gameTime) e acima do método UpdateCannonMissiles(). Ele verifica se os misseis do nosso array ainda estão na tela, caso algum não esteja podemos disparar outo missil. Assim ele define a posição inicial do missil como sendo a posição do canhão, a rotação da imagem do míssil como sendo a mesma rotação da imagem do canhão (por isso fizemos as duas imagens no mesmo sentido), e a velocidade junto a direção que o missil será atirado.

Temos que fazer uma atualização no método UpdateCannonMissiles() para que possamos "matar" os mísseis que estiverem fora da nossa tela. Logo abaixo de onde atualizamos a posição do nosso missil no método UpdateCannonMissiles() vamos checar se o missil ainda está na tela, o que é uma tarefa bem simples por termos o nosso viewportRect.

Desenhando os Mísseis na Tela

Para finalizarmos temos que desenhar os nossos misseis na tela. Assim no método protected override void Draw(GameTime gameTime), para termos os misseis desenhados antes do canhão e dar a impressão que eles estão saindo de dentro do canhão temos também que colocar o código para desenha-los antes do código para desenhar o canhão. Então usaremos um loop para desenhar cada missil do nosso array na tela.

Se não nos esquecemos de nenhum detalhe e não cometemos nenhum erro podemos rodar nosso jogo e já ver nosso canhão atirando os misseis ao pressionarmos a barra de espaço do teclado ou o botão A do controle do xbox360.

Resumo

Nesta terceira parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio vimos como criar e desenhar os mísseis que o canhão do nosso navio irá disparar para acertar as aeronaves inimigas. Vimos o conceito de array, como declarar uma constante e alguns tipos de loop que a linguagem C# nos oferece.

Na quarta parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio veremos como criar as aeronaves inimigas para que apareçam de posições randomicas do canto direito da tela.

Tutorial - Nosso Primeiro Jogo 2D - Parte 2

2008-10-21T02:20:00.000-02:00

Neste tutorial veremos, passo a passo, como criar um jogo 2D simples. Este tutorial foi baseado nos videos Begginers Guide 2D encontrados no site creators.xna.com.

Esta é a segunda parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio. Aqui veremos como criar uma nova classe para representar os outros objetos do nosso jogo. Com essa classe iremos carregar o canhão do navio no nosso projeto. Iremos também desenha-lo na tela e faze-lo girar com os comandos do teclado ou de um controle do xbox360.

Criando e Modificando a Classe GameObject

Vamos criar uma nova classe que representará os objetos do nosso jogo. Vamos clicar com o botão direito do mouse no nó que representa nosso projeto, o Belonave no Solution Explorer, clicando em Add->New Item..., selecionaremos o Template: Class na janela que aparece, daremos o Name: GameObject.cs e clicamos em Add.

Vemos que o XNA Game Studio criou para nós um arquivo praticamente vazio chamado GameObject.cs. Voltaremos então ao arquivo Game1.cs e bem no começo do arquivo temos os using. Iremos copiar todos os using de Game1.cs e coloca-los no lugar dos using que foram criados no GameObject.cs. Como cada objeto que criaremos em nosso jogo tem sua própria imagem, posição, rotação e centro, nós criaremos em nossa classe GameObject essas variáveis. A variável que representa a imagem do objeto será do tipo Texture2D e seu nome sprite, a que representa a posição do nosso objeto será do tipo Vector2 e seu nome position, assim a que representa a rotação do objeto será do tipo float e seu nome rotation e a que representa o centro da imagem é do tipo Vector2 e seu nome center.

Em seguida vamos declarar o construtor da nossa classe GameObject. O construtor é o método que chamamos ao criarmos um novo objeto. Em geral esse método inicializa tudo o que for necessário para a utilização do objeto. No caso do nosso construtor da classe GameObject, além de inicializarmos todos os seus parametros, ele irá receber uma Texture2D que será a imagem do objeto que desejamos desenhar na tela. Iniciaremos a posição como sendo zero, a rotação como sendo zero, atribuiremos a imagem que recebemos a nossa variável sprite e calcularemos o centro tendo esse as coordenadas metade da largura da imagem em X e metade da altura da imagem em Y.

Instanciando, Carregando e Desenhando o shipCannon

Agora vamos voltar ao Game1.cs. Logo abaixo de onde declaramos a backgroundTexture e o viewportRect vamos declarar nossa variável shipCannon, que será o canhão do nosso navio, e é do tipo GameObject.

Iremos inicializa-lo para podermos desenha-lo na tela do nosso jogo. No método protected override void LoadContent(), logo abaixo do Load<>() que fizemos para o backgroundTexture vamos instanciar o shipCannon como um novo GameObject que recebe um Load<>() da imagem do shipCannon e logo após isso vamos inicializar a posição do nosso canhão para posiciona-lo junto ao nosso navio desenhado no backgroundTexture.

Vamos ao método protected override void Update(GameTime gameTime) do Game1.cs, adicionaremos o código necessário para rotacionar o nosso canhão e assim podermos mirar nos nossos inimigos. Como vimos no nosso primeiro tutorial o método Update(GameTime gameTime) é o responsável por atualizar nosso jogo a cada quadro, é nele que codificamos todas as alterações de lógica que queremos fazer em cada objeto do jogo. Vamos adicionar primeiramente o código pare entrada do controle do xbox360 e após o código para entrada do teclado. Esses códigos farão nosso canhão rodar tendo seu centro como eixo. No caso do controle do xbox360, a rotação ocorre de acordo com a variação da alavanca para a esquerda e para a direita. No caso do teclado ocorre quando as teclas da direita ou da esquerda forem pressionadas. O código #if !xbox e #endif faz com que o trecho de código entre eles seja compilado em caso de atender a condição que no caso é ser diferente de xbox. O método Clamp() do MathHelper serve para limitarmos a rotação do nosso canhão.

Para desenharmos o canhão de nosso navio na tela, vamos ao método protected override void Draw(GameTime gameTime) mas não usaremos o mesmo Draw() do spriteBatch que usamos para o backgroundTexture, usaremos um overload do método que aceita outros argumentos. A versão que usaremos nesse caso recebe a imagem, a posição, o retangulo que é um argumento opicional, a cor, a rotação, a origem da rotação, a escala, efeitos e a profundidade.

Se não nos esquecemos de nada e nem cometemos nenhum erro podemos rodar nossa aplicação. Veremos o nosso navio já com seu canhão e esse atende as entradas do teclado e do controle do xbox360.

Resumo

Nesta a segunda parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio vimos como criar uma nova classe para representar os outros objetos do nosso jogo. Instanciamos essa classe e carregamos o canhão do navio no nosso projeto. Também o desenhamos na tela e o fizemos girar com os comandos do teclado ou de um controle do xbox360.

Na terceira parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio veremos como criar e desenhar os mísseis que o canhão do nosso navio irá disparar para acertar as aeronaves inimigas. Veremos também o conceito de array, como declarar uma constante e alguns tipos de loop que a linguagem C# nos oferece.

XNA Challenge Brasil - O que é?

2008-10-17T16:17:00.005-03:00

Neste post falarei um pouquinho sobre o XNA Challenge Brasil.

O XNA Challenge Brasil

É o maior concurso brasileiro de desenvolvimento de jogos para PCs e XBOXs utilizando a plataforma XNA Game Studio. Organizado pela Microsoft, incentiva estudantes, professores e entusiastas a criarem jogos com o XNA Game Studio abordando determinados temas.

Atualmente este concurso encontra-se em sua terceira edição e as inscrições para esta edição estão abertas.

- 3° XNA Challenge Brasil

A temática desse ano é "Resolver os problemas mais difíceis do Mundo" que são baseados nos desafios identificados pela ONU:

Pobreza
Saúde Materna
Desenvolvimento Colaborativo
Educação
Igualdade entre Gêneros
Aids e outras Enfermidades
Mortalidade Infantil
Sustentabilidade

Ao participar do XNA Challenge Brasil, a equipe também poderá participar do Imagine Cup 2009 na categoria Desenvolvimento de Jogos, com o mesmo projeto pois o tema é o mesmo e os critérios de classificação são similares.

O Concurso

O XNA Challenge Brasil é dividido em três etapas.

A primeira etapa é classificatória onde 10 equipes serão selecionadas para as semifinais. O prazo de submissão do jogo será até o dia 15/12/08 as 23:59.

A segunda etapa é a fase semi final onde 5 equipes serão selecionadas para a final. Essas equipes devem submeter um resumo da implementação do jogo, demo do jogo no formato, video do jogo e o código-fonte do jogo até o dia 26/01/09 as 23:59.

A terceira etapa é a fase final do concurso. Nela, as 5 equipes finalistas deverão apresentar seus jogos pessoalmente para a comissão julgadora. Deverão também enviar no dia da apresentação final um resumo descritivo da implementação, o jogo final e o codigo-fonte do mesmo, alé de uma apresentação em powerpoint.

A Premiação

Haverá premiação para os três primeiros lugares e para um escolhido do juri popular. O escolhido pelo juri popular será escolhido pela platéia no dia da apresentação dos cinco finalistas e receberá um kit com um controle do Xbox360 sem fio e um jogo Microsoft para PC para cada participante da equipe. O terceiro lugar recebe um kit contendo Lifechat VX 3000 e um jogo Microsoft para PC para cada participante da equipe. O segundo lugar da competição recebe um kit contendo mouse SideWinder e Lifechat VX 3000 para cada integrante da da equipe. O prêmio para a equipe que vencer o XNA Game Challenge é uma viagem internacional para um representante da equipe conhecer a sede da Microsoft em Seattle e um Xbox para cada outro integrante.

Tutorial - Nosso Primeiro Jogo 2D - Parte 1

2008-10-14T01:48:00.001-03:00

Neste tutorial veremos, passo a passo, como criar um jogo 2D simples. Este tutorial foi baseado nos videos Begginers Guide 2D encontrados no site creators.xna.com.

Esta é a primeira parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio. Aqui vamos rever como criar um novo projeto e como adicionar imagens ao nosso projeto. Vamos ver também como carregar e desenhar na tela uma imagem de fundo no nosso jogo.

No nosso jogo teremos basicamente um navio, seus mísseis e aviões. O objetivo do jogo é, controlando o canhão do navio, conseguir acertar o maior número de aviões que passarem voando na tela.

Criando um Novo Projeto

Primeiramente vamos começar criando um novo projeto. No Visual C# 2005 Express Edition vamos no menu File->New Project..., ou apenas Ctrl+Shift+N. Selecionaremos como Project Type: XNA Game Studio 2.0 e como Template: Windows Game. O Name do projeto eu chamei de Belonave e procurando na Wikipédia temos a seguinte definição: "Belonave é a designação de qualquer tipo de embarcação, fluvial ou marítima, para utilização em combate.", o que tem muito a ver com nosso jogo. Também selecionaremos o Location que acharmos melhor para armazenarmos nosso projeto em nosso PC. Em Solution escolheremos a opção Create a new Solution, deixaremos a opção Create directory for solution marcada e clicaremos em OK.

Salvando as Imagens e Adicionando ao Projeto

Agora que criamos nosso novo projeto, já podemos ver no Solution Explorer os arquivos que o compõem. Ainda não modificaremos nenhum arquivo. Antes vamos baixar e adicionar ao projeto as imagens que usaremos em nosso jogo. Clique em cada imagem abaixo e, com o botão direito do mouse, salve elas em seu PC com os seguintes nomes:

backgroundTexture:

shipCannon:

cannonMissile:

enemyPlane:

Para organizarmos melhor nossas imagens, após telas salvo em nosso PC, vamos voltar ao Visual C# 2005 Express Edition e vamos clicar com o botão direito do mouse em Content, no Solution Explorer, Add->New Folder e nomearems essa nova pasta como Sprites. Mais uma vez na Wikipédia encontramos a seguinte definição: "Sprite é um objeto gráfico bi ou tridimensional que se move numa tela sem deixar traços de sua passagem.". Nessa pasta ficarão armazenadas todas as imagens que usaremos em nosso projeto.
Clicando com o botão direito do mouse na pasta recém criada, no Solution Explorer dentro de Content, Add->Existing Item e vamos ao local onde salvamos nossas imagens. Selecionaremos e adicionaremos cada uma delas.

Carregando e Desenhando a Imagem de Fundo

Depois que já tivermos todas as imagens adicionadas ao projeto na pasta Sprites vamos começar a modificar nosso código. Caso ainda não esteja aberto, abriremos o arquivo Game1.cs clicando duas vezes nele no Solution Explorer. Com o arquivo aberto, procuraremos a classe Game1 dentro dele. Abaixo de GraphicsDeviceManager graphics; iremos declarar a variável que será responsável pela imagem de fundo do nosso jogo. Essa variável será do tipo Texture2D e se chamará backgroundTexture. Abaixo de nossa variável backgroundTexture vamos declarar outra variável, que será responsável por definir a área máxima que um objeto poderá ter. Esta será do tipo Rectangle e a chamaremos de viewportRect. Essas variáveis que acabamos de declarar ficaram acima do SpriteBatch spriteBatch; que é uma classe do XNA framework que utilizaremos para desenhar todas as imagens que usamos nesse tutorial.

Para carregarmos nossa imagem de fundo no nosso jogo, vamos ao método protected override void LoadContent() que como vimos em nosso primeiro tutorial, é um método que é chamado quando o jogo inicia e ele carrega todas as imagens que precisamos durante o jogo. Logo abaixo de spriteBatch = new SpriteBatch(GraphicsDevice); vamos carregar nossa imagem de fundo na nossa variável backgroundTexture. Para isso vamos usar o método Load<>() da classe Content Manager.

Ainda no método protected override void LoadContent(), abaixo da atribuição que acabamos de fazer para carregar nossa imagem de fundo, vamos instanciar nosso viewportRect atribuindo a ele as nossas medidas da tela começando em (0, 0) e termonando em (width, height) da Viewport.

Agora que a carregamos, desenharemos a nossa imagem de fundo na tela. Para isso usaremos a classe SpriteBatch spriteBatch; e nosso Rectangle viewportRect; que acabamos de inicializar. Vamos então ao método protected override void Draw(GameTime gameTime). Como vimos no nosso primeiro tutorial o método Draw() é o responsável por redesenhar a tela a cada quadro. É nele que a tela é limpa e que desenhamos cada objeto que desejamos que apareça no nosso jogo. Abaixo do graphics.GraphicsDevice.Clear(Color.CornflowerBlue); vamos acrescentar o bloco que nos permite desenhar na tela.
Iniciamos com o método Begin() do spriteBatch, desenhamos com o método Draw() do spriteBatch e ao terminarmos finalizamos com o método End() do spriteBatch. No método Begin() podemos passar como parametro o SpriteBlendMode.AlphaBlend que nos permite desenhar imagens com transparencia. No método Draw() iremos passar como parametros nossa textura, um retangulo que especifica onde a sprite será desenhada, e uma cor que por default estamos usando o branco. O método End() não recebe parametros.

Se não tivermos esquecido de nada, podemos rodar nossa aplicação sem erros e conseguiremos ver a janela do nosso jogo já com a nossa imagem de fundo no lugar.

Resumo

Nesta primeira parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio revimos como criar um novo projeto e como adicionar imagens ao nosso projeto. Vimos como carregar e desenhar na tela uma imagem de fundo no nosso jogo.

Na segunda parte do nosso tutorial de como criar um jogo 2D com o XNA Game Studio veremos como criar uma nova classe para representar os outros objetos do nosso jogo. Com essa classe iremos carregar o canhão do navio no nosso projeto. Iremos também desenha-lo na tela e faze-lo girar com os comandos do teclado ou de um controle do xbox360.

Imagine Cup - O que é?

2008-10-11T14:37:00.007-03:00

Neste post falarei um pouquinho de uma das maiores competições de desenvolvimento de jogos com o XNA Game Studio.

A Imagine Cup

É uma competição anual patrocinada e organizada pela Microsoft. Ela une jovens interessados em tecnologia ao redor do mundo com o objetivo de resolver alguns desafios. Ela tem diversas categorias e uma delas é a de desenvolvimento de jogos.

- Imagine Cup Website

Essa competição foi iniciada em 2002 e tem aumentado rapidamente no número de competidores. Em 2008 houveram 210.000 inscritos de mais de 100 países para competir em uma das nove categorias da competição.

A Categoria Desenvolvimento de Jogos

Nessa categoria a equipe competidora deve inventar um jogo usando o XNA Game Studio e o Visual Studio. A cada ano mudam os temas que os jogos devem ilustrar. Para 2009 o tema é "Imagine um mundo onde a tecnologia ajude a resolver os problemas mais dificeis que enfrentamos hoje."

Em 2008 o tema foi Sustentabilidade Ambiental e a equipe vencedora foi brasileira. A equipe Mother Gaia Studio venceu a final do Imagine Cup que ocorreu em Paris com seu jogo City Rain.

City Rain é um jogo de pixel art 2D isométrico que mistura um puzzle criativo com um simulador de planejamento urbano focado na ecologia e na sustentabilidade ambiental. No jogo você é o prefeito de uma cidade que deve decidir qual é a melhor maneira de construir uma cidade lucrativa e também ambientalmente sustentavel.

A Competição

O Imagine Cup acontece em três etapas sendo a primeira qualificatória, a segunda as semi finais e a terceira as finais. Em 2009 as finais ocorrerão no Egito. Na primeira etapa as equipes criam e enviam o material de seu jogo que deve consistir basicamente em um demo jogável com pelo menos uma fase implementada que consiga passar a jogabilidade do jogo, a descrição do jogo e as instruções. Na segunda etapa a equipe deve submeter o jogo completo e um sumário do jogo. E na terceira etapa cada equipe terá 30 minutos para apresentar seu jogo a uma banca que irá julga-lo.

A Premiação

Os premios para os semifinalistas é um Premium Membership de 12 meses no Creators Club para cada integrante da equipe. Caso a sua equipe vá para a final ela ganha uma viagem para a cidade onde será realizada a final incluindo passagens, estadia e alimentação. A equipe que vencer a final ainda leva 25 mil dolares para serem divididos igualmente entre os integrantes da equipe, e um pacote com livros e um voucher para Certificação da Microsoft. A equipe na segunda posição recebe 10 mil dolares e a que fica em terceiro 5 mil dlares.

Eu já me empolguei de participar, e você?

Tutorial - Nossa Primeira Aplicação - Extra

2008-10-08T15:34:00.001-03:00

Hoje estou postando aqui no blog uma parte extra do nosso tutorial Nossa Primeira Aplicação. Recebi alguns pedidos e algumas perguntas de como tratamos entradas do teclado e do controller do XBOX360. Nesse post mostrarei como trata-las fazendo nosso aviãozinho voar mais alto ou mais baixo, ou seja, daremos uma movimentação vertical a ele além da movimentação horizontal que ele já possui. Em seguida faremos com que ele não saia da tela nos limites superiores e inferiores.

Abriremos novamente o Visual C# 2005 Express Edition e o nosso projeto, ou pela Start Page em Recent Projects, ou em File->Open Project... se sabemos onde salvamos nosso projeto.

Voltamos a ter nosso Game1.cs aberto. Caso o Game1.cs não esteja aberto é só dar um duplo clique em Game1.cs no Solution Explorer.

Movimentando de Acordo com o Input

Com o XNA Game Studio podemos ter diversos inputs diferentes, seja ele o controller do XBOX360, o teclado do PC ou até mesmo os botões do Zune. Aqui, por enquanto, cobriremos somente as duas primeiras entradas, o teclado e o controller. Caso você não tenha um controller do XBOX360 em casa, não será possivel testar se o código que você fez para o controller funciona corretamente, caso tenha é só conectar o controller do seu XBOX360 em uma porta USB do seu PC e testar o código que escreveremos aqui.

Vamos ao método Update() da nossa classe Game1 pois é nesse método que quando pressionada a tecla Up ou Down do teclado ou do Dpad do nosso controller atualizaremos a posição do nosso avião. Como ainda lembramos do nosso sistema de coordenadas da tela, sabemos que ao pressionarmos o botão Down do teclado ou do Dpad temos que incrementar de um valor o Y da posição do nosso avião e ao pressionarmos o botão Up do teclado ou do Dpad temos que decrementar de um valor o Y da posição do nosso avião.

Devemos inserir o código no método Update() acima das modificações que haviamos feito anteriormente. Assim fazemos o teste com o if onde nossa condição é se o estado do teclado ou do Dpad tiver pressionado os botões Down ou Up fazemos planePosition.Y += ou -= 2.5f.

Se rodarmos nossa aplicação e pressionarmos o Down ou o Up veremos que o avião se move para baixo ou para cima ainda respeitando os limites laterais da nossa tela mas ultrapassando seus limites superiores e inferiores. Como corrigir isso?

Respeitando os Limites da Tela

Uma das opções é fazermos uma checagem da posição do aviãozinho com relação ao limite superior ou inferior da tela.

Se sua posição em Y for maior ou menor do que os limites da tela em Y igualaremos sua posição em Y ao limite em Y da tela.

Talvez, para ficar mais interessante, fosse legal darmos uma pequena rotação na nossa imagem no sentido horário caso esteja descendo e no sentido anti-horário caso esteja subindo.

Rotacionando nossa Imagem

Para realizarmos essa rotação precisaremos de uma outra variável na nossa classe. Iremos declarar a nossa variável do tipo float, planeRotation, junto com as outras variáveis da nossa classe. Não iremos inicializá-la ainda.

Essa variável receberá um valor em radianos da anlgulação que queremos que a nossa imagem gire.

Agora novamente no início do método Update() iremos inicializar nossa variável planeRotation com o valor 0.0f, para que a cada loop se não pressionarmos Down ou Up nossa imagem seja desenhada da maneira original.

E dentro de cada bloco em que checarmos se pressionamos Down ou Up do teclado ou do Dpad do controller iremos atribuir uma angulação de acordo com o movimento que estamos fazendo.

Ainda temos que passar para o spriteBatch essa atualização na rotação que fizemos da nossa imagem para que ele possa desenha-la levando em consideração essas modificações. Então no método Draw():

Agora está quase tudo ok. Se rodarmos e mexermos um pouquinho veremos o porque nossa aplicação ainda não está 100%.

Ao vermos essa imagem até parece que está tudo bem com nossa aplicação, se algum de vocês já tiver rodado sua aplicação verá que não está tudo bem pois a imagem a esquerda mostra a posição do aviãozinho subindo após sua imagem estar flipada e a da direita mostra ele descendo após sua imagem estar flipada, deveria ser o contrário!

Corrigiremos isso invertendo a rotação caso a imagem estaja flipada, ou seja, ao desenharmos, quando fazemos o check se a imagem está flipada, antes iremos fazer com que o nosso planeRotation = -planeRotation.

Agora tudo estará rodando como desejamos. Podemos rodar e ver os resultados.

Resumo

Nesta parte extra do nosso tutorial Nossa Primeira Aplicação vimos como tratar a entrada do teclado e tembém uma entrada vinda do controller do XBOX360. Vimos também um pouquinho de como rotacionamos uma imagem que estamos desenhando na tela além de masi alguma pratica com blocos condicionais.

Espero que gostem e que estejam conseguindo fazer coisas interessantes a partir das noções que foram dadas aqui nesse primeiro tutorial que nos dá uma visão bem básica do XNA Game Studio e de aplicações 2D utilizando essa ferramenta.

XSI Mod Tool - O Que é?

2008-10-08T11:02:00.000-03:00

Neste post estaremos falando um pouco sobre a SOFTIMAGE|XSI Mod Tool, mais uma vez uma sugestão muito interessante de conteúdo vindo da nossa comunidade no Orkut.

A XSI Mod Tool

É uma aplicação gráfica 3D da SOFTIMAGE onde podemos desenvolver conteúdo para nossos jogos e para mods de jogos. Traz as mesmas ferramentas de modelagem e animação 3D do XSI 6, que é a ferramenta usada pelos profissionais no mercado para criar o conteúdo gráfico dos jogos AAA como Half Life 2. A grande vantagem do Mod Tool é que além de sua qualidade ela é grátis.

A Mod Tool é uma ferramenta muito interessante para nós que desenvolvemos jogos usando o XNA Game Studio pois nos fornece total integração com o framework através de um plug-in. Assim o conteúdo criado é exportado facilmente para os nossos projetos e usados no nosso código da mesma maneira que usamos imagens.

Como começar?

Para começa o desenvolvimento de assets para nossos jogos devemos fazer o download da ferramenta. É recomendado o download de além da Mod Tool, do Mod Tool 6.X Motor, que é um patch para a Mod Tool, e do CROSSWALK, que ajuda a importar e exportar conteúdo do 3DS Max e Maya para o Mod Tool.

É necessário um rápido registro para a ativação e o download da ferramenta.

- SOFTIMAGE|XSI Mod Tool Download

Após o dowload, no site da Mod Tool existem diversos recursos de aprendizado da ferramenta, dentre eles alguns video tutorials muito interessantes. Tem um tutorial especialmente para desenvolvedores XNA e um arquivo de documentação de como integrar o XSI Mod Tool e o XNA.

- Quick Start: XNA Development Video
- XNA Game Studio Integration in SOFTIMAGE|XSI

Esse pdf de como integrar o XNA no XSI é bem explicativo e aborda desde uma explicação e como preparar o ambiente junto ao projeto do XNA até como mostrar o modelo, passando por sua modelagem, animação e importação.

Para Saber Mais

Maiores informações podem ser obtidas no site da Mod Tool.

- SOFTIMAGE|XSI Mod Tool Website

Agradecimento

Gostaria de agradecer ao Renan Recapix pela sugestão e dica e fica aqui o convite de futuramente desenvolvermos juntos uma série de tutoriais que abordem desde a modelagem no Mod Tool, sua inclusão no projeto, até a programação e desenvolvimento do jogo.

Abraços a todos
Leo Camello